myvtm/Module/mod_mediacontroller/mod_mediacontroller.cpp

#include "stdafx.h"
#include "y2k_time.h"
#include "capture.h"
#include "Event.h"
#include "CommEntityUtil.hpp"
#include "SpUtility.h"
#include "fileutil.h"
#include "brightnessinfo.h"
#include "SpDefine.h"

#ifdef RVC_OS_WIN
#include "iaudiorenderinterface.h"
#include <Windows.h>
#include <Dbt.h>
#include <setupapi.h>
#include <initguid.h>
#include <cfgmgr32.h>
#include <devguid.h>
#else
#include <sys/socket.h>
#include <sys/types.h>
#include <asm/types.h>
#include <linux/netlink.h>
#include <linux/socket.h>
#endif

#include "../mod_snapshot/Event.h"
#include "mod_mediacontroller.h"
#include "../mod_interactivecontrol/Event.h"
#include "../mod_recorder/Event.h"
#include "../mod_counterconnector/Event.h"
#include "../mod_sipphone/Event.h"
#include "../mod_SalesRecorder/Event.h"
#include "../mod_evtconverter/Event.h"

#ifndef AUTOMATCH_CAMERA_ENV
#define AUTOMATCH_CAMERA_ENV	"ENV_"
#endif

#ifndef AUTOMATCH_CAMERA_OPT
#define AUTOMATCH_CAMERA_OPT	"OPT_"
#endif

#ifndef MAX_PATH
#define MAX_PATH 260
#endif

#ifndef RVC_MEDIADEV_STATUS_CHECK_TIMER
#define RVC_MEDIADEV_STATUS_CHECK_TIMER 1
#endif // !RVC_MEDIADEV_STATUS_CHECK_TIMER

#ifndef RVC_CAMERA_OFF_TIMER
#define RVC_CAMERA_OFF_TIMER 3
#endif // !RVC_CAMERA_OFF_TIMER

#ifndef RVC_CAMERA_CAP_PROCESS
#define RVC_CAMERA_CAP_PROCESS 4
#endif // !RVC_CAMERA_CAP_PROCESS

#ifndef RVC_MIN_CAMERA_BRIGHNESS
#define RVC_MIN_CAMERA_BRIGHNESS 30
#endif // !RVC_MIN_CAMERA_BRIGHNESS

#ifndef RVC_DEFAULT_CAMERA_BRIGHNESS
#define RVC_DEFAULT_CAMERA_BRIGHNESS 50
#endif // !RVC_DEFAULT_CAMERA_BRIGHNESS

#ifndef RVC_DEFAULT_KERNEL_VERSION
#define RVC_DEFAULT_KERNEL_VERSION "4.19.0-arm64-desktop"
#endif

#ifndef szMailslot
#define szMailslot "\\\\.\\mailslot\\107F37CC-D88C-4BD2-9675-CB965F99BF99"
#endif

#ifndef RVC_BUFFER_SIZE
#define RVC_BUFFER_SIZE 256 
#endif // !RVC_BUFFER_SIZE

#ifndef RVC_MAX_PAYLOAD
#define RVC_MAX_PAYLOAD 128 
#endif

#ifndef NETLINK_RVC
#define NETLINK_RVC 17
#endif


#ifdef RVC_OS_WIN
typedef HRESULT(__stdcall* PFNREGISTERSERVER)(void);
typedef HRESULT(__stdcall* PFNUNREGISTERSERVER)(void);
#endif


#ifndef RVC_DEFAULT_KERNEL_VERSION
#define RVC_DEFAULT_KERNEL_VERSION "4.19.0-arm64-desktop"
#endif


#ifdef RVC_OS_WIN
static void __audio_render_log(audiorender_loglevel elevel, void* user_data, const char* fmt, va_list arg)
{
	int n = vsnprintf(NULL, 0, fmt, arg);
	if (n >= MAX_PATH) {
		char* buf = (char*)malloc((size_t)(n + 1));
		vsnprintf(buf, n + 1, fmt, arg);
		DbgWithLink((LOG_LEVEL_E)elevel, LOG_TYPE_SYSTEM)("%s", buf);
		free(buf);
	}
	else{
		char strlog[MAX_PATH] = {0};
		vsnprintf(strlog, MAX_PATH, fmt, arg);
		DbgWithLink((LOG_LEVEL_E)elevel, LOG_TYPE_SYSTEM)("%s", strlog);
	}
}
#else
static void __audiomgrlog(void* user_data, audiomgr_loglevel elevel, const char* fmt, va_list arg)
{
	int n = vsnprintf(NULL, 0, fmt, arg);
	if (n >= MAX_PATH) {
		char* buf = (char*)malloc((size_t)(n + 1));
		vsnprintf(buf, n + 1, fmt, arg);
		DbgWithLink((LOG_LEVEL_E)elevel, LOG_TYPE_SYSTEM)("%s", buf);
		free(buf);
	}
	else{
		char strlog[MAX_PATH] = {0};
		vsnprintf(strlog, MAX_PATH, fmt, arg);
		DbgWithLink((LOG_LEVEL_E)elevel, LOG_TYPE_SYSTEM)("%s", strlog);
	}
}
#endif

static int GetFormatString(char* strVala, size_t uValaLen, char* strValb, size_t uValbLen, const char* pSrc, size_t uSrcLen, char cWord)
{
	int iRet = -1;
	if (NULL == pSrc || 0 == uSrcLen || MAX_PATH < uSrcLen) {
		return iRet;
	}

	char strBuffer[MAX_PATH] = { 0 };
	memcpy(strBuffer, pSrc, uSrcLen);
	char* pIndex = NULL;
	if (pIndex = strrchr(strBuffer, cWord)) {
		char* pHash = pIndex + sizeof(char);
		*pIndex = '\0';
		if (NULL != pHash) {
			memcpy(strVala, strBuffer, pIndex - strBuffer);
			memcpy(strValb, pHash, strlen(pHash));
			iRet = 0;
		}
	}

	return iRet;
}


static void LogTransToCMSEvt()
{
	static bool blogevt = false;
	if (false == blogevt) {
		LogWarn(Severity_Low, Error_Debug, LOG_EVT_JSOCCUPYCAMERA_REQUEST, "js occupy camera request evt.");
		blogevt = true;
	}
}

CMediaControllerEntity::CMediaControllerEntity(): m_capture(NULL), m_salesaudio_capture(NULL), m_lCaptureEnvCount(0), m_lCaptureEnvOptCount(0), m_lCaptureOptCount(0),
	m_pHMClient(NULL),m_pMediaControllerChannel(NULL),m_bIsRemoteRecord(false), m_bHasStartSpeakerRender(false), m_bConnectedAssist(false)
{
#ifdef RVC_OS_WIN
	m_pAudioRenderObj = NULL;
	m_bSpeakerCap = true;
#else
	m_env_mutex = PTHREAD_MUTEX_INITIALIZER;
	m_opt_mutex = PTHREAD_MUTEX_INITIALIZER;
	m_envopt_mutex = PTHREAD_MUTEX_INITIALIZER;
	m_pAudioCap = NULL;
#endif

	m_iCamTimeout = CAMERA_TIMEOUT;
	m_iDelayTime = RVC_MAX_DELAY_TIME;
	m_interValTime = RVC_CAM_INTERVAL_TIME;
	m_iAudioTimeout = AUDIO_BUG_THRESHOLD_TIME;
	m_bOnBusiness = false;
	m_bJsOccupyCamera = false;
	m_bCameraOffTimerOn = false;
	m_bVirtualCamOpened = false;
	m_eDeviceType = eStand2sType;
	m_nCameraErrorCode = Error_Succeed;
	memset(&conf, 0, sizeof(capture_config_t));
	memset(&m_sales_audio_conf, 0, sizeof(rvc_audio_capture_config_t));

#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
	m_PhotoSaveDir = "";
	m_bPostCapInfo = false;
#endif
#endif

	m_strHttpServerAddr = SpDefine::CenterConfigTotal;
	m_strHttpServerAPI = RVC_UPDATE_CAMERABRIGHNESS_HTTP_API;
	m_iHttpTimeOut = RVC_HTTPTIMEOUT;
	m_strAppVersion = NULL;
	m_strTerminalId = NULL;
	m_bsynchronized = false;
}

void CMediaControllerEntity::OnSysVarEvent(const char *pszKey, const char *pszValue,const char *pszOldValue,const char *pszEntityName)
{
	if (_stricmp(pszKey, SYSVAR_CALLSTATE) == 0)
	{
		CSimpleStringA strState;
		GetFunction()->GetSysVar("UIState", strState);
		if ('C' == pszValue[0]) {
			StartAllCameras(true);
		}
		else if ('O' == pszValue[0]){
			if (strState.GetLength() > 0 && strState[0] == 'M') {
				if (eCameraOpened == m_eCameraState) {
					DelayCloseCameras();
				}
			}
		}
	}
}

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

	//is Pad Version
	m_eDeviceType = RvcGetDeviceType();
	g_eDeviceType = m_eDeviceType;
	
#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 failed!");
			return;
		}
	}
#endif

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

	SetCameraSysVar(CAMERA_STATE_INIT);

	int i = 0;

	m_arrListener.Init(16);
	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_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_MOD_SALESRECORDER_STARTED_SUCCESS, NULL, false);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_Middle, Error_IgnoreAll, LOG_EVT_BEGIN_HANDLE_BUSINESS, NULL, false);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_Middle, Error_IgnoreAll, LOG_EVT_END_HANDLE_BUSINESS, NULL, false);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_MOD_FACETRACKING_STARTED_SUCCESS, NULL, false);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_Middle, Error_IgnoreAll, EVENT_MOD_CONNECT_BEGAIN_RECORD_CALL, NULL, false);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTCAMERACAPTURE, NULL, false);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STOPCAMERACAPTURE, NULL, false);
	GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_MEDIACONTROLLER_NOMATCHED_RESOLUTION, NULL, false);
	
	pTransactionContext->SendAnswer(Error_Succeed);
}


bool CMediaControllerEntity::HandleVirtucalCamMsg(const char* strMsg)
{
	bool bRet = false;
	if (NULL == strMsg) {
		return bRet;
	}

	if (strstr(strMsg, "Start")) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Start virtual Camera %s.", strMsg);
		m_bVirtualCamOpened = true;
		StartAllCameras();
		bRet = true;
	}
	else if (strstr(strMsg, "Stop")) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Stop virtual Camera %s.", strMsg);
		m_bVirtualCamOpened = false;
		CSimpleStringA strState;
		GetFunction()->GetSysVar("UIState", strState);
		if (strState.GetLength() > 0 && strState[0] == 'M') {
			if (eCameraOpened == m_eCameraState) {
				DelayCloseCameras();
			}
		}
		bRet = true;
	}
	else {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("virtual camera send message %s.", strMsg);
	}

	return bRet;
}

#ifdef RVC_OS_WIN
static bool GetDestCameraDeviceID(char* strdeviceID, uint32_t ulen, const char* strdevicename, uint32_t unamelen)
{
	bool bret = false;
	//Win10 摄像头在设备管理器在摄像头类
	HDEVINFO hDevInfoSet = SetupDiGetClassDevs(&GUID_DEVCLASS_CAMERA, NULL, NULL, DIGCF_PRESENT);
	if (hDevInfoSet == INVALID_HANDLE_VALUE) {
		return bret;
	}

	SP_DEVINFO_DATA DeviceInfoData = { 0 };
	DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
	if (!SetupDiEnumDeviceInfo(hDevInfoSet, 0, &DeviceInfoData)) {
		//Win8 摄像头在设备管理器在图像设备类
		hDevInfoSet = SetupDiGetClassDevs(&GUID_DEVCLASS_IMAGE, NULL, NULL, DIGCF_PRESENT);
		if (hDevInfoSet == INVALID_HANDLE_VALUE) {
			return bret;
		}
	}

	for (DWORD i = 0; SetupDiEnumDeviceInfo(hDevInfoSet, i, &DeviceInfoData); i++) {
		memset(strdeviceID, 0, ulen);
		if (CM_Get_Device_ID(DeviceInfoData.DevInst, strdeviceID, ulen, 0) == CR_SUCCESS) {
			bret = true;
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%d Device ID: %s.", i, strdeviceID);
			char szName[MAX_PATH] = { 0 };
			if (SetupDiGetDeviceRegistryProperty(hDevInfoSet, &DeviceInfoData, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, sizeof(szName), NULL)) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%d camera friendlyname is %s.", i, szName);
				if (strdevicename && (strstr(strdevicename, szName))) {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get dest camera[%s] deviceid success.", szName);
					break;
				}
			}
		}
	}

	SetupDiDestroyDeviceInfoList(hDevInfoSet);

	return bret;
}

static bool SetDeviceState(const char* pstrHardwareID, bool bEnable) 
{
	HDEVINFO hDevInfoSet = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_ALLCLASSES | DIGCF_PRESENT);
	if (hDevInfoSet == INVALID_HANDLE_VALUE) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetupDiGetClassDevs INVALID_HANDLE_VALUE(%d).", GetLastError());
		return false;
	}

	SP_DEVINFO_DATA DeviceInfoData = { 0 };
	DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);

	for (DWORD i = 0; SetupDiEnumDeviceInfo(hDevInfoSet, i, &DeviceInfoData); i++) {
		char strDeviceInstanceId[MAX_PATH] = { 0 };
		if (SetupDiGetDeviceInstanceId(hDevInfoSet, &DeviceInfoData, strDeviceInstanceId, sizeof(strDeviceInstanceId) / sizeof(char), nullptr)) {				
			if (0 == strcmp(strDeviceInstanceId, pstrHardwareID)) {
				if (bEnable) {
					// 启用设备
					if (CM_Enable_DevNode(DeviceInfoData.DevInst, 0) != CR_SUCCESS) {
						SetupDiDestroyDeviceInfoList(hDevInfoSet);
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CM_Enable_DevNode failed!");
						return false;
					}
				}
				else {
					// 禁用设备
					if (CM_Disable_DevNode(DeviceInfoData.DevInst, 0) != CR_SUCCESS) {
						SetupDiDestroyDeviceInfoList(hDevInfoSet);
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CM_Disable_DevNode failed!");
						return false;
					}
				}
			}
		}
	}

	SetupDiDestroyDeviceInfoList(hDevInfoSet);

	return true;
}


static void RefreshVirtualCameraList(const char* strdevicename, uint32_t unamelen)
{
	char strId[MAX_PATH] = { 0 };
	if (GetDestCameraDeviceID(strId, MAX_PATH, strdevicename, unamelen)) {
		if (SetDeviceState(strId, false)) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("摄像头[%s]禁用成功.", strId);
			Sleep(3000);
			if (SetDeviceState(strId, true)) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("摄像头[%s]禁用成功后启用成功.", strId);
			}
			else {
				LogWarn(Severity_Middle, Error_Debug, LOG_WARN_ENABLE_CAMERA_FAILED, CSimpleStringA::Format("摄像头[%s]禁用成功后启用失败.", strId));
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("摄像头[%s]禁用成功后启用失败.", strId);
			}
		}
		else {
			LogWarn(Severity_Middle, Error_Debug, LOG_WARN_DISABLE_CAMERA_FAILED, CSimpleStringA::Format("摄像头[%s]禁用失败.", strId));
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("摄像头[%s]禁用失败.", strId);
		}
	}
	else {
		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_GET_DISABLE_CAMERA_INFO_FAILED, "获取禁用摄像头信息失败.");
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("获取禁用摄像头信息失败.");
	
	}
}

static void InstallVirtualCamera(const char* strdevicename, uint32_t unamelen)
{
	HMODULE hDll = LoadLibraryEx("virtualcam.dll", NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
	if (hDll)
	{
		PFNREGISTERSERVER pfnRegister = (PFNREGISTERSERVER)GetProcAddress(hDll, "DllRegisterServer");
		if (pfnRegister) {
			if (S_OK == pfnRegister()) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Install Virtual camera success!");
				RefreshVirtualCameraList(strdevicename, unamelen);
			}
			else {
				LogWarn(Severity_Middle, Error_Debug, LOG_WARN_INSTALL_VIRTUALCAM_FAILED, CSimpleStringA::Format("安装虚拟摄像头失败!"));
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2832")("安装虚拟摄像头失败!");
			}
		}
		else {
			LogWarn(Severity_Middle, Error_Debug, LOG_WARN_GET_INSTALL_VIRTUALCAM_INTERFACE_FAILED, CSimpleStringA::Format("获取安装虚拟摄像头接口失败!"));
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2831")("获取安装虚拟摄像头接口失败!");
		}
		FreeLibrary(hDll);
	}
	else {
		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_LOADVIRTUALCAM_FAILED, CSimpleStringA::Format("加载虚拟摄像头组件失败!"));
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2830")("加载虚拟摄像头组件失败!");
	}
}


static void UnInstallVirtualCamera(const char* strdevicename, uint32_t unamelen)
{
	HMODULE hDll = LoadLibraryEx("virtualcam.dll", NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
	if (hDll)
	{
		PFNUNREGISTERSERVER pfnUnregister = (PFNUNREGISTERSERVER)GetProcAddress(hDll, "DllUnregisterServer");
		if (pfnUnregister) {
			if (S_OK == pfnUnregister()) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("uninstall virtual camera success!");
				RefreshVirtualCameraList(strdevicename, unamelen);
			}
			else {
				LogWarn(Severity_Middle, Error_Debug, LOG_WARN_UNINSTALL_VIRTUALCAM_FAILED, CSimpleStringA::Format("卸载虚拟摄像头失败!"));
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2834")("卸载虚拟摄像头失败!");
			}
		}
		else {
			LogWarn(Severity_Middle, Error_Debug, LOG_WARN_GET_UNINSTALL_VIRTUALCAM_INTERFACE_FAILED, CSimpleStringA::Format("获取卸载虚拟摄像头接口失败!"));
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2833")("获取卸载虚拟摄像头接口失败!");
		}
		FreeLibrary(hDll);
	}
	else {
		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_LOADVIRTUALCAM_FAILED, CSimpleStringA::Format("加载虚拟摄像头组件失败!"));
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2830")("加载虚拟摄像头组件失败!");
	}
}

static unsigned int __stdcall virtulcam_state_func(void* arg)
{
	CMediaControllerEntity* pEntity = (CMediaControllerEntity*)arg;

	HANDLE hMailslot = CreateMailslotA(
		szMailslot,             // mailslot name
		RVC_BUFFER_SIZE,              // input buffer size 
		MAILSLOT_WAIT_FOREVER,    // no timeout
		NULL);                    // default security attribute 

	if (INVALID_HANDLE_VALUE == hMailslot)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Error occurred while creating the mailslot: %d", GetLastError());
		return 1;  //Error
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CreateMailslot successful.");
	}

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Waiting for client connection...");

	for (;;) //Infinite, till user terminates the console app
	{
		char szBuffer[RVC_BUFFER_SIZE] = {0};
		DWORD cbBytes = 0;
		//Read client message
		BOOL bResult = ReadFile(
			hMailslot,            // handle to mailslot 
			szBuffer,             // buffer to receive data 
			sizeof(szBuffer),     // size of buffer 
			&cbBytes,             // number of bytes read 
			NULL);                // not overlapped I/O 

		if ((!bResult) || (0 == cbBytes))
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Error occurred while reading from the client: %d", GetLastError());
			CloseHandle(hMailslot);
			return 1;  //Error
		}
		else
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ReadFile() was successful.");
		}

		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Client sent the following message: %s", szBuffer);
		pEntity->HandleVirtucalCamMsg(szBuffer);
	}

	CloseHandle(hMailslot);

	return 0;
}

#else
static void GetOSKernelVersionInfo()
{
	std::string sucContent, failedContent;
	CSimpleStringA strCmd("uname -r");
	bool ret = SP::Module::Util::ShellExecute(strCmd.GetData(), sucContent, failedContent);
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("{%s}:{%s}{%s}", strCmd.GetData(), sucContent.c_str(), failedContent.c_str());
	if (ret) {
		LogWarn(Severity_Low, Error_Debug, LOG_INFO_KERNEL_VERSION, sucContent.c_str() ? sucContent.c_str() : "get kernel version failed.");
		if (0 != sucContent.compare(RVC_DEFAULT_KERNEL_VERSION)) {
			LogWarn(Severity_Low, Error_Debug, LOG_INFO_UNEXPECTED_KERNEL_VERSION, CSimpleStringA::Format("unexpected kernel version %s.", sucContent.c_str() ? sucContent.c_str() : "get kernel version failed.").GetData());
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("获取系统内核版本信息失败");
	}
}


static bool IsVirtualcamDriverLoaded()
{
	bool bRet = false;

	CSimpleString strCmd = "lsmod | grep virtualcam";
	std::string sucContent, failedContent;
	bool ret = SP::Module::Util::ShellExecute(strCmd.GetData(), sucContent, failedContent);
	std::string msg = SP::Utility::ToTrim(sucContent);
	SP::Utility::replaceInPlace(msg, "\n", "|");
	if (ret) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("lsmod | grep virtualcam 执行成功{%s}.", msg.c_str());
		if (strstr(msg.c_str(), "|")) {
			bRet = true;
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("lsmod | grep virtualcam 执行失败");
	}
	return bRet;
}

static bool HandleVirtualcamDriver(CSimpleStringA strCmd)
{
	std::string sucContent, failedContent;
	bool ret = SP::Module::Util::ShellExecute(strCmd.GetData(), sucContent, failedContent);
	if (ret) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s 执行成功.", strCmd.GetData());
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s 执行失败.", strCmd.GetData());
	}

	return ret;
}

static int AddVirtualCamera(const char* strName)
{
	int iRet = -1;

	CSimpleString strCmd = CSimpleString::Format("./bin/virtualcamutils add -n \"%s\"", strName);
	
	std::string sucContent, failedContent;
	bool ret = SP::Module::Util::ShellExecute(strCmd.GetData(), sucContent, failedContent);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("{%s}:{%s}{%s}", strCmd.GetData(), sucContent.c_str(), failedContent.c_str());
	if (ret) {
		iRet = 0;
	}

	return iRet;
}

static int SetVirtualCameraCaps(int ideviceid)
{
	int iRet = -1;

	if (!ExistsFileA("./bin/virtualcamutils")) {
		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_GET_INSTALL_VIRTUALCAM_INTERFACE_FAILED, CSimpleStringA::Format("获取安装虚拟摄像头接口失败!"));
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2831")("获取安装虚拟摄像头接口失败!");
		return iRet;
	}

	char strCmd[MAX_PATH] = { 0 };
	snprintf(strCmd, MAX_PATH, "./bin/virtualcamutils set-caps /dev/video%d YUYV:640x360@15/1", ideviceid);

	std::string sucContent, failedContent;
	bool ret = SP::Module::Util::ShellExecute(strCmd, sucContent, failedContent);
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("{%s}:{%s}{%s}", strCmd, sucContent.c_str(), failedContent.c_str());
	if (ret) {
		iRet = 0;
	}

	return iRet;
}

static int DeleteVirtualCamera(int ideviceid)
{
	int iRet = -1;

	if (!ExistsFileA("./bin/virtualcamutils")) {
		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_GET_INSTALL_VIRTUALCAM_INTERFACE_FAILED, CSimpleStringA::Format("获取安装虚拟摄像头接口失败!"));
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2831")("获取安装虚拟摄像头接口失败!");
		return iRet;
	}

	char strCmd[MAX_PATH] = { 0 };
	snprintf(strCmd, MAX_PATH, "./bin/virtualcamutils delete /dev/video%d", ideviceid);

	std::string sucContent, failedContent;
	bool ret = SP::Module::Util::ShellExecute(strCmd, sucContent, failedContent);
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("{%s}:{%s}{%s}", strCmd, sucContent.c_str(), failedContent.c_str());
	if (ret) {
		iRet = 0;
	}

	return iRet;
}

typedef struct
{
	struct nlmsghdr hdr;
	char msg[RVC_BUFFER_SIZE];
}RX_KERNEL_MSG;


void* virtulcam_state_func(void* arg)
{
	CMediaControllerEntity* pEntity = (CMediaControllerEntity*)arg;

	int iret = -1;
	char* data = "this message is from user's space";
	//初始化
	struct sockaddr_nl src_addr, dest_addr;    //sockaddr_nl 是 netlink 使用的地址数据结构
	int skfd, ret = sizeof(struct sockaddr_nl);
	socklen_t rxlen = sizeof(struct sockaddr_nl);
	struct nlmsghdr* message;
	RX_KERNEL_MSG info;

	/* 1.创建NETLINK socket */
	skfd = socket(PF_NETLINK, SOCK_RAW, NETLINK_RVC);
	if (skfd < 0) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("can not create a netlink socket(%d:%s).", errno, strerror(errno));
		return &iret;
	}

	//初始化 netlink 源地址
	memset(&src_addr, 0, sizeof(src_addr));
	src_addr.nl_family = AF_NETLINK;
	src_addr.nl_pid = getpid();
	src_addr.nl_groups = 0;
	if (bind(skfd, (struct sockaddr*)&src_addr, sizeof(src_addr)) != 0) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("bind error(%d:%s).", errno, strerror(errno));
		close(skfd);
		return &iret;
	}

	//初始化 netlink 目标地址
	memset(&dest_addr, 0, sizeof(dest_addr));
	dest_addr.nl_family = AF_NETLINK;
	dest_addr.nl_pid = 0;            //0表示发送给kernel
	dest_addr.nl_groups = 0;         //多播组的地址掩码

/* 2.设置消息 */
	message = (struct nlmsghdr*)malloc(NLMSG_SPACE(RVC_MAX_PAYLOAD));
	memset(message, 0, sizeof(struct nlmsghdr));
	message->nlmsg_len = NLMSG_SPACE(strlen(data)); //包括netlink消息头在内，整个消息长度 
	message->nlmsg_flags = 0;            //消息标志
	message->nlmsg_type = 0;             //消息类型
	message->nlmsg_seq = 0;              //消息报文的序列号
	message->nlmsg_pid = src_addr.nl_pid; //消息中加入本应用端口pid，内核应答时往此pid写入
	memcpy(NLMSG_DATA(message), data, strlen(data));    //数据

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("user send: %s, len:%d.", (char *)NLMSG_DATA(message), message->nlmsg_len);

/* 3.发送消息 */
	ret = sendto(skfd, message, message->nlmsg_len, 0, (struct sockaddr*)&dest_addr, sizeof(dest_addr));	//将message消息发送给内核
	if (!ret) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("sendto error(%d:%s).", errno, strerror(errno));
		close(skfd);
		free((void*)message);
		return &iret;
	}

	while (true) {
		/* 4.接收内核发来的信息 */
		memset(&info, 0, sizeof(RX_KERNEL_MSG));
		ret = recvfrom(skfd, &info, sizeof(RX_KERNEL_MSG), 0, (struct sockaddr*)&dest_addr, &rxlen);
		if (!ret) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("recv form kerner error(%d:%s).", errno, strerror(errno));
			close(skfd);
			free((void*)message);
			return &iret;
		}

		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("user receive msg from kernel:%s.", (char*)info.msg);
		pEntity->HandleVirtucalCamMsg((char*)info.msg);
	}

	close(skfd);
	free((void*)message);

	iret = 0;

	return &iret;
}
#endif


void CMediaControllerEntity::OnStarted()
{
	m_eCameraState = eCameraClose;

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

	m_pHMClient = new HealthManagerService_ClientBase(this);
	Error = m_pHMClient->Connect();
	if (Error != Error_Succeed){
		m_pHMClient->SafeDelete();
		m_pHMClient = NULL;
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("m_pHMClient connect fail!");
	}

	if (Error_Succeed != GetMediaConfig()) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get entity config from config failed!");
	}

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

#ifdef RVC_OS_WIN
	audiorender_callback_t t_callback = { 0 };
	t_callback.debug = &__audio_render_log;
	t_callback.user_data = this;

	m_pAudioRenderObj = CreateIAudioRenderObj(&t_callback);
	if (NULL == m_pAudioRenderObj){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create audio render failed.");
	}
#endif

	int icamnum = 0;
	Error = (ErrorCodeEnum)capture_lib_init(&icamnum);
	if (Error == Error_Succeed)
	{
		RvcGetAudioDevice();
		//RvcCheckCameraInfo(icamnum);
		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;
				}
				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;
				}
			}
			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;
				}
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Load Config failed!");
			}
		}
		else {
			SetCameraSysVar(CAMERA_NO_ERROR);
		}
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("capture_lib_init failed!");
	}

	int ienvvirtualid = capture_get_video_device_id(RVC_ENV_VIRTUALCAMERA);
	int ioptvirtualid = -1;
	if (eStand2sType == m_eDeviceType) {
		ioptvirtualid = capture_get_video_device_id(RVC_OPT_VIRTUALCAMERA);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("虚拟上摄像头id为: %d, 虚拟下摄像头id为: %d.", ienvvirtualid, ioptvirtualid);
	}
	else {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("虚拟上摄像头id为: %d.", ienvvirtualid);
	}
	
#ifdef RVC_OS_WIN
	if (ienvvirtualid >= 0 || ioptvirtualid >= 0) {
		UnInstallVirtualCamera(conf.strVideoOpt.GetData(), conf.strVideoOpt.GetLength());
		ienvvirtualid = capture_get_video_device_id(RVC_ENV_VIRTUALCAMERA);
		ioptvirtualid = capture_get_video_device_id(RVC_OPT_VIRTUALCAMERA);
	}

	if (ienvvirtualid >= 0 && ioptvirtualid >= 0) {
		if (Error_AllCamera == m_nCameraErrorCode) {
			UnInstallVirtualCamera(conf.strVideoOpt.GetData(), conf.strVideoOpt.GetLength());
		}
	}
	else {
		if (Error_AllCamera != m_nCameraErrorCode) {
			InstallVirtualCamera(conf.strVideoOpt.GetData(), conf.strVideoOpt.GetLength());

			m_hVirtualCamStateThread = (HANDLE)_beginthreadex(NULL, 0, &virtulcam_state_func, this, 0, NULL);
			if (NULL == m_hVirtualCamStateThread) {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("create virtual camera state listen thread failed.");
			}
			else {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("create virtual camera state listen thread success.");
			}
		}
	}
#else
	
	GetOSKernelVersionInfo();
	if (ienvvirtualid >= 0 || ioptvirtualid >= 0) {
		HandleVirtualcamDriver(CSimpleStringA::Format("rmmod virtualcam -f"));
		ienvvirtualid = capture_get_video_device_id(RVC_ENV_VIRTUALCAMERA);
		ioptvirtualid = capture_get_video_device_id(RVC_OPT_VIRTUALCAMERA);
	}

	if (!IsVirtualcamDriverLoaded()) {
		long lstarttime = SP::Module::Comm::RVCGetTickCount();
		HandleVirtualcamDriver(CSimpleStringA::Format("insmod ./bin/virtualcam.ko pid=%d", getpid()));
		long lcosttime = SP::Module::Comm::RVCGetTickCount() - lstarttime;
		if (!IsVirtualcamDriverLoaded()) {
			LogWarn(Severity_Middle, Error_Debug, LOG_WARN_LOADVIRTUALCAM_FAILED, CSimpleStringA::Format("加载虚拟摄像头组件失败!"));
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2830")("加载虚拟摄像头组件失败!");
			HandleVirtualcamDriver(CSimpleStringA::Format("insmod ./bin/virtualcam.ko pid=%d -f", getpid()));
		}
		else {
			LogWarn(Severity_Low, Error_Debug, LOG_INFO_LOADVIRTUALCAM_COST_TIME, CSimpleStringA::Format("加载虚拟摄像头驱动耗时 %dms.", lcosttime));
		}
	}

	bool binstalled = false;
	if (eStand2sType == m_eDeviceType) {
		if (ienvvirtualid >= 0 && ioptvirtualid >= 0) {
			if (Error_AllCamera == m_nCameraErrorCode) {
				DeleteVirtualCamera(ienvvirtualid);
				DeleteVirtualCamera(ioptvirtualid);
				if ((capture_get_video_device_id(RVC_ENV_VIRTUALCAMERA) >= 0) || (capture_get_video_device_id(RVC_OPT_VIRTUALCAMERA) >= 0)) {
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2834")("卸载虚拟摄像头失败!");
				}
			}
		}
		else {
			if (Error_AllCamera != m_nCameraErrorCode) {
				AddVirtualCamera(RVC_ENV_VIRTUALCAMERA);
				AddVirtualCamera(RVC_OPT_VIRTUALCAMERA);
				int ienvid = capture_get_video_device_id(RVC_ENV_VIRTUALCAMERA);
				int ioptid = capture_get_video_device_id(RVC_OPT_VIRTUALCAMERA);
				if ((-1 == ienvid) || (-1 == ioptid)) {
					LogWarn(Severity_Middle, Error_Debug, LOG_WARN_INSTALL_VIRTUALCAM_FAILED, CSimpleStringA::Format("安装虚拟摄像头失败!"));
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2832")("安装虚拟摄像头失败!");
				}
				else {
					SetVirtualCameraCaps(ienvid);
					SetVirtualCameraCaps(ioptid);
					binstalled = true;
				}
			}
		}
	}
	else {
		if (ienvvirtualid >= 0) {
			if (Error_AllCamera == m_nCameraErrorCode) {
				DeleteVirtualCamera(ienvvirtualid);
				if (capture_get_video_device_id(RVC_ENV_VIRTUALCAMERA) >= 0) {
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2834")("卸载虚拟摄像头失败!");
				}
			}
		}
		else {
			if (Error_AllCamera != m_nCameraErrorCode) {
				AddVirtualCamera(RVC_ENV_VIRTUALCAMERA);
				int ienvid = capture_get_video_device_id(RVC_ENV_VIRTUALCAMERA);
				if (-1 == ienvid) {
					LogWarn(Severity_Middle, Error_Debug, LOG_WARN_INSTALL_VIRTUALCAM_FAILED, CSimpleStringA::Format("安装虚拟摄像头失败!"));
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2832")("安装虚拟摄像头失败!");
				}
				else {
					SetVirtualCameraCaps(ienvid);
					binstalled = true;
				}
			}
		}
	}

	if (binstalled) {
		int err = pthread_create(&m_iCamStateThreadId, NULL, virtulcam_state_func, this);
		if (0 != err) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create virtual camera state monitor thread failed!");
		}
		else {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("create virtual camera state monitor thread sucess.");
		}
	}

#endif
	
	LogEvent(Severity_Middle, LOG_EVT_MOD_MEDIACONTROLLER_STARTED_SUCCESS, "mediacontroller entity started successfully.");

	if (Error != Error_AllCamera)
	{
		CSimpleStringA uiState("");
		GetFunction()->GetSysVar("UIState", uiState);
		if (uiState.GetLength() > 0 && uiState[0] == 'F') {
			StartAllCameras(true);
		}
	}

#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
	Error = GetFunction()->GetPath("Temp", m_PhotoSaveDir);
	if (Error != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get global record save path failed!");
	}

	if (m_PhotoSaveDir.GetLength() > 0 && m_PhotoSaveDir[m_PhotoSaveDir.GetLength() - 1] != SPLIT_SLASH) {
		m_PhotoSaveDir += SPLIT_SLASH_STR;
	}
	m_PhotoSaveDir += "CameraPhoto";
	m_PhotoSaveDir += SPLIT_SLASH_STR;

#endif
#endif

	CSystemStaticInfo si;
	Error = GetFunction()->GetSystemStaticInfo(si);
	if (Error == Error_Succeed) {
		m_strAppVersion = si.InstallVersion.ToString();
		m_strTerminalId = si.strTerminalID;
	}
}


ErrorCodeEnum CMediaControllerEntity::RvcCheckCameraInfo(int iCamNumber)
{
	ErrorCodeEnum Error = Error_Succeed;
	bool bnumbererror = false;

	if (eStand2sType == m_eDeviceType) {
		if (3 != iCamNumber) {
			bnumbererror = true;
		}
	}
	else if (eStand1SPlusType == m_eDeviceType) {
		if (1 != iCamNumber) {
			bnumbererror = true;
		}
	}

	if (bnumbererror) {
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_MEDIACONTROLLER_CAMERA_NUM, CSimpleStringA::Format("camera number(%d) error.", iCamNumber).GetData());
	}

	return Error;
}

ErrorCodeEnum CMediaControllerEntity::RvcGetAudioDevice()
{
	ErrorCodeEnum Error = Error_Param;

#ifdef RVC_OS_LINUX
	if (NULL != m_pAudioCap) {
		int icountmic = m_pAudioCap->audio_get_device_count(true);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("audio input devices(%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 devices(%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;
	}
#endif

	return Error;
}


DeviceTypeEnum CMediaControllerEntity::RvcGetDeviceType()
{
	DeviceTypeEnum eType = eStand2sType;
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSystemStaticInfo stStaticinfo;
	spFunction->GetSystemStaticInfo(stStaticinfo);
	if (_stricmp(stStaticinfo.strMachineType, "RVC.Stand1SPlus") == 0) {
		eType = eStand1SPlusType;
	}
	else if (_stricmp(stStaticinfo.strMachineType, "RVC.CardStore") == 0 || _stricmp(stStaticinfo.strMachineType, "RVC.CardPrinter") == 0) {
		eType = eCardStore;
	}
	else {
		eType = eStand2sType;
	}

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

	return eType;
}


DeviceTypeEnum CMediaControllerEntity::RvcDeviceType()
{
	return m_eDeviceType;
}


ErrorCodeEnum CMediaControllerEntity::GetSalesRecordAudioParam()
{
	ErrorCodeEnum Error = Error_Succeed;

#ifdef RVC_OS_WIN
	CSmartPointer<IConfigInfo> spConfig;
	SpIniMappingTable table;
	int iPlayType = 0;
	Error = GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
	if (Error == Error_Succeed) {
		table.AddEntryInt("LocalMediaPlay", "PlayType", iPlayType, 0);
		Error = table.Load(spConfig);
	}

	if (0 != iPlayType) {
		m_bSpeakerCap = false;
	}
#endif // RVC_OS_WIN

	return Error;
}


ErrorCodeEnum CMediaControllerEntity::GetMediaConfig()
{
	ErrorCodeEnum Error = Error_Succeed;
	CSmartPointer<IConfigInfo> spConfig;
	SpIniMappingTable table;
	int itimeout = CAMERA_TIMEOUT;
	int iDelayTime = RVC_MAX_DELAY_TIME;
	unsigned int intervaltime = RVC_CAM_INTERVAL_TIME;
	int iaudiotimeout = AUDIO_BUG_THRESHOLD_TIME;

	Error = GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
	if (Error == Error_Succeed){
		table.AddEntryInt("MediaController", "CamTimeOut", itimeout, CAMERA_TIMEOUT);
		table.AddEntryInt("MediaController", "MaxDelayTime", iDelayTime, RVC_MAX_DELAY_TIME);
		table.AddEntryUInt("MediaController", "InterValTime", intervaltime, RVC_CAM_INTERVAL_TIME);
		table.AddEntryInt("MediaController", "AudioTimeOut", iaudiotimeout, AUDIO_BUG_THRESHOLD_TIME);
		Error= table.Load(spConfig);
	}
	 
	if (Error_Succeed != Error){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get entity config from config failed!");
	}
	else{
		if (itimeout >= CAMERA_MIN_TIMEOUT && itimeout <= CAMERA_TIMEOUT) {
			m_iCamTimeout = itimeout;
		}

		if (iDelayTime > 0) {
			m_iDelayTime = iDelayTime;
		}

		if (intervaltime <= 10*RVC_CAM_INTERVAL_TIME && intervaltime >= RVC_CAM_INTERVAL_TIME / 3) {
			m_interValTime = intervaltime;
		}

		if (iaudiotimeout > 0) {
			m_iAudioTimeout = iaudiotimeout;
		}
	}

	return Error;
}


ErrorCodeEnum CMediaControllerEntity::SetCameraSysVar(const CSimpleStringA &newVal)
{
	CSmartPointer<IEntityFunction> spFunction = this->GetFunction();
		
	CSimpleStringA val = newVal;
	if('B' == val[0]){
		LogWarn(Severity_Middle, Error_DevMedia, ERROR_MOD_MEDIACONTROLLER_CONFIG_ALLERROR, "all config cameras error");
	}

	return spFunction->SetSysVar(SYSVAR_CAMERASTATE, newVal.GetData());
}

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

	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) {
		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::OnTimeout(DWORD dwTimerID)
{
	if (RVC_MEDIADEV_STATUS_CHECK_TIMER == dwTimerID) {
		if (!m_capture) {
			return;
		}

		if (eCameraOpened != m_eCameraState) {
			return;
		}

		OnTimeCameraStatusCheck();

		OnTimeHandfreeMicroStatusCheck();
	}
	else if (2 == dwTimerID) {
		if (false == m_bConnectedAssist) {
			if (Error_Succeed == ConnectAssistChannel()) {
				m_bConnectedAssist = true;
			}
		}

		if (true == m_bConnectedAssist) {
			GetFunction()->KillTimer(2);
		}
	}
	else if (RVC_CAMERA_OFF_TIMER == dwTimerID) {
		if (eCameraOpened == m_eCameraState) {
			CSimpleStringA strCallState("");
			if (Error_Succeed == GetFunction()->GetSysVar(SYSVAR_CALLSTATE, strCallState)) {
				if ((strCallState.Compare("O") == 0) && (false == m_bVirtualCamOpened)) {
					if (m_capture) {
						GetFunction()->KillTimer(RVC_MEDIADEV_STATUS_CHECK_TIMER);
						capture_stop(m_capture);
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402208V5")("关闭摄像头");
						capture_destroy(m_capture);
						m_capture = NULL;
					}
					OnCameraStopped();
					m_eCameraState = eCameraClose;
					if (m_bCameraOffTimerOn) {
						if (Error_Succeed != GetFunction()->KillTimer(RVC_CAMERA_OFF_TIMER)) {
							LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_KILLTIMER_ERROR, "stop camera, kill camera off timer failed.");
						}
						else {
							m_bCameraOffTimerOn = false;
						}
					}
				}
				else {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CallState is %s, and current virtual camera is %s.", strCallState.GetData(), m_bVirtualCamOpened?"on":"off");
				}
			}
		}
	}
#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
	else if (RVC_CAMERA_CAP_PROCESS == dwTimerID) {
		GetEnvCamCaptureProcess();
	}
#endif
#endif
}


void CMediaControllerEntity::OnTimeHandfreeMicroStatusCheck()
{
	CSimpleStringA strValue = m_capture->config.strAudioState;
	if ('B' == strValue[0] || 'H' == strValue[0]) {
		return;
	}

	unsigned int nHandfreeinAudioTime = 0;
	static bool bTimeout = false;
	static bool bPost = false;

	capture_get_last_audio_frametime(m_capture, &nHandfreeinAudioTime);

	if (nHandfreeinAudioTime > 0)
	{
		if (((y2k_time_now() - nHandfreeinAudioTime) > m_iAudioTimeout) && !bTimeout)
		{
			bTimeout = true;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("bTimeout.");
		}
		else if (((y2k_time_now() - nHandfreeinAudioTime) < m_iAudioTimeout) && bTimeout)
		{
			bTimeout = false;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("change handfree audio in from bTimeout to ok.");
		}
	}

	if (bTimeout){
		if (!bPost) {
			LogWarn(Severity_Middle, Error_Hardware, ERROR_MOD_MEDIACONTROLLER_HANDFREEIN_BUG, CSimpleStringA::Format("{%s}故障，采集不到音频", m_capture->config.strAudioIn.GetData()).GetData());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode("RTA2820")("免提麦克风故障，采集不到音频");
			bPost = true;
		}
	}
}

void CMediaControllerEntity::OnTimeCameraStatusCheck()
{
	int env_n = -1, opt_n = -1;
	unsigned int nLastEnvTime = 0, nLastOptTime = 0;
	static bool bEnvTimeout = false, bOptTimeout = false;
	static int iEnvEmptyTimes(0), iOptEmptyTimes(0), iEnvCameraRestartNum(0), iOptCameraRestartNum(0);

	bool bSingleCamera = false;
	if (eStand1SPlusType == m_eDeviceType){
		bSingleCamera = true;
	}

	capture_detect_camera_bug(m_capture, &env_n, &opt_n, bSingleCamera);

	capture_get_last_frametime(m_capture, &nLastEnvTime, &nLastOptTime);

	if (env_n == 0) {
		if (iEnvEmptyTimes < CAMERA_BUG_THRESHOLD){
			iEnvEmptyTimes++; 
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("get env camera picture fail, times=%d.", iEnvEmptyTimes);
		}	
	} 
	else if (env_n == -1){
		iEnvEmptyTimes = CAMERA_BUG_THRESHOLD;
	}
	else {
		if (iEnvEmptyTimes == CAMERA_BUG_THRESHOLD){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("env camera get video right again.");
		}
		iEnvEmptyTimes = 0;
	}

	//env图像是否超时
	if(nLastEnvTime > 0)
	{
		if(((y2k_time_now()-nLastEnvTime) > m_iCamTimeout)&&!bEnvTimeout)
		{
			bEnvTimeout = true;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("bEnvTimeout.");
		} 
		else if (((y2k_time_now()-nLastEnvTime) < m_iCamTimeout)&&bEnvTimeout)
		{
			bEnvTimeout = false;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("change env camera from bEnvTimeout to ok.");
		}
	}

	//env是否30S没有图像或者图像15秒没有更新
	if(((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!");
		char strInfo[MAX_PATH*2] = {0};
		if ((NULL != m_capture) && (NULL != m_capture->env_video)) {
			snprintf(strInfo, MAX_PATH * 2, "%s and current time = %u, env last capture time = %u, video queue LastEnvTime = %u.", strMessage, y2k_time_now(), m_capture->env_video->ulastcaptime, nLastEnvTime);
		}
		else {
			snprintf(strInfo, MAX_PATH * 2, "%s", strMessage);
		}
		
		LogWarn(Severity_Middle, Error_Hardware, ERROR_MOD_MEDIACONTROLLER_ENVCAMERA_BUG, strInfo);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V4").setResultCode("RTA2805")("上摄像头故障，采集不到图像");

		if (eStand1SPlusType == m_eDeviceType){
			m_nCameraErrorCode = Error_AllCamera;
		}
		else{
			if (m_nCameraErrorCode == Error_Succeed){
				m_nCameraErrorCode = Error_EnvCamera;
			}
			else if (m_nCameraErrorCode == Error_OptCamera){
				m_nCameraErrorCode = Error_AllCamera;
			}
		}
		ChangeSysvar(m_nCameraErrorCode);
	}
	else if((iEnvEmptyTimes != CAMERA_BUG_THRESHOLD)&&!bEnvTimeout&&((m_nCameraErrorCode == Error_EnvCamera)||(m_nCameraErrorCode == Error_AllCamera)))
	{
		if (eStand1SPlusType == m_eDeviceType){
			m_nCameraErrorCode = Error_Succeed;
		}
		else{
			if (m_nCameraErrorCode == Error_EnvCamera){
				m_nCameraErrorCode = Error_Succeed;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("changeSysvar to No_Error");
			}
			else if (m_nCameraErrorCode == Error_AllCamera){
				m_nCameraErrorCode = Error_OptCamera;
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("changeSysvar to Opt_Error");
			}
		}
		ChangeSysvar(m_nCameraErrorCode);
	}

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

	//opt图像是否超时
	if (eStand2sType == m_eDeviceType) {
		if (nLastOptTime > 0)
		{
			if (((y2k_time_now() - nLastOptTime) > m_iCamTimeout) && !bOptTimeout)
			{
				bOptTimeout = true;
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("bOptTimeout");
			}
			else if (((y2k_time_now() - nLastOptTime) < m_iCamTimeout) && bOptTimeout)
			{
				bOptTimeout = false;
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("change opt camera from bOptTimeout to ok");
			}
		}
	}

	//opt是否100S没有图像或者图像20秒没有更新
	if(((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};
		if (NULL != m_capture && NULL != m_capture->opt_video) {
			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);
		}
		else {
			snprintf(strInfo, MAX_PATH * 2, "%s.", strMessage);
		}
		
		LogWarn(Severity_Middle, Error_Hardware, ERROR_MOD_MEDIACONTROLLER_OPECAMERA_BUG, strInfo);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V4").setResultCode("RTA2806")("下摄像头故障，采集不到图像");
		if (m_nCameraErrorCode == Error_Succeed)
		{
			m_nCameraErrorCode = Error_OptCamera;
		}
		else if (m_nCameraErrorCode == Error_EnvCamera)
		{
			m_nCameraErrorCode = Error_AllCamera;
		}
		ChangeSysvar(m_nCameraErrorCode);
	}
	else if((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;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("changeSysvar to No_Error");
		}
		else if (m_nCameraErrorCode == Error_AllCamera)
		{
			m_nCameraErrorCode = Error_EnvCamera;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("changeSysvar to Env_Error");
		}
		ChangeSysvar(m_nCameraErrorCode);
	}

	//重新打开摄像头
	if((m_nCameraErrorCode == Error_EnvCamera)&&(iEnvCameraRestartNum<CAMERA_RESTARTNUM)&&(NULL != m_capture->env_video))
	{
		if (ReStartCamera(ENVCAMERA) != Error_Succeed){
			iEnvCameraRestartNum++;
		}
		else
		{
			iEnvCameraRestartNum = 0;
			m_nCameraErrorCode = Error_Succeed;
			ChangeSysvar(m_nCameraErrorCode);
			iEnvEmptyTimes = 0;
			bEnvTimeout = false;
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_RESTART_CAME_SUCCESS, "restart env camera success.");
		}
	}
	else if((m_nCameraErrorCode == Error_OptCamera)&&(iOptCameraRestartNum<CAMERA_RESTARTNUM)&&(eStand2sType == m_eDeviceType)&&(NULL != m_capture->opt_video))
	{
		if (ReStartCamera(OPTCAMERA) != Error_Succeed) {
			iOptCameraRestartNum++;
		}
		else
		{
			iOptCameraRestartNum = 0;
			m_nCameraErrorCode = Error_Succeed;
			ChangeSysvar(m_nCameraErrorCode);
			iOptEmptyTimes = 0;
			bOptTimeout = false;
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_RESTART_CAME_SUCCESS, "restart opt camera success.");
		}
	}
	else if (m_nCameraErrorCode == Error_AllCamera)
	{
		if ((iEnvCameraRestartNum<CAMERA_RESTARTNUM) && (NULL != m_capture->env_video))
		{
			if (ReStartCamera(ENVCAMERA) != Error_Succeed) {
				iEnvCameraRestartNum++;
			}
			else
			{
				iEnvCameraRestartNum = 0;
				m_nCameraErrorCode = Error_OptCamera;
				ChangeSysvar(m_nCameraErrorCode);
				iEnvEmptyTimes = 0;
				bEnvTimeout = false;
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_RESTART_CAME_SUCCESS, "restart env camera success.");
			}
		}

		if((iOptCameraRestartNum<CAMERA_RESTARTNUM)&&(eStand2sType == m_eDeviceType)&&(NULL != m_capture->opt_video))
		{
			if (ReStartCamera(OPTCAMERA) != Error_Succeed) {
				iOptCameraRestartNum++;
			}
			else
			{
				iOptCameraRestartNum = 0;
				iOptEmptyTimes = 0;
				bOptTimeout = false;
				if (m_nCameraErrorCode == Error_AllCamera)
				{
					m_nCameraErrorCode = Error_EnvCamera;
				} 
				else
				{
					m_nCameraErrorCode = Error_Succeed;
				}
				ChangeSysvar(m_nCameraErrorCode);
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_RESTART_CAME_SUCCESS, "restart opt camera success.");
			}
		}
	}
}


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

bool CMediaControllerEntity::SetConfigBright(ErrorCodeEnum nCode)
{
	if (eStand2sType == m_eDeviceType) {
		if (m_capture) {
			capture_set_camera_brightness(m_capture->config.video_env_brightness, m_capture, nCode, 0);
			capture_set_camera_brightness(m_capture->config.video_opt_brightness, m_capture, nCode, 1);
		}
	}
	else {
		if (m_capture) {
			capture_set_camera_brightness(m_capture->config.video_env_brightness, m_capture, nCode, 0);
		}
	}
	return true;
}

//camera gain adjust
void CMediaControllerEntity::OnReceivePkt(int sub_type, const char *buffer, int size)
{
	if (sub_type == ACM_SET_CAMERABRIGHT)
	{
		if (eCameraOpened == m_eCameraState)
		{
			if (eStand2sType == m_eDeviceType || eStand1SPlusType == m_eDeviceType)
			{
				//vamera bright adj
				CCameraBrightValue num;
				SpBuffer buf;
				buf.OpenRead(buffer, size);
				num.Serialize(buf);
				int ibrightness = num.nValue;
				if (ibrightness < RVC_MIN_CAMERA_BRIGHNESS) {
					ibrightness = RVC_MIN_CAMERA_BRIGHNESS;
				}

				if (eStand2sType == m_eDeviceType) {
					if (capture_adj_brightness(m_capture, ibrightness, m_nCameraErrorCode) == true){
						SendCameraBright(eStand2sType);
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("set camera brightness to %d success.", ibrightness);
						PostCameraBrightnessInfos(ibrightness);
					}
					else{
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ACM_SET_CAMERABRIGHT fail!");
						LogWarn(Severity_Middle, Error_Debug, LOG_EVT_SET_CAMERA_BRIGHTNESS_FAILED, CSimpleStringA::Format("set camera brightness to %d failed.", ibrightness).GetData());
					}
				}
				else {
					if (0 == capture_set_camera_brightness(ibrightness, m_capture, m_nCameraErrorCode, 0)) {
						SendCameraBright(eStand1SPlusType);
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("set camera brightness to %d success.", ibrightness);
						PostCameraBrightnessInfos(ibrightness);
					}
					else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ACM_SET_CAMERABRIGHT fail!");
						LogWarn(Severity_Middle, Error_Debug, LOG_EVT_SET_CAMERA_BRIGHTNESS_FAILED, CSimpleStringA::Format("set camera brightness to %d failed.", ibrightness).GetData());
					}
				}

			}
			else{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("device 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_pHMClient)
	{
		HealthManagerService_RealCheck_Req req;
		req.name = GetEntityName();
		HealthManagerService_RealCheck_Ans ans;
		Error = m_pHMClient->RealCheck(req,ans,500);
		if (Error!=Error_Succeed){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RealSelfcheck fail!");
		}
		else{
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_REAL_SELF_CHECK, "media controller entity auto restart.");
		}
	}
	return Error;
}


ErrorCodeEnum CMediaControllerEntity::GetEnvCamRawBrightnessInfo(int* iMin, int* iMax)
{
	ErrorCodeEnum Error = Error_Failed;

#ifdef DEVOPS_ON_PRD

#else
	if (eCameraOpened == m_eCameraState) {
		if (0 == capture_get_env_rawbrightnessinfo(m_capture, m_nCameraErrorCode, iMin, iMax)) {
			Error = Error_Succeed;
		}
	}
#endif
	return Error;
}


ErrorCodeEnum CMediaControllerEntity::SetEnvCamRawBrightness(int iBrightness)
{
	ErrorCodeEnum Error = Error_Failed;

#ifdef DEVOPS_ON_PRD

#else
	if (eCameraOpened == m_eCameraState) {
		if (0 == capture_set_env_rawbrightness(m_capture, m_nCameraErrorCode, iBrightness)) {
			Error = Error_Succeed;
		}
	}
#endif
	return Error;
}


void CMediaControllerEntity::SendCameraBright(DeviceTypeEnum eType)
{
	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;
	if (eStand2sType == eType) {
		nValue = capture_get_brightness(m_capture, m_nCameraErrorCode);
	}
	else if(eStand1SPlusType == eType){
		capture_get_camera_brightness(&nValue, m_capture, m_nCameraErrorCode, 0);
	}

	if (nValue >= 0){
		buf & nValue;
		Info.data = buf.ToBlob();
		m_pMediaControllerChannel->Send(Info);
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("send cur camera bright value Fail!");
	}
}


ErrorCodeEnum CMediaControllerEntity::GetEnvCameraVideoCaptureInfo(CSimpleStringA& strnotice, CSimpleStringA& strcmd)
{
	ErrorCodeEnum Error = Error_NotImpl;

#ifdef DEVOPS_ON_PRD

#else
	int ienvid = capture_get_video_device_id(conf.strVideoEnv.GetData());

	if (-1 != ienvid) {
	#ifdef RVC_OS_WIN

	#else
		char strCmd[256] = { 0 };
		snprintf(strCmd, 256, "v4l2-ctl -d%d --list-formats-ext", ienvid);
		strnotice = "在终端输入以下命令获取摄像头支持的图像格式信息,检查输出图像格式是否包含YUYV,图像分辨率是否包含640*360,该分辨率对应的帧率是否包含15fps.";
		strcmd = strCmd;
	#endif
		Error = Error_Succeed;
	}
#endif
	return Error;
}


ErrorCodeEnum CMediaControllerEntity::StartAllCameras(bool bstartaudio)
{
	ErrorCodeEnum Error = Error_Succeed;
	if (eCameraClose == m_eCameraState) {
		CheckAutoVideoConfig(&conf);
		Error = StartCamera(bstartaudio);
		SetCameraState(Error);

		if (Error_Succeed == Error || Error_EnvCamera == Error || Error_OptCamera == Error) {
			m_eCameraState = eCameraOpened;
			OnCameraStarted();
		}
	}
	else {
		if (m_bCameraOffTimerOn) {
			if (Error_Succeed != GetFunction()->KillTimer(RVC_CAMERA_OFF_TIMER)) {
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_KILLTIMER_ERROR, "start camera for it's already on, kill camera off timer failed.");
			}
			else {
				m_bCameraOffTimerOn = false;
			}
		}
	}

	return Error;
}


void CMediaControllerEntity::DelayCloseCameras() 
{
	if (false == m_bCameraOffTimerOn) {
		if (Error_Succeed != GetFunction()->SetTimer(RVC_CAMERA_OFF_TIMER, this, m_iDelayTime * 1000)) {
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_SETTIMER_ERROR, "delay close camera, set camera off timer failed.");
		}
		else {
			m_bCameraOffTimerOn = true;
		}
	}
	else {
		if (Error_Succeed == GetFunction()->ResetTimer(RVC_CAMERA_OFF_TIMER, m_iDelayTime * 1000)) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Retset camera off timer success!");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Retset camera off timer failed!");
		}
	}
}


ErrorCodeEnum CMediaControllerEntity::StopAllCameras()
{
	if (m_capture){
		GetFunction()->KillTimer(RVC_MEDIADEV_STATUS_CHECK_TIMER);
		capture_stop(m_capture);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402208V5")("关闭摄像头");
		capture_destroy(m_capture);
		m_capture = NULL;
	}
	m_eCameraState = eCameraClose;
	OnCameraStopped();
	if (m_bCameraOffTimerOn) {
		if (Error_Succeed != GetFunction()->KillTimer(RVC_CAMERA_OFF_TIMER)) {
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_KILLTIMER_ERROR, "stop camera, kill camera off timer failed.");
		}
		else {
			m_bCameraOffTimerOn = false;
		}
	}

	return Error_Succeed;
}


ErrorCodeEnum CMediaControllerEntity::StopCamerasAndRecord()
{
	LogTransactionRecordCtrEvt(0);
	ErrorCodeEnum CamRet = StopAllCameras(); 

	return CamRet;
}

ErrorCodeEnum CMediaControllerEntity::StartCamerasAndRecord()
{
	ErrorCodeEnum CamRet = StartAllCameras(true);
	LogTransactionRecordCtrEvt(1);

	return CamRet;
}

	
ErrorCodeEnum CMediaControllerEntity::CheckConfigCameraName(capture_config_t *conf, DeviceTypeEnum eType)
{
	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)",conf->strVideoEnv.GetData());
			EnvConfigNameError = -1;
		}
	} 
	else {
		conf->video_env_dev = -1;
		EnvConfigNameError = 1;
	}

	if (0 != EnvConfigNameError) {
		char strMessage[MAX_PATH * 2] = { 0 };
		get_camera_exception_message(strMessage, MAX_PATH * 2, conf->strVideoEnv, "env camera config error, please check config file or device.");
		LogWarn(Severity_Middle, Error_DevMedia, ERROR_MOD_MEDIACONTROLLER_ENVCAM_INITFAIL, strMessage);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V2").setResultCode("RTA2801")("上摄像头配置错误，请检查摄像头配置");
	}

	//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)",conf->strVideoOpt.GetData());
			OptConfigNameError = -1;
		}
	} 
	else {
		conf->video_opt_dev = -1;
		OptConfigNameError = 1;
	}

	if ((eStand2sType == eType) && (0 != OptConfigNameError)) {
		char strMessage[MAX_PATH * 2] = { 0 };
		get_camera_exception_message(strMessage, MAX_PATH * 2, conf->strVideoOpt, "operation camera config error, please check config file or device.");
		LogWarn(Severity_Middle, Error_DevMedia, ERROR_MOD_MEDIACONTROLLER_OPTCAM_INITFAIL, strMessage);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V2").setResultCode("RTA2802")("下摄像头配置错误，请检查摄像头配置");
	}

	if (eStand2sType == eType) {
		//配置的环境摄像头能识别到
		if (0 == EnvConfigNameError) {
			//配置的操作摄像头识别不到or未配置操作摄像头,此时表明只有环境摄像头OK
			if (0 != OptConfigNameError) {
				Error = Error_OptCamera;
			}
		}
		//配置的环境摄像头识别不到or未配置环境摄像头
		else {
			//配置的操作摄像头识别不到or未配置操作摄像头,此时表明摄像头都不可用
			if (0 != OptConfigNameError) {
				Error = Error_AllCamera;
			}
			//操作摄像头配置名能打开,此时表明只有操作摄像头OK
			else {
				Error = Error_EnvCamera;
			}
		}
	}
	else if (eStand1SPlusType == eType) {
		if (0 != EnvConfigNameError) {
			Error = Error_AllCamera;
		}
	}
		
	return Error;
}


ErrorCodeEnum CMediaControllerEntity::AutoGetVideoDeviceName(capture_config_t* conf)
{
	ErrorCodeEnum Error = Error_Unexpect;
	bool benv = false;
	bool bopt = false;
	CSimpleStringA strLastCamera("");
	int icount = 0;

#ifdef  RVC_OS_WIN

#else
	icount = rvc_videocap_get_device_count();
	int ifound = 0;
	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)) && (NULL == strstr(strfullname, RVC_ENV_VIRTUALCAMERA))) {
				conf->strVideoEnv = strfullname;
				benv = true;
			}
			if ((NULL != strstr(strfullname, AUTOMATCH_CAMERA_OPT)) && (NULL == strstr(strfullname, RVC_OPT_VIRTUALCAMERA))) {
				conf->strVideoOpt = strfullname;
				bopt = true;
			}

			if (NULL == strstr(strfullname, RVC_ENV_VIRTUALCAMERA)) {
				strLastCamera = strfullname;
			}

			if (benv && bopt) {
				break;
			}
		}
	}
#endif //  RVC_OS_WIN

	if (eStand1SPlusType == m_eDeviceType && strLastCamera.GetLength() > 0) {
		conf->strVideoEnv = strLastCamera;
		benv = true;
	}

	if (benv || bopt) {
		Error = Error_Succeed;
	}

	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", strAudioInDevice, "$");
		Error = table.Load(spConfig);
		if (Error == Error_Succeed) {
			conf->audio_capture_period = CAPTURE_FRAME_TIME;
			conf->audio_capture_samplerate = CAPTURE_CLOCK;
			conf->strAudioIn = this->conf.strAudioIn;
			conf->strAudioOut = this->conf.strAudioOut;
			if (strAudioInDevice.GetLength() > 0) {
				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.");
		conf->strAudioIn = this->conf.strAudioIn;
		conf->audio_capture_period = CAPTURE_FRAME_TIME;
		conf->audio_capture_samplerate = CAPTURE_CLOCK;
		Error = Error_Succeed;
	}

	if (true == bRemoteRecord) {
		conf->audio_capture_samplerate = CAPTURE_CLOCK;
	}
	return Error;
}

ErrorCodeEnum CMediaControllerEntity::LoadConfig(capture_config_t *conf)
{
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	SpIniMappingTable table;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Root, spConfig);
	if (Error == Error_Succeed) {
		int imtu = 1500;
		int ienvfps = REC_COMMON_VIDEO_RAW_FPS;
		int ioptfps = REC_COMMON_VIDEO_RAW_FPS;
		int ienvbrightness = RVC_DEFAULT_CAMERA_BRIGHNESS;
		int ioptbrightness = RVC_DEFAULT_CAMERA_BRIGHNESS;
		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.AddEntryInt("Video", "EnvRotate", conf->video_env_rotate, 0);
		table.AddEntryInt("Video", "OptRotate", conf->video_opt_rotate, 270);
		table.AddEntryInt("Video", "EnvFps", ienvfps, REC_COMMON_VIDEO_RAW_FPS);
		table.AddEntryInt("Video", "OptFps", ioptfps, REC_COMMON_VIDEO_RAW_FPS);
		table.AddEntryInt("Video", "mtu", imtu, 1500);
		table.AddEntryInt("Video", "EnvBrightness", ienvbrightness, RVC_DEFAULT_CAMERA_BRIGHNESS);
		table.AddEntryInt("Video", "OptBrightness", ioptbrightness, RVC_DEFAULT_CAMERA_BRIGHNESS);
		Error = table.Load(spConfig);
		if (Error == Error_Succeed)
		{
			if (0 != conf->video_env_rotate) {
				conf->video_env_rotate = 0;
			}

			if (270 != conf->video_opt_rotate) {
				conf->video_opt_rotate = 270;
			}

			conf->video_env_fps = REC_COMMON_VIDEO_RAW_FPS;
			if (ienvfps <= 30 && ienvfps >= 5) {
				conf->video_env_fps = ienvfps;
			}

			conf->video_opt_fps = REC_COMMON_VIDEO_RAW_FPS;
			if (ioptfps <= 30 && ioptfps >= 5) {
				conf->video_opt_fps = ioptfps;
			}

			conf->video_env_brightness = RVC_DEFAULT_CAMERA_BRIGHNESS;
			if (ienvbrightness <= 100 && ienvbrightness >= RVC_MIN_CAMERA_BRIGHNESS) {
				conf->video_env_brightness = ienvbrightness;
			}

			conf->video_opt_brightness = RVC_DEFAULT_CAMERA_BRIGHNESS;
			if (ioptbrightness <= 100 && ioptbrightness >= RVC_MIN_CAMERA_BRIGHNESS) {
				conf->video_opt_brightness = ioptbrightness;
			}

			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_BRIGHTNESS, CSimpleStringA::Format("env camera brightness is %d, opt camera brightness is %d.", conf->video_env_brightness, conf->video_opt_brightness).GetData());
			
#ifdef RVC_OS_WIN

#else
			Error = AutoGetVideoDeviceName(conf);
			CSimpleStringA strInfo = CSimpleStringA::Format("env = %s,opt = %s", conf->strVideoEnv.GetData(), conf->strVideoOpt.GetData());
			if (Error_Succeed == Error){
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s", strInfo.GetData());
			}
			else {
				LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_MEDIACONTROLLER_VIDEO_AUTO_MATHED_FAILED, strInfo.GetData());
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V2").setResultCode("RTA2807")("摄像头名称不符合硬件要求，请联系厂商处理");
			}
#endif // RVC_OS_WIN

			Error = CheckConfigCameraName(conf, m_eDeviceType);
			if (Error == Error_Succeed){
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402208V2")("摄像头配置正确");
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("load config failed!");
		}
	} 
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("open config failed!");
	}

	return Error;
}


#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
void CMediaControllerEntity::OnBrocastEnvCameraCapInfo(int icaptime, int irealframes, float frealfps, float fstable)
{
	
	EnvCameraCapInfo ret;
	CSimpleStringA strMsg = CSimpleStringA::Format("摄像头已打开%d秒, 输出图像%d帧, 实际帧率为%.2ffps, 稳定性偏差为%.4f.", icaptime, irealframes, frealfps, fstable);
	ret.cameracapmsg = CSimpleStringA2W(strMsg);
	SpSendBroadcast(GetFunction(), eMsg_EnvCameraCapInfo, eMsgSig_EnvCameraCapInfo, ret);
}

ErrorCodeEnum CMediaControllerEntity::GetEnvCamCaptureProcess()
{
	ErrorCodeEnum Error = Error_Failed;
	if (eCameraOpened == m_eCameraState) {
		if (m_capture && m_capture->env_video) {
			unsigned int istarttime = m_capture->env_video->ustarttime;
			int irealframes = m_capture->env_video->frame_id;
			unsigned int icaptime = y2k_time_now() - istarttime;
			float fenvframerate = (float)((float)irealframes / (float)icaptime);
			int icalcfps = icaptime * 15;
			float fenvstable = (float)(irealframes - icalcfps) / (float)icalcfps;
			OnBrocastEnvCameraCapInfo(icaptime, irealframes, fenvframerate, fenvstable);
			Error = Error_Succeed;
		}
		else{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("env capture param is invalid.");
		}
	}

	return Error;
}

ErrorCodeEnum CMediaControllerEntity::StartSaveEnvCamPhoto(const char* pname, const int interval)
{
	ErrorCodeEnum Error = Error_Failed;
	if (eCameraOpened == m_eCameraState) {
		if (m_capture && m_capture->env_video) {
			m_capture->env_video->bsavephoto = true;
			snprintf(m_capture->env_video->strsavedir, MAX_PATH, "%s", m_PhotoSaveDir.GetData());
			snprintf(m_capture->env_video->strphotoname, MAX_PATH, "%s", pname);
			m_capture->env_video->isaveinterval = interval;

			Error = Error_Succeed;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("env capture param is invalid.");
		}
	}

	return Error;
}

ErrorCodeEnum CMediaControllerEntity::StopSaveEnvCamPhoto()
{
	ErrorCodeEnum Error = Error_Failed;
	if (eCameraOpened == m_eCameraState) {
		if (m_capture && m_capture->env_video) {
			m_capture->env_video->bsavephoto = false;
			memset(m_capture->env_video->strphotoname, 0, MAX_PATH);
			Error = Error_Succeed;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("env camera capture param is invalid.");
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("env camera already stop.");
		Error = Error_Succeed;
	}

	return Error;
}
#endif
#endif


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)
{
	switch (dwUserCode)
	{    
	case 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:
		{
#ifdef RVC_OS_WIN
			InterlockedCompareExchange(&m_lCaptureEnvCount, 1, 0);
#else
			pthread_mutex_lock(&m_env_mutex);
			LONG* plTemp = &m_lCaptureEnvCount;
			if (0 == *plTemp) {
				*plTemp = 1;
			}
			pthread_mutex_unlock(&m_env_mutex);
#endif // RVC_OS_WIN
		} 
		break;

	case  MOD_EVENT_SNAPSHOT_START_CAPTURE_OPT:
		{
#ifdef RVC_OS_WIN
			InterlockedCompareExchange(&m_lCaptureOptCount, 1, 0);
#else
			pthread_mutex_lock(&m_opt_mutex);
			LONG* plTemp = &m_lCaptureOptCount;
			if (0 == *plTemp) {
				*plTemp = 1;
			}
			pthread_mutex_unlock(&m_opt_mutex);
#endif // RVC_OS_WIN
		}
		break;

	case  LOG_EVT_MOD_ASSISCHAN_STARTED_SUCCESS:
		{
			Sleep(800);
			if (m_pMediaControllerChannel != NULL){
				m_pMediaControllerChannel->GetFunction()->CloseSession();
#ifdef RVC_OS_WIN
				m_pMediaControllerChannel->SafeDelete();
#endif
				m_pMediaControllerChannel = NULL;
				m_bConnectedAssist = false;
			}

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

	case LOG_EVT_BEGIN_HANDLE_BUSINESS:
		if (!m_bJsOccupyCamera) {
			StartAllCameras(true);
		}
		m_bOnBusiness = true;
		break;

	case LOG_EVT_END_HANDLE_BUSINESS:
		if (eCameraOpened == m_eCameraState) {
			DelayCloseCameras();
		}
		m_bOnBusiness = false;
		break;

	case LOG_EVT_RECORDFAILED: 
		{
			GetFunction()->KillTimer(RVC_MEDIADEV_STATUS_CHECK_TIMER);

			char FaildFlag = pszMessage[0];
			if (FaildFlag == '0')
			{
				GetFunction()->SetTimer(RVC_MEDIADEV_STATUS_CHECK_TIMER, this, 5000);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("本地录音录像失败，已停止！");
			}
			else 
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("本地录音录像设备故障，尝试恢复中（预计10s内），请稍等");
				if (false == m_bIsRemoteRecord) {
					m_nCameraErrorCode = Error_AllCamera;
				}
			}
		}
		break;

	case  LOG_EVT_UI_RECORDFAILED: 
		{
			GetFunction()->KillTimer(RVC_MEDIADEV_STATUS_CHECK_TIMER);
			if (m_bIsRemoteRecord){
				LogEvent(Severity_Middle, LOG_EVT_UI_STOPREMOTERECORD, NULL);
			}
				
			GetFunction()->SetTimer(RVC_MEDIADEV_STATUS_CHECK_TIMER, this, 5000);
		}
		break;

	case LOG_EVT_MOD_SALESRECORDER_STARTED_SUCCESS:
		m_bIsRemoteRecord = false;
		break;

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

	case LOG_EVT_UI_STOPREMOTERECORD:
		{
			m_bIsRemoteRecord = false;
			if (Error_Succeed == StopSalesRecordAudioCapture()){

			}

			if (true == m_bHasStartSpeakerRender){
				StopSpeakerAudioRender();
			}
		}
		break;

	case EVENT_MOD_CONNECT_BEGAIN_RECORD_CALL:
		{
			if (true == m_bHasStartSpeakerRender) {
				StopSpeakerAudioRender();
			}
		}
		break;

	case LOG_EVT_MOD_FACETRACKING_STARTED_SUCCESS: 
		{
			if (eCameraClose == m_eCameraState) {
				LogEvent(Severity_Middle, LOG_EVT_MEDIACONTROLLER_RESET_ACTIVECAMERA, "reset active camera.");
			}
		}
		break;

	case LOG_EVT_UI_STARTCAMERACAPTURE:
	{
#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
		HandleStartCameraCapture(pszMessage);
#endif
#endif
	}
	break;

	case LOG_EVT_UI_STOPCAMERACAPTURE:
	{
#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
		HandleStopCameraCapture();
#endif
#endif
	}
	break;

	case LOG_EVT_MEDIACONTROLLER_NOMATCHED_RESOLUTION:
	{
		if (pszMessage) {
			char cdevid = pszMessage[0];
			int idevid = cdevid - '0';
			if (idevid == capture_get_video_device_id(conf.strVideoEnv)) {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V3").setResultCode("RTA2810")("上摄像分辨率不符合要求");
			}
			else if(idevid == capture_get_video_device_id(conf.strVideoOpt)){
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V3").setResultCode("RTA2811")("下摄像分辨率不符合要求");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("no mathed device id.");
			}
		}
	}
	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
	{
		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);
		break;
	case Error_EnvCamera:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to Env_Error");
		SetCameraSysVar(CAMERA_ENV_ERROR);
		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);
		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);
		capture_clearsnapshotvideo(m_capture,AlLCAMERA);
		break;
	default:
		break;
	}

	return Error_Succeed;
}

//开始销售双录音频采集函数
ErrorCodeEnum CMediaControllerEntity::StartSalesRecordAudioCapture(bool bRemoteRecord)
{
	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 = salesrecord_audio_capture_start(m_salesaudio_capture);
		if (Error_Succeed != Error){
			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;
	return Error_Succeed;
}

ErrorCodeEnum CMediaControllerEntity::StartCamera(bool bstartaudio)
{
	if (m_capture == NULL)
	{
		m_eCameraState = eCameraOpening;
		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
		conf.uintervaltime = m_interValTime;
		Error = (ErrorCodeEnum)capture_create(&conf, &m_capture, bstartaudio);
		if (Error == Error_Succeed) 
		{
#ifdef RVC_OS_WIN
#else
			if (bstartaudio) {
				m_capture->handfree_audio->paudiocap = m_pAudioCap;
			}
#endif
			CSmartPointer<IEntityFunction> Func = GetFunction();
			CSimpleStringA strValue("");
			Func->GetSysVar(SYSVAR_SOUNDCARDSTATE, strValue);
			m_capture->config.strAudioState = strValue;
			if ('N' != strValue[0]) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Sound Card State %s.", strValue.GetData());
			}

			Error = capture_start(m_capture, bstartaudio);
			if (Error != Error_Succeed)
			{
				if((Error == Error_AudioIN)||(Error == Error_AudioOut))
				{
					return Error;
				}
				else if (Error == Error_AllCamera)
				{
					capture_stop(m_capture);
					capture_destroy(m_capture);
					m_capture = NULL;
					return Error;
				}
				else
				{
					//SetAutoBright(Error);
					if (!m_bsynchronized) {
						SetConfigBright(Error);
						m_bsynchronized = true;
					}
					GetFunction()->SetTimer(RVC_MEDIADEV_STATUS_CHECK_TIMER, this, 5000);
					if((Error == Error_OptCamera)&&(eStand1SPlusType == m_eDeviceType))
					{
						return Error_Succeed;
					}
					else
					{
						return Error;
					}
				}	
			}
			else
			{
				//SetAutoBright(Error);
				if (!m_bsynchronized) {
					SetConfigBright(Error);
					m_bsynchronized = true;
				}
				GetFunction()->SetTimer(RVC_MEDIADEV_STATUS_CHECK_TIMER, this, 5000);
				return Error_Succeed;
			}
		} 
		else if(Error_Unexpect == Error)
		{
			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;
	}
}


void CMediaControllerEntity::SetCameraState(ErrorCodeEnum errorcode)
{
	if (Error_Succeed == errorcode) {
		SetCameraSysVar(CAMERA_NO_ERROR);
		m_nCameraErrorCode = Error_Succeed;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402208V3")("摄像头打开成功");
	}
	else {
		if (Error_EnvCamera == errorcode) {
			SetCameraSysVar(CAMERA_ENV_ERROR);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_ENV_ERROR");
			m_nCameraErrorCode = Error_EnvCamera;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V3").setResultCode("RTA2803")("上摄像头故障，打开失败");
		}
		else if (Error_OptCamera == errorcode) {
			SetCameraSysVar(CAMERA_OPT_ERROR);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_OPT_ERROR");
			m_nCameraErrorCode = Error_OptCamera;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V3").setResultCode("RTA2804")("下摄像头故障，打开失败");
		}
		else if (Error_AllCamera == errorcode) {
			SetCameraSysVar(CAMERA_BOTH_ERROR);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_BOTH_ERROR");
			m_nCameraErrorCode = Error_AllCamera;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V3").setResultCode("RTA2808")("上下摄像头都故障");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to Other Error");
			m_nCameraErrorCode = errorcode;
			m_eCameraState = eCameraClose;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402208V3").setResultCode("RTA2809")("打开摄像头时出现其它异常");
		}
	}
}

ErrorCodeEnum CMediaControllerEntity::ReStartCamera(int nCamera)
{
	if (m_capture != NULL)
	{
		if((stopcamera(m_capture,nCamera)==-1)){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("restart camera %d, stop camera failed!", nCamera);
		}
		//TODO: CrossPlaform  [Gifur@2025730]
#ifdef RVC_OS_WIN
		Sleep(2000);
#else
		sleep(2);
#endif

		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)("restart camera %d, capture start failed!", nCamera);
				capture_destroy(m_capture, nCamera);
				return Error;
			}
			else
			{
				return Error_Succeed;
			}
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("restart camera %d, capture create failed!", nCamera);
			capture_destroy(m_capture,nCamera);
			return Error;
		}	
	}
	else
	{
		return Error_Unexpect;
	}
}

	
CServerSessionBase *CMediaControllerEntity::OnNewSession(const char* pszRemoteEntityName, const char * pszClass)
{
	return new MediaServiceSession(this);
}


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<char*>(arr2[i].GetData());
		}
		if (arr1.GetCount() > 4){
			snprintf(strSwiftName, MAX_PATH, "%s", result[4]);
		}
		delete tmp;
		tmp = NULL;
	}

	CSimpleStringA strTempDir;
	if (Error_Succeed == GetFunction()->GetPath("Temp", strTempDir)){

	}
	
	if (Error_Succeed == StartSalesRecordAudioCapture(bRemoteRecord)){

	}

#ifdef RVC_OS_WIN
	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);
	}
#endif
		
	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 (Error_Succeed == StartSalesRecordAudioCapture(true)){

	}
	StartSpeakerAudioRender(0, &frame, NULL);	
}

ErrorCodeEnum CMediaControllerEntity::StartSpeakerAudioRender(int iQueue, audio_frame* pFrame, const char* strName)
{
	auto rc = Error_Succeed;
#ifdef RVC_OS_WIN
	if (m_bSpeakerCap){
		if (NULL != m_pAudioRenderObj){
			if(0 == m_pAudioRenderObj->StartRender(0, pFrame, strName)){
				m_bHasStartSpeakerRender = true;
			}
		}
	}
#endif // RVC_OS_WIN

	return rc;
}


ErrorCodeEnum CMediaControllerEntity::StopSpeakerAudioRender()
{
	auto rc = Error_Succeed;
#ifdef RVC_OS_WIN
	if (m_bSpeakerCap){
		if (NULL != m_pAudioRenderObj){
			m_pAudioRenderObj->StopRender();
			m_bHasStartSpeakerRender = false;
		}
	}
#endif // RVC_OS_WIN
	return rc;
}

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

	ErrorCodeEnum Error = m_pMediaControllerChannel->Connect();
	if (Error != Error_Succeed) {
#ifdef RVC_OS_WIN
		m_pMediaControllerChannel->SafeDelete();
#endif
		m_pMediaControllerChannel = NULL;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ChannelMediaControllerClient connect fail!");
		return Error;
	}

	if (Error_Succeed == Error)
	{
		ChannelService_BeginState_Sub Sub;
		Error = (*m_pMediaControllerChannel)(EntityResource::getLink().upgradeLink())->BeginState(Sub);
		if (Error != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("BeginState biz channel failed!");
			m_pMediaControllerChannel->GetFunction()->CloseSession();
#ifdef RVC_OS_WIN
			m_pMediaControllerChannel->SafeDelete();
#endif
			m_pMediaControllerChannel = NULL;
			return Error;
		}
	}

	if (Error_Succeed == Error)
	{
		ChannelService_BeginRecv_Sub Sub;
		Sub.type = ACM_TYPE_DEVICE;
		Error = (*m_pMediaControllerChannel)(EntityResource::getLink().upgradeLink())->BeginRecv(Sub);
		if (Error != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Begin BeginRecv ACM_TYPE_DEVICE failed!");
			m_pMediaControllerChannel->GetFunction()->CloseSession();
#ifdef RVC_OS_WIN
		 	m_pMediaControllerChannel->SafeDelete();
#endif
			m_pMediaControllerChannel = NULL;
			return Error;
		}
	}

	return Error;
}


ErrorCodeEnum CMediaControllerEntity::GetAudioDevices(int& iAudioCount, CSimpleStringA& strAudioDev, int iAudioType)
{
	ErrorCodeEnum Error = Error_Param;
#ifdef RVC_OS_WIN
	if (0 == iAudioType) {
		iAudioCount = capture_get_audio_device_list(0, strAudioDev);
	}
	else {
		iAudioCount = capture_get_audio_device_list(1, strAudioDev);
	}
#else
		if (NULL != m_pAudioCap) {
		strAudioDev = "[";
		if (1 == iAudioType) {
			int icountmic = m_pAudioCap->audio_get_device_count(true);
			for (int i = 0; i < icountmic; i++) {
				char strname[MAX_PATH] = { 0 };
				m_pAudioCap->audio_get_device_name(strname, MAX_PATH, true, i);
				CSimpleStringA str = CSimpleStringA::Format("\"%s\"", strname);
				if (i > 0) {
					strAudioDev += ",";
				}
				strAudioDev += str;
			}
			iAudioCount = icountmic;
		}
		else {
			int icountspeaker = m_pAudioCap->audio_get_device_count(false);
			for (int i = 0; i < icountspeaker; i++) {
				char strname[MAX_PATH] = { 0 };
				m_pAudioCap->audio_get_device_name(strname, MAX_PATH, false, i);
				CSimpleStringA str = CSimpleStringA::Format("\"%s\"", strname);
				if (i > 0) {
					strAudioDev += ",";
				}
				strAudioDev += str;
			}
			iAudioCount = icountspeaker;
		}
		
		strAudioDev += "]";

		Error = Error_Succeed;
	}
#endif

	return Error;
}


ErrorCodeEnum CMediaControllerEntity::GetVideoDevices(int& iVideoCount, CSimpleStringA& strVideoDev)
{
	ErrorCodeEnum Error = Error_Succeed;

	iVideoCount = capture_get_video_device_list(strVideoDev);

	return Error;
}


void CMediaControllerEntity::CheckAutoVideoConfig(capture_config_t* conf)
{
	if (conf) {
		if (0 == conf->strVideoEnv.GetLength() || 0 == conf->strVideoOpt.GetLength()) {
			AutoGetVideoDeviceName(conf);
		}
	}
}


void CMediaControllerEntity::OnCameraStarted()
{
	LogEvent(Severity_Middle, LOG_EVT_MEDIACONTROLLER_CAMERA_STARTED, "camera started.");

	int ienvbrightness = 0;
	capture_get_camera_brightness(&ienvbrightness, m_capture, m_nCameraErrorCode, 0);

	int ioptbrightness = 0;
	capture_get_camera_brightness(&ioptbrightness, m_capture, m_nCameraErrorCode, 1);

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("current env camera brightness is %d, opt camera brightness is %d.", ienvbrightness, ioptbrightness);
}


void CMediaControllerEntity::OnCameraStopped()
{
	LogEvent(Severity_Middle, LOG_EVT_MEDIACONTROLLER_CAMERA_STOPPED, "camera stopped.");
}


void CMediaControllerEntity::LogTransactionRecordCtrEvt(int iEvtType)
{
	if (0 == iEvtType) {
		LogEvent(Severity_Middle, EVENT_MOD_PAUSE_RECORD, "pause record.");
	}
	else {
		LogEvent(Severity_Middle, EVENT_MOD_CONTINUE_RECORD, "continue record.");
	}
}


#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
void CMediaControllerEntity::HandleStartCameraCapture(const char* pszMessage)
{
	int local_view_x = 0;
	int local_view_y = 0;
	int local_view_cx = 0;
	int local_view_cy = 0;
	char strphotoname[256] = { 0 };
	int isecond = 0;
	sscanf(pszMessage, "%d@%d@%d@%d@%d@%s", &local_view_x, &local_view_y, &local_view_cx, &local_view_cy, &isecond, strphotoname);
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("photo name is %s, picture interval time is %d.", strphotoname, isecond);
	if (isecond <= 5) {
		isecond = 5;
	}
	if (!ExistsDirA(m_PhotoSaveDir.GetData())) {
		CreateDirA(m_PhotoSaveDir.GetData(), true);
	}

	if (Error_Succeed != StartSaveEnvCamPhoto(strphotoname, isecond)) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Start Save EnvCam Photo failed.");
	}
}

void CMediaControllerEntity::HandleStopCameraCapture()
{
	if (Error_Succeed != StopSaveEnvCamPhoto()) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Stop Save EnvCam Photo failed.");
	}
}

void CMediaControllerEntity::SetPostCapInfoFlag(bool bpostcapinfo)
{
	m_bPostCapInfo = bpostcapinfo;
}

bool CMediaControllerEntity::GetPostCapInfoFlag()
{
	return m_bPostCapInfo;
}

#endif
#endif

void CMediaControllerEntity::GetCameraBrightness(SpReqAnsContext<MediaService_GetCameraBrightness_Req, MediaService_GetCameraBrightness_Ans>::Pointer ctx)
{
	int ibrightness = 0;
	if (0 == capture_get_camera_brightness(&ibrightness, m_capture, m_nCameraErrorCode, ctx->Req.icameraid)) {
		ctx->Ans.result = 0;
		ctx->Ans.ibrightness = ibrightness;
		ctx->Answer(Error_Succeed);
	}
	else {
		ctx->Ans.result = -1;
		if (0 == ctx->Req.icameraid) {
			ctx->Answer(Error_EnvCamera, LOG_WARN_ENVCAMERA_ERROR);
		}
		else if (1 == ctx->Req.icameraid) {
			ctx->Answer(Error_OptCamera, LOG_WARN_OPTCAMERA_ERROR);
		}
	}
}

void CMediaControllerEntity::SetCameraBrightness(SpReqAnsContext<MediaService_SetCameraBrightness_Req, MediaService_SetCameraBrightness_Ans>::Pointer ctx)
{
	int ibrightness = ctx->Req.ibrightness;
	if (0 == capture_set_camera_brightness(ibrightness, m_capture, m_nCameraErrorCode, ctx->Req.icameraid)) {
		ctx->Ans.result = 0;
		ctx->Answer(Error_Succeed);
	}
	else {
		ctx->Ans.result = -1;
		if (0 == ctx->Req.icameraid) {
			ctx->Answer(Error_EnvCamera, LOG_WARN_ENVCAMERA_ERROR);
		}
		else if (1 == ctx->Req.icameraid) {
			ctx->Answer(Error_OptCamera, LOG_WARN_OPTCAMERA_ERROR);
		}
	}
}


ErrorCodeEnum CMediaControllerEntity::PostCameraBrightnessInfos(int iBrightness)
{
	ErrorCodeEnum Error = Error_Failed;

	brightness_info_t camera_brightness_params;
	camera_brightness_params.strServerURL = m_strHttpServerAddr;
	camera_brightness_params.strAPI = m_strHttpServerAPI;
	camera_brightness_params.strAppVersion = m_strAppVersion;
	camera_brightness_params.strTerminalNo = m_strTerminalId;

	brightness_item_t* item_env = new brightness_item_t();
	item_env->module = "Video";
	item_env->name = "EnvBrightness";
	item_env->value = CSimpleStringA::Format("%d", iBrightness).GetData();
	camera_brightness_params.vBrightnessList.push_back(item_env);

	if (eStand2sType == m_eDeviceType) {
		brightness_item_t* item_opt = new brightness_item_t();
		item_opt->module = "Video";
		item_opt->name = "OptBrightness";
		item_opt->value = CSimpleStringA::Format("%d", iBrightness).GetData();
		camera_brightness_params.vBrightnessList.push_back(item_opt);
	}

	unsigned int uposttime = 0;
	CSimpleStringA strErrorMsg("");
	if (0 == post_camera_brightness_info_list(uposttime, strErrorMsg, &camera_brightness_params, m_iHttpTimeOut, false)) {
		if (500 < uposttime) {
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_POST_CAMERA_BRIGHTNESSINFO_COST_TIME, CSimpleStringA::Format("post camera brightness infos cost time is %ums.", uposttime).GetData());
		}
		Error = Error_Succeed;
	}
	else {
		LogWarn(Severity_Middle, Error_Exception, LOG_EVT_POST_CAMERA_BRIGHTNESSINFO_FAILED, strErrorMsg.GetData());
	}

	for (vector<brightness_item_t*>::iterator it = camera_brightness_params.vBrightnessList.begin(); it < camera_brightness_params.vBrightnessList.end(); ++it) {
		if (NULL != *it) {
			delete* it;
			*it = NULL;
		}
	}
	camera_brightness_params.vBrightnessList.clear();

	return Error;
}

bool CMediaControllerEntity::IsOnlineState()
{
	bool bret = true;
	CSimpleStringA strCallState("");
	if (Error_Succeed == GetFunction()->GetSysVar(SYSVAR_CALLSTATE, strCallState)) {
		if (strCallState.Compare("O") == 0) {
			bret = false;
		}
	}
	return bret;
}

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 (eCameraOpened ==  pEntity->m_eCameraState)
			{
				pEntity->SendCameraBright(pEntity->RvcDeviceType());
			}
		}
	}
}


void ChannelMediaControllerClient::OnMessage( ErrorCodeEnum Error, ChannelService_Packet_Info &Msg, CSmartPointer<IReleasable> pData )
{
	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_GetAudioDevices(SpReqAnsContext<MediaService_GetAudioDevices_Req, MediaService_GetAudioDevices_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	ErrorCodeEnum Error = Error_NotImpl;

	Error = m_pEntity->GetAudioDevices(ctx->Ans.deviceCount, ctx->Ans.strNames, ctx->Req.audioType);

	ctx->Ans.retCode = (int)Error;

	ctx->Answer(Error_Succeed);
}

void MediaServiceSession::Handle_GetVideoDevices(SpReqAnsContext<MediaService_GetVideoDevices_Req, MediaService_GetVideoDevices_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	ErrorCodeEnum Error = Error_NotImpl;

	Error = m_pEntity->GetVideoDevices(ctx->Ans.deviceCount, ctx->Ans.strNames);

	ctx->Ans.retCode = (int)Error;
	ctx->Answer(Error_Succeed);
}


void MediaServiceSession::Handle_GetCameraInfos(SpReqAnsContext<MediaService_GetCameraInfos_Req, MediaService_GetCameraInfos_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	ErrorCodeEnum Error = Error_Succeed;

	char strEnvCamera[MAX_PATH] = { 0 };
	char strEnvUsbPort[MAX_PATH] = { 0 };
	char strOptCamera[MAX_PATH] = { 0 };
	char strOptUsbPort[MAX_PATH] = { 0 };
	//TODO:   [Gifur@2025730]
	char cWord = ';';

#ifdef RVC_OS_LINUX
		cWord = ':';
#endif // RVC_OS_LINUX


	if (0 == GetFormatString(strEnvCamera, MAX_PATH, strEnvUsbPort, MAX_PATH, m_pEntity->conf.strVideoEnv.GetData(), m_pEntity->conf.strVideoEnv.GetLength(), cWord)){
		ctx->Ans.EnvCamera = strEnvCamera;
		ctx->Ans.EnvUsbPort = strEnvUsbPort;
		ctx->Ans.EnvReserved = "";
	}
	else {
		ctx->Ans.EnvCamera = "";
		ctx->Ans.EnvUsbPort = "";
		ctx->Ans.EnvReserved = "";
	}

	if (0 == GetFormatString(strOptCamera, MAX_PATH, strOptUsbPort, MAX_PATH, m_pEntity->conf.strVideoOpt.GetData(), m_pEntity->conf.strVideoOpt.GetLength(), cWord)) {
		ctx->Ans.OptCamera = strOptCamera;
		ctx->Ans.OptUsbPort = strOptUsbPort;
		ctx->Ans.OptReserved = "";
	}
	else {
		ctx->Ans.OptCamera = "";
		ctx->Ans.OptUsbPort = "";
		ctx->Ans.OptReserved = "";
	}

	ctx->Ans.retCode = (int)Error;

	ctx->Answer(Error_Succeed);
}


void MediaServiceSession::Handle_ManipulateCameras(SpReqAnsContext<MediaService_ManipulateCameras_Req, MediaService_ManipulateCameras_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	ErrorCodeEnum Error = Error_NotImpl;

	DeviceTypeEnum eType = m_pEntity->RvcDeviceType();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("rvc Device Type is %s, and cmdType is %d.", Device_Type_Table[eType], ctx->Req.cmdType);
	
	if (ctx->Req.cmdType == 0) {
		LogTransToCMSEvt();
		if (eCameraOpened == m_pEntity->m_eCameraState) {
			Error = m_pEntity->StopCamerasAndRecord();
			//TODO: CrossPlaform  [Gifur@2025730]
#ifdef RVC_OS_WIN
			Sleep(200);
#else
			usleep(200*1000);
#endif
		}
		else {
			m_pEntity->LogTransactionRecordCtrEvt(0);
			Error = Error_Succeed;
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("current is not on business, camera is not on.");
		}
		m_pEntity->m_bJsOccupyCamera = true;
	}
	else {
		//TODO: CrossPlaform  [Gifur@2025730]
#ifdef RVC_OS_WIN
		Sleep(100);
#else
		usleep(100*1000);
#endif
		if (m_pEntity->m_bOnBusiness) {
			Error = m_pEntity->StartCamerasAndRecord();
		}
		else {
			m_pEntity->LogTransactionRecordCtrEvt(1);
			Error = Error_Succeed;
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("current is not on business, not start camera.");
		}
		m_pEntity->m_bJsOccupyCamera = false;
	}

	ctx->Ans.retCode = (int)Error;
	ctx->Answer(Error_Succeed);
}

void MediaServiceSession::Handle_IsCameraOnStatus(SpReqAnsContext<MediaService_IsCameraOnStatus_Req, MediaService_IsCameraOnStatus_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();

	ctx->Ans.biscameraon = (eCameraOpened == m_pEntity->m_eCameraState);

	ctx->Answer(Error_Succeed);
}

void MediaServiceSession::Handle_GetCameraBrightness(SpReqAnsContext<MediaService_GetCameraBrightness_Req, MediaService_GetCameraBrightness_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	m_pEntity->GetCameraBrightness(ctx);
}

void MediaServiceSession::Handle_SetCameraBrightness(SpReqAnsContext<MediaService_SetCameraBrightness_Req, MediaService_SetCameraBrightness_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	m_pEntity->SetCameraBrightness(ctx);
}

void MediaServiceSession::Handle_GetEnvCameraVideoCaptureInfo(SpReqAnsContext<MediaService_GetEnvCameraVideoCaptureInfo_Req, MediaService_GetEnvCameraVideoCaptureInfo_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();

	ErrorCodeEnum Error = Error_Succeed;
#ifdef DEVOPS_ON_PRD

#else
	Error = m_pEntity->GetEnvCameraVideoCaptureInfo(ctx->Ans.strnotice, ctx->Ans.strcmd);
	if (Error_Succeed != Error) {
		Error = Error_Failed;
	}
#endif

	ctx->Answer(Error);
}


void MediaServiceSession::Handle_GetEnvCamRawBrightnessInfo(SpReqAnsContext<MediaService_GetEnvCamRawBrightnessInfo_Req, MediaService_GetEnvCamRawBrightnessInfo_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();

	ErrorCodeEnum Error = Error_Succeed;
	int iMin = 0;
	int iMax = 0;

#ifdef DEVOPS_ON_PRD

#else
	if (Error_Succeed == m_pEntity->GetEnvCamRawBrightnessInfo(&iMin, &iMax)) {
		ctx->Ans.iMinBrightness = iMin;
		ctx->Ans.iMaxBrightness = iMax;
	}
	else {
		ctx->Ans.iMinBrightness = 0;
		ctx->Ans.iMaxBrightness = 0;
		Error = Error_Failed;
	}
#endif
	ctx->Answer(Error);
}

void MediaServiceSession::Handle_SetEnvCamRawBrightness(SpReqAnsContext<MediaService_SetEnvCamRawBrightness_Req, MediaService_SetEnvCamRawBrightness_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	ErrorCodeEnum Error = Error_Succeed;
#ifdef DEVOPS_ON_PRD

#else
	if (Error_Succeed != m_pEntity->SetEnvCamRawBrightness(ctx->Req.iBrightness)) {
		Error = Error_Failed;
	}
#endif
	ctx->Answer(Error);
}

void MediaServiceSession::Handle_TurnOnCamera(SpReqAnsContext<MediaService_TurnOnCamera_Req, MediaService_TurnOnCamera_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	
	if (m_pEntity->m_bJsOccupyCamera || m_pEntity->IsOnlineState()) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA280C").setAPI(__FUNCTION__)("摄像头正在使用中，请断开连线后再试");
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_CAMERAOCCUPYING);
		return;
	}

	ErrorCodeEnum Error = m_pEntity->StartAllCameras(false);
	if (Error_Unexpect == Error) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA280F").setAPI(__FUNCTION__)("摄像头实体异常，请联系总行开发人员排查");
		ctx->Answer(Error_Unexpect, LOG_ERROR_ENTITY_ALLOC_MEM_FAILED);
		return;
	}

#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
	if (ctx->Req.bPostCapInfo) {
		m_pEntity->GetFunction()->SetTimer(RVC_CAMERA_CAP_PROCESS, m_pEntity, 5 * 1000);
		m_pEntity->SetPostCapInfoFlag(true);
	}
#endif
#endif

	ErrorCodeEnum CameraErrorCode = m_pEntity->m_nCameraErrorCode;
	if ( Error_AllCamera != CameraErrorCode) {
		if (Error_Succeed == CameraErrorCode) {
			ctx->Ans.result = 0;
		}
		else if (Error_EnvCamera == CameraErrorCode) {
			ctx->Ans.result = -1;
		}
		else if (Error_OptCamera == CameraErrorCode) {
			ctx->Ans.result = -2;
		}
		ctx->Answer(Error_Succeed);
	}
	else {
		ctx->Ans.result = -3;
		ctx->Answer(Error_AllCamera, LOG_WARN_ALLCAMERA_ERRORS);
	}
}

void MediaServiceSession::Handle_TurnOffCamera(SpReqAnsContext<MediaService_TurnOffCamera_Req, MediaService_TurnOffCamera_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
	if (m_pEntity->GetPostCapInfoFlag()) {
		m_pEntity->GetFunction()->KillTimer(RVC_CAMERA_CAP_PROCESS);
		m_pEntity->SetPostCapInfoFlag(false);
	}
#endif
#endif

	ErrorCodeEnum CamRet = m_pEntity->StopAllCameras();
	if (Error_Succeed == CamRet) {
		ctx->Ans.result = 0;
	}
	else {
		ctx->Ans.result = -1;
	}

	ctx->Answer(Error_Succeed);
}

SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CMediaControllerEntity)
SP_END_ENTITY_MAP()