myvtm/Module/mod_sipphone/unix/mod_sipphone.cpp

#include "stdafx.h"

#include "pthread.h"
#include "mod_sipphone.h"

#include "../mod_agentip/sysvar.h"
#include "../mod_facetracking/sysvar.h"

#include "sockutil.h"

#include "rvc_media_common.h"

#include "../mod_interactivecontrol/Event.h"

#include "audio_session.h"
#include "video_session.h"


//#include "volumekeeper.h"

#define EVT_CONVERTER	"EventConverter"

#define DEVICE_HANDFREE_OUT	0
#define DEVICE_PICKUP_OUT	1
#define DEVICE_HANDFREE_IN	2
#define DEVICE_PICKUP_IN	3

#ifndef DEFAULT_RECORD_VIDEO_WIDTH
#define DEFAULT_RECORD_VIDEO_WIDTH 1056
#endif

#ifndef DEFAULT_RECORD_VIDEO_HEIGHT
#define DEFAULT_RECORD_VIDEO_HEIGHT 595
#endif

#ifndef SMALL_RECORD_VIDEO_WIDTH
#define SMALL_RECORD_VIDEO_WIDTH 244
#endif

#ifndef SMALL_RECORD_VIDEO_HEIGHT
#define SMALL_RECORD_VIDEO_HEIGHT 138
#endif

#ifndef RVC_VIDEO_FRESH_TIME
#define RVC_VIDEO_FRESH_TIME 50
#endif // !RVC_VIDEO_FRESH_TIME

#ifndef RVC_MAX_VIDEO_FRESH_TIME
#define RVC_MAX_VIDEO_FRESH_TIME 200
#endif // !RVC_MAX_VIDEO_FRESH_TIME

#ifndef RVC_MIN_VIDEO_FRESH_TIME
#define RVC_MIN_VIDEO_FRESH_TIME 1
#endif // !RVC_MAX_VIDEO_FRESH_TIME

extern BOOL g_IsExternalTerminalted;

static void __on_video_box_move(int imessagetype, int ivideotype, int ileft, int ibottom, void *user_data)
{
	CSIPPhoneSession *pThis = static_cast<CSIPPhoneSession*>(user_data);
	pThis->on_video_box_move(imessagetype, ivideotype, ileft, ibottom);
}


static void __on_call_state(int state, const char *state_desc, const char *phrase, void *user_data)
{
	CSIPPhoneSession *pThis = static_cast<CSIPPhoneSession*>(user_data);
	if (pThis->m_iLastState != state) {
		pThis->m_iLastState = state;
		pThis->on_call_state(state, state_desc, phrase);
	}
}


static int __make_call(void *user_data)
{
	MakeCallCommand_t *cmd = (MakeCallCommand_t*)user_data;
	int rc = cmd->pSIPPhoneSession->make_call(cmd);
	delete cmd;
	return rc;
}


static int __hangup_call(void *user_data)
{
	HangupCallCommand *cmd = (HangupCallCommand*)(user_data);
	cmd->pSIPPhoneSession->hangup_call(cmd);
	delete cmd;
	return 0;
}


static int __control_video(void *arg)
{
	ControlVideoCommand *pCmd = (ControlVideoCommand*)(arg);
	pCmd->pSIPPhoneSession->control_video(pCmd);
	delete pCmd;
	return 0;
}


static int __video_render(void* arg)
{
	VideoRenderCommand_t* pCmd = (VideoRenderCommand_t*)(arg);
	pCmd->pSIPPhoneSession->video_render(pCmd);
	delete pCmd;
	return 0;
}


static int __release_call(void *user_data)
{
	CSIPPhoneSession *pThis = static_cast<CSIPPhoneSession*>(user_data);
	pThis->release_call();
	pThis->on_call_state(TERMINATED,"STATE:terminated","bye bye");
	return 0;
}


static void __video_render_log(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_INFO, LOG_TYPE_SYSTEM)("%s", buf);
		free(buf);
	}
	else {
		char strlog[MAX_PATH] = { 0 };
		vsnprintf(strlog, MAX_PATH, fmt, arg);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", strlog);
	}
}

static int __on_stop_remote_video_render_callback(void* user_data)
{
	int iret = -1;
	CSIPEntity* pThis = static_cast<CSIPEntity*>(user_data);
	if (NULL != pThis->m_render) {
		if (pThis->m_render->remote_render_threadid > 0) {
			iret = rvc_stop_remote_video_render(pThis->m_render);
		}
	}

	return iret;
}

static int __remote_video_render_callback(void* videoframe, void* user_data)
{
	CSIPEntity* pThis = static_cast<CSIPEntity*>(user_data);

	return rvc_remote_video_render(pThis->m_render, videoframe);
}

static int __on_window_type_callback(void* user_data)
{
	CSIPEntity* pThis = static_cast<CSIPEntity*>(user_data);
	return pThis->m_stVideoParam.bShowPersonArea;
}


static CSimpleStringA generateAudioInfoJson(const char* handfreeIn, const char* handfreeOut, const char* pickupIn, const char* pickupOut)
{
	return CSimpleStringA::Format("{\"handfree_in_dev\":\"%s\",\"handfree_out_dev\":\"%s\",\"pickup_in_dev\":\"%s\",\"pickup_out_dev\":\"%s\"}",
		handfreeIn, handfreeOut, pickupIn, pickupOut);
}


static CSimpleStringA generateVolumeJson(int ihandfreeIn, int ihandfreeOut, int ipickupIn, int ipickupOut)
{
	return CSimpleStringA::Format("{\"handfree_in_volume\":\"%d\",\"handfree_out_volume\":\"%d\",\"pickup_in_volume\":\"%d\",\"pickup_out_volume\":\"%d\"}",
		ihandfreeIn, ihandfreeOut, ipickupIn, ipickupOut);
}


static CSimpleStringA generateAudioDspFlags(endpoint_audiodsp_config_t conf)
{
	int ipickup_in_agc = 0;
	int ipickup_out_agc = 0;
	int ihandfree_in_agc = 0;
	int ihandfree_out_agc = 0;

	int ipickup_in_ns = 0;
	int ipickup_out_ns = 0;
	int ihandfree_in_ns = 0;
	int ihandfree_out_ns = 0;

	int ipickup_aec = 0;
	int ihandfree_aec = 0;

	conf.audio_pickup_in_agc ? ipickup_in_agc = 1 : ipickup_in_agc = 0;
	conf.audio_pickup_out_agc ? ipickup_out_agc = 1 : ipickup_out_agc = 0;
	conf.audio_handfree_in_agc ? ihandfree_in_agc = 1 : ihandfree_in_agc = 0;
	conf.audio_handfree_out_agc ? ihandfree_out_agc = 1 : ihandfree_out_agc = 0;
	conf.audio_pickup_in_ns ? ipickup_in_ns = 1 : ipickup_in_ns = 0;
	conf.audio_pickup_out_ns ? ipickup_out_ns = 1 : ipickup_out_ns = 0;
	conf.audio_handfree_in_ns ? ihandfree_in_ns = 1 : ihandfree_in_ns = 0;
	conf.audio_handfree_out_ns ? ihandfree_out_ns = 1 : ihandfree_out_ns = 0;
	conf.audio_pickup_aec ? ipickup_aec = 1 : ipickup_aec = 0;
	conf.audio_handfree_aec ? ihandfree_aec = 1 : ihandfree_aec = 0;

	return CSimpleStringA::Format("{\"handfree_in_agc\":\"%d\",\"handfree_out_agc\":\"%d\",\"pickup_in_agc\":\"%d\",\"pickup_out_agc\":\"%d\",\"handfree_in_ns\":\"%d\",\"handfree_out_ns\":\"%d\",\"pickup_in_ns\":\"%d\",\"pickup_out_ns\":\"%d\",\"handfree_aec\":\"%d\",\"pickup_aec\":\"%d\"}",
		ihandfree_in_agc, ihandfree_out_agc, ipickup_in_agc, ipickup_out_agc,
		ihandfree_in_ns, ihandfree_out_ns, ipickup_in_ns, ipickup_out_ns,
		ihandfree_aec, ipickup_aec);
}



CSIPPhoneSession::CSIPPhoneSession(CSIPEntity* pEntity) : m_pEntity(pEntity), m_pCall(NULL), m_iLastState(0)
{

}


CSIPEntity::CSIPEntity() : m_pCurrentSession(NULL), m_state(INIT),m_iPickupPhoneState(ePickupMicrophoneState_Off) 
{
	m_kept_volume_in[0] = m_kept_volume_in[1] = 0;
	m_kept_volume_out[0] = m_kept_volume_out[1] = 0;
#ifdef RVC_OS_WIN
	m_pKeeperIn[0] = m_pKeeperIn[1] = NULL;
	m_pKeeperOut[0] = m_pKeeperOut[1] = NULL;
#else
	m_pAudioMgr = NULL;
#endif
	m_SipErrorCode = Error_Succeed;
	memset((void*)&m_stVideoParam,0,sizeof(stVideoParam));
	m_bConnectedAssist = false;
	m_ilocalvideo_freshtime = RVC_VIDEO_FRESH_TIME;
	m_iremotevideo_freshtime = RVC_VIDEO_FRESH_TIME;
	m_render = NULL;
	m_iAudioDspUseCenter = 0;
}


void CSIPEntity::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 LOG_EVT_MOD_ASSISCHAN_STARTED_SUCCESS:
		{
			Sleep(810);
			if (m_pSipphoneChannel != NULL){
				m_bConnectedAssist = false;
				m_pSipphoneChannel->GetFunction()->CloseSession();
				m_pSipphoneChannel = NULL;
			}

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

	case EVENT_MOD_CONNECT_HANDFREE_TO_PICKUP:
	case EVENT_MOD_CONNECT_AGENT_HANDFREE_PICKUP:
	case EVENT_MOD_CONNECT_AGENT_PICKUP_HANDFREE:
	case EVENT_MOD_CONNECT_PICKUP_TO_HANDFREE:
	case EVENT_MOD_CONNECT_PICKUP_CALL:
	case EVENT_MOD_CONNECT_SLV_HANDFREECALL:
	case EVENT_MOD_CONNECT_SLV_PICKUPCALL:
	case LOG_EVT_HANDFREE_MODE_REMOTE_CALL:
	case LOG_EVT_PICKUP_MODE_REMOTE_CALL:
		{
			int old_state = m_iPickupPhoneState;
			if (dwUserCode == EVENT_MOD_CONNECT_HANDFREE_TO_PICKUP) { // 免提->提机
				m_iPickupPhoneState = ePickupMicrophoneState_On;
			} 
			else if (dwUserCode == EVENT_MOD_CONNECT_AGENT_HANDFREE_PICKUP) { //坐席控制免提->提机
				m_iPickupPhoneState = ePickupMicrophoneState_On;
			} 
			else if (dwUserCode == EVENT_MOD_CONNECT_AGENT_PICKUP_HANDFREE) { //坐席控制提机->免提
				m_iPickupPhoneState = ePickupMicrophoneState_Off;
			} 
			else if (dwUserCode == EVENT_MOD_CONNECT_PICKUP_TO_HANDFREE) 
			{ // // 提机->免提
				m_iPickupPhoneState = ePickupMicrophoneState_Off;
			}
			else if (dwUserCode == EVENT_MOD_CONNECT_PICKUP_CALL) 
			{ // 提机拨号
				m_iPickupPhoneState = ePickupMicrophoneState_On;
			}
			else if (dwUserCode == EVENT_MOD_CONNECT_SLV_HANDFREECALL) 
			{   // 免提拨号
				m_iPickupPhoneState = ePickupMicrophoneState_Off;
			}
			else if (dwUserCode == EVENT_MOD_CONNECT_SLV_PICKUPCALL)
			{
				// 通过界面拨号，但话筒未挂，进入提机拨号
				m_iPickupPhoneState = ePickupMicrophoneState_On;
			}
			else if (dwUserCode == LOG_EVT_HANDFREE_MODE_REMOTE_CALL) 
			{   // 免提模式开始远程双录连线
				m_iPickupPhoneState = ePickupMicrophoneState_Off;
			}
			else if (dwUserCode == LOG_EVT_PICKUP_MODE_REMOTE_CALL)
			{
				// 话筒模式开始远程双录连线
				m_iPickupPhoneState = ePickupMicrophoneState_On;
			}

			if (old_state != m_iPickupPhoneState) 
			{
				if (m_iPickupPhoneState == ePickupMicrophoneState_On) 
				{
					SwitchPickup();
				} 
				else 
				{
					SwitchHandFree();
				}
			}
		}
		break;

	case LOG_EVT_ENTER_ACM_FLOW:
		{
			m_stVideoParam.nWindowState = 1;
		}
		break;

	case LOG_EVT_EXIT_ACM_FLOW:
		{
			if(m_stVideoParam.nWindowState == 1)
			{
				m_stVideoParam.nWindowState = 0;
			}
		}
		break;

	case LOG_EVT_CHANGELIVEDETECTIONCAM:
		{
			if (pszMessage && strlen(pszMessage) > 0) 
			{
				int i = atoi(pszMessage);
				m_stVideoParam.iCameraSwitch = i;
			} 
			else 
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("change active display camera param error");
			}
		}
		break;

	case LOG_EVT_RELEASELIVEDETECTION:
		{
			m_stVideoParam.bActiveInspect = 0;
			m_stVideoParam.bShowActiveImg = 0;
			m_stVideoParam.iCameraSwitch = CAMERA_TYPE_ENV;
		}
		break;

		case LOG_EVT_UI_HIDEONLINEVIDEO:
		{
			m_stVideoParam.nWindowState = 2;
			HideBothVideo();
		}
		break;

		case LOG_EVT_UI_SHOWONLINEVIDEO:
		{
			if (m_stVideoParam.nWindowState == 2)
			{
				m_stVideoParam.nWindowState = 3;
				ShowBothVideo();
			}
		}
		break;

		case LOG_EVT_UI_STARTRECORD:
		case LOG_EVT_UI_STARTREMOTERECORD:
		{

		}
		break;

		case LOG_EVT_UI_STARTRECORDPREVIEW:
		{
			m_stVideoParam.bShowRecordArea = 1;
			Handle_RecordVideoLocation_Info(pszMessage);
		}
		break;

		case LOG_EVT_UI_STOPRECORD:
		case LOG_EVT_UI_STOPREMOTERECORD:
		{
			if (m_stVideoParam.bShowRecordArea){
				m_stVideoParam.bShowRecordArea = 0;
			}
			rvc_stop_video_render(m_render);
		}
		break;

		case LOG_EVT_UI_STOPRECORDPREVIEW:
		{
			m_stVideoParam.bShowRecordArea = 0;
		}
		break;

	case LOG_EVT_UI_RETURNMENU:
		{

		}
		break;

		case LOG_EVT_UI_SHOWLOCALVIDEO:
		{
			if (m_stVideoParam.nWindowState == 4)
			{
				m_stVideoParam.nWindowState = 3;
				ShowLocalVideo();
			}
		}
		break;

		case LOG_EVT_UI_HIDELOCALVIDEO:
		{
			m_stVideoParam.nWindowState = 4;
			HideLocalVideo();
		}
		break;

		case LOG_EVT_UI_HIDEPERSONAREA:
		{
			m_stVideoParam.bShowPersonArea = 0;
		}
		break;

		case LOG_EVT_UI_SHOWPERSONAREA:
		{
			m_stVideoParam.bShowPersonArea = 1;
		}
		break;

		case LOG_EVT_UI_ADJUSTVIDEOECHOSIZE:
		{
			Handle_AdjustVideoEchoEvent(pszMessage);
		}
		break;

		default:
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("unknown dwUserCode = 0x%08x.",dwUserCode);
		}
		break;
	}
}


void CSIPEntity::OnSysVarEvent(const char *pszKey, const char *pszValue,const char *pszOldValue,const char *pszEntityName)
{
	if (_stricmp(pszKey, SYSVAR_CAMERASTATE) == 0)
	{
		if (pszValue[0] == 'E')
		{
			m_stVideoParam.iCameraState = CAMERA_TYPE_OPT;
		}
		else if (pszValue[0] == 'O')
		{
			m_stVideoParam.iCameraState = CAMERA_TYPE_ENV;
		}
		else if(pszValue[0] == 'B')   ///////显示贴图
		{
			/////////////////////////此处显示贴图//////////////////////////////////
			//m_stVideoParam.iCameraSwitch = CAMERA_TYPE_ERROR;
			m_stVideoParam.iCameraState = CAMERA_TYPE_ERROR;
		}
		else if (pszValue[0] == 'N')
		{
			m_stVideoParam.iCameraState = CAMERA_TYPE_AUTO;
			//m_stVideoParam.iCameraSwitch = CAMERA_TYPE_AUTO;
		}
	}
	else if (_stricmp(pszKey, SYSVAR_ACTIVETRACKINGCAMERA) == 0) 
	{
		if (pszValue[0] == 'E') 
		{
			m_stVideoParam.iActiveCamera = CAMERA_TYPE_ENV;
		} 
		else if (pszValue[0] == 'O') 
		{
			m_stVideoParam.iActiveCamera = CAMERA_TYPE_OPT;
		} 
		else 
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("warning: unknown ActiveTrackingCamera value!");
		}	
	} 
	else if (_stricmp(pszKey, SYSVAR_AGENTCAMERASWITCH) == 0) 
	{
		if(pszValue[0] == 'E')
		{
			m_stVideoParam.iCameraSwitch = CAMERA_TYPE_ENV;
		} 
		else if(pszValue[0] == 'O')
		{
			m_stVideoParam.iCameraSwitch = CAMERA_TYPE_OPT;
		}
		else if(pszValue[0] == 'A')
		{
			m_stVideoParam.iCameraSwitch = CAMERA_TYPE_AUTO;
		}
	}
	else if (_stricmp(pszKey, SYSVAR_CALLTYPE) == 0) 
	{
		if(pszValue[0] == CALLTYPE_NORMAL)
		{
			m_nSysCallType = 0;
		} 
		else if(pszValue[0] == CALLTYPE_MOBILE)
		{
			m_nSysCallType = 1;
		}
		else 
		{
			m_nSysCallType =-1;
		}
	}
}

	
void CSIPEntity::OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext) 
{ 
	if (Test_ShakeHand == eTestType)
	{
		pTransactionContext->SendAnswer(m_SipErrorCode); 
	}
}

void CSIPEntity::OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
{ 
	ErrorCodeEnum Error = __OnStart(Error_Succeed);
	pTransactionContext->SendAnswer(Error);
}

void CSIPEntity::OnStarted() 
{ 
    LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_ENTITY_STARTED, "sipphone entity started.");

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

	m_pSipphoneChannel = new ChannelSipphoneClient(this);
	if (Error_Succeed == ConnectAssistChannel()){
		m_bConnectedAssist = true;
	}
	else {
		GetFunction()->SetTimer(2, this, 3200);
	}

	LogEvent(Severity_Middle, LOG_EVT_MOD_SIPPHONE_STARTED_SUCCESS, "sip phone started successfully.");
}

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


ErrorCodeEnum CSIPEntity::LoadEntityConfig()
{
	SpIniMappingTable table;
	int iAudioDspUseCenter = 0;

	table.AddEntryInt("SipPhone", "AudioDspUseCenter", iAudioDspUseCenter, 0);

	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
	if (Error == Error_Succeed) {
		Error = table.Load(spConfig);
		if (Error_Succeed == Error) {
			m_iAudioDspUseCenter = iAudioDspUseCenter;
		}
	}

	return Error;
}


ErrorCodeEnum CSIPEntity::ConnectAssistChannel()
{
	if (NULL == m_pSipphoneChannel) {
		m_pSipphoneChannel = new ChannelSipphoneClient(this);
	}

	ErrorCodeEnum Error = m_pSipphoneChannel->Connect();
	if (Error != Error_Succeed) {
		m_pSipphoneChannel = NULL;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ChannelSipphoneClient connect fail!");
		return Error;
	}

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

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

	{
		ChannelService_BeginRecv_Sub Sub;
		Sub.type = ACM_TYPE_VIDEOFREQ;
		Error = (*m_pSipphoneChannel)(EntityResource::getLink().upgradeLink())->BeginRecv(Sub);
		if (Error != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Begin BeginRecv ACM_TYPE_VIDEOFREQ failed!");
			m_pSipphoneChannel->GetFunction()->CloseSession();
			m_pSipphoneChannel = NULL;
			return Error;
		}
	}

	return Error;
}


ErrorCodeEnum CSIPEntity::__OnStart(ErrorCodeEnum preOperationError)
{
	ErrorCodeEnum Error;
	//MessageBoxA(0,0,0,0);
	m_nCallType = NORMAL_CALLTYPE;
	m_nSysCallType = 0;
	m_pSipphoneChannel = new ChannelSipphoneClient(this);
	memset(m_localip,0,256);

#ifdef RVC_OS_LINUX
	{
		audiomgr_callback_t t_callback = { 0 };
		t_callback.debug = &__audiomgrlog;
		m_pAudioMgr = CreateAudioMgrObj(&t_callback);
		if (0 != m_pAudioMgr->audio_mgr_initialize()) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Audio Manager Initialize failed!");
			return Error_Param;
		}
	}
#endif

	m_eDeviceType = RvcGetDeviceType();
	m_stVideoParam.bActiveInspect = 0;
	m_stVideoParam.bShowActiveImg = 0;
	m_stVideoParam.nWindowState = 0;
	m_RecordVideoLocation.x = 0;
	m_RecordVideoLocation.y = 0;
	m_RecordVideoLocation.width = DEFAULT_RECORD_VIDEO_WIDTH;
	m_RecordVideoLocation.height = DEFAULT_RECORD_VIDEO_HEIGHT;

	video_lib_init();
	audio_lib_init();
	endpoint_init_lib();

	Error = GetLocalIP();
	if (Error != 0) {
		CSimpleStringA strErrMsg = "获取本地 IP 地址失败，请检查本地网络是否连接！";
		LogWarn(Severity_Middle, Error_NetBroken, ERROR_MOD_SIP_GET_LOCAL_IP_FAILED, strErrMsg.GetData());
		return Error;
	}

#ifdef RVC_OS_LINUX
	RvcGetAudioDeviceInfo();
#endif

	if (Error_Succeed != LoadEntityConfig()) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("LoadEntityConfig failed.");
	}

	Error = LoadConfig(&conf);
	if (Error != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("load config failed!");
		return Error;
	}

	if (IsPostAudioConfigInfo()) {
		LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_AUDIO_DEVICE_INFO, generateAudioInfoJson(conf.audio_handfree_in_dev, conf.audio_handfree_out_dev, conf.audio_pickup_in_dev, conf.audio_pickup_out_dev).GetData());
	}

	int nhandfreeout = 0;
	int npickupout = 0;
	int nhanfreein = 0;
	int npickupin = 0;
	Error = LoadAudioRunConfig(nhandfreeout,npickupout,nhanfreein,npickupin);
	if (Error == Error_Succeed)
	{
		if (nhandfreeout > 0){
			m_kept_volume_out[DEV_HANDFREE] = nhandfreeout;
		}
		
		if (npickupout > 0){
			m_kept_volume_out[DEV_PICKUP] = npickupout;
		}

		if (nhanfreein > 0){
			m_kept_volume_in[DEV_HANDFREE] = nhanfreein;
		}

		if (npickupin > 0){
			m_kept_volume_in[DEV_PICKUP] = npickupin;
		}
	}

#ifdef RVC_OS_LINUX
	RvcSetSaveAudioVolume();
#endif
		
	{
		CSmartPointer<IEntityFunction> Func = GetFunction();
		Func->GetSystemStaticInfo(staticInfo);
	}
	
	CSimpleStringA strUri = MakeUri(staticInfo.strTerminalID);
	if (strUri.GetLength() > 0) 
	{
		strcpy(conf.uri, strUri);
		conf.media_start_port = REC_COMMON_AUDIO_PORT_START;
		conf.media_stop_port = REC_COMMON_AUDIO_PORT_STOP;
		m_pEndpoint = endpoint_create(this, &conf,DEV_HANDFREE);
		if (!m_pEndpoint) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create endpoint failed!");
			return Error_Unexpect;
		}
	} 
	else 
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("strUri length equals zero!");
		return Error_Unexpect;
	}

	{
		CSmartPointer<IEntityFunction> Func = GetFunction();
		CUUID id;
		int i = 0;
		m_arrListener.Init(30);
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_MOD_CONNECT_HANDFREE_TO_PICKUP, EVT_CONVERTER);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_MOD_CONNECT_PICKUP_TO_HANDFREE, EVT_CONVERTER);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_MOD_CONNECT_PICKUP_CALL, EVT_CONVERTER);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_MOD_CONNECT_SLV_HANDFREECALL,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_MOD_CONNECT_SLV_PICKUPCALL,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_MOD_CONNECT_AGENT_HANDFREE_PICKUP,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_MOD_CONNECT_AGENT_PICKUP_HANDFREE,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_MOD_ASSISCHAN_STARTED_SUCCESS,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_ENTER_ACM_FLOW,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_EXIT_ACM_FLOW,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_CHANGELIVEDETECTIONCAM,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_RELEASELIVEDETECTION,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_HIDEONLINEVIDEO,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_SHOWONLINEVIDEO,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTRECORD,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STOPRECORD,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_RETURNMENU,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_HIDELOCALVIDEO,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_SHOWLOCALVIDEO,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_HIDEPERSONAREA,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_SHOWPERSONAREA,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_MOD_CONNECT_STOP_RECORD_BROADCAST,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_MOD_CONNECT_BEGAIN_RECORD_CALL,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTREMOTERECORD,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STOPREMOTERECORD,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_HANDFREE_MODE_REMOTE_CALL,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_PICKUP_MODE_REMOTE_CALL,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTRECORDPREVIEW,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STOPRECORDPREVIEW,NULL,false);
		m_arrListener[i++] = id;
		Func->SubscribeLog(id, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_ADJUSTVIDEOECHOSIZE,NULL,false);
		m_arrListener[i++] = id;
	}

	{
		CSmartPointer<IEntityFunction> Func = GetFunction();
		CSimpleStringA strValue;
		Func->RegistSysVarEvent(SYSVAR_ACTIVETRACKINGCAMERA, this);
		Func->GetSysVar(SYSVAR_ACTIVETRACKINGCAMERA, strValue);
		if (strValue[0] == 'E') 
		{
			m_stVideoParam.iActiveCamera = CAMERA_TYPE_ENV;
		} 
		else if (strValue[0] == 'O') 
		{
			m_stVideoParam.iActiveCamera = CAMERA_TYPE_OPT;
		} 
		else 
		{
			assert(0);
		}
	}

	{
		CSmartPointer<IEntityFunction> Func = GetFunction();
		CSimpleStringA strValue;
		Func->RegistSysVarEvent(SYSVAR_CAMERASTATE, this);
		Func->GetSysVar(SYSVAR_CAMERASTATE, strValue);
		if (strValue[0] == 'E')
		{
			m_stVideoParam.iCameraState = CAMERA_TYPE_OPT;
		}
		else if (strValue[0] == 'O')
		{
			m_stVideoParam.iCameraState = CAMERA_TYPE_ENV;
		}
		else if(strValue[0] == 'B')   ///////显示贴图
		{
				/////////////////////////此处显示贴图//////////////////////////////////
				//m_stVideoParam.iCameraSwitch = CAMERA_TYPE_ERROR;
				m_stVideoParam.iCameraState = CAMERA_TYPE_ERROR;
		}
		else if (strValue[0] == 'N')
		{
			//m_stVideoParam.iCameraSwitch = CAMERA_TYPE_AUTO;
			m_stVideoParam.iCameraState = CAMERA_TYPE_AUTO;
		}
	}

	{
		CSmartPointer<IEntityFunction> Func = GetFunction();
		CSimpleStringA strValue;
		Func->RegistSysVarEvent(SYSVAR_AGENTCAMERASWITCH, this);
		Func->GetSysVar(SYSVAR_AGENTCAMERASWITCH, strValue);
		if((strValue[0] == 'E'))
		{
			m_stVideoParam.iCameraSwitch = CAMERA_TYPE_ENV;
		} 
		else if((strValue[0] == 'O'))
		{
			m_stVideoParam.iCameraSwitch = CAMERA_TYPE_OPT;
		}
		else if ((strValue[0] == 'A'))
		{
			m_stVideoParam.iCameraSwitch = CAMERA_TYPE_AUTO;
		}
	}

	{
		CSmartPointer<IEntityFunction> Func = GetFunction();
		CSimpleStringA strValue;
		Func->RegistSysVarEvent(SYSVAR_CALLTYPE, this);
		Func->GetSysVar(SYSVAR_CALLTYPE, strValue);
		if (strValue[0] == CALLTYPE_NORMAL) 
		{
			m_nSysCallType = 0;
		} 
		else if (strValue[0] == CALLTYPE_MOBILE) 
		{
			m_nSysCallType = 1;
		} 
		else 
		{
			assert(0);
		}
	}

#ifdef RVC_OS_WIN

	if (m_kept_volume_in[DEV_HANDFREE]) {
		m_pKeeperIn[DEV_HANDFREE] = volume_keeper_create(conf.audio_handfree_in_dev, 1, m_kept_volume_in[DEV_HANDFREE]);
		if (m_pKeeperIn[DEV_HANDFREE]) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("HANDFREE in volume keeper create ok! %d", m_kept_volume_in[DEV_HANDFREE]);
		} 
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HANDFREE in volume keeper create failed!");
		}
	}

	if (m_kept_volume_out[DEV_HANDFREE]) {
		m_pKeeperOut[DEV_HANDFREE] = volume_keeper_create(conf.audio_handfree_out_dev, 0, m_kept_volume_out[DEV_HANDFREE]);
		if (m_pKeeperOut[DEV_HANDFREE]) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("HANDFREE out volume keeper create ok! %d", m_kept_volume_out[DEV_HANDFREE]);
		} 
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HANDFREE out volume keeper create failed!");
		}
	}

	if (m_kept_volume_in[DEV_PICKUP]&&(eStand2sType == m_eDeviceType)){
		m_pKeeperIn[DEV_PICKUP] = volume_keeper_create(conf.audio_pickup_in_dev, 1, m_kept_volume_in[DEV_PICKUP]);
		if (m_pKeeperIn[DEV_PICKUP]) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("PICKUP in volume keeper create ok! %d", m_kept_volume_in[DEV_PICKUP]);
		} 
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PICKUP in volume keeper create failed!");
		}
	}

	if (m_kept_volume_out[DEV_PICKUP]&&(eStand2sType == m_eDeviceType)){
		m_pKeeperOut[DEV_PICKUP] = volume_keeper_create(conf.audio_pickup_out_dev, 0, m_kept_volume_out[DEV_PICKUP]);
		if (m_pKeeperOut[DEV_PICKUP]) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("PICKUP out volume keeper create ok! %d", m_kept_volume_out[DEV_PICKUP]);
		} 
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PICKUP out volume keeper create failed!");
		}
	}
#else

#endif // RVC_OS_WIN
	return Error_Succeed;
}


void CSIPEntity::OnReceivePkt(int type, int sub_type, const char *buffer, int size)
{ 
	if (type == ACM_TYPE_DEVICE)
	{ 
		if (sub_type == ACM_SET_HANDFREE_OUTVOLUMN)
		{
			CVolumnValue num;
			SpBuffer buf;
			buf.OpenRead(buffer,size);
			num.Serialize(buf);
#ifdef RVC_OS_WIN
			if (m_pKeeperOut[DEV_HANDFREE])
			{
				volume_keeper_change(m_pKeeperOut[DEV_HANDFREE], num.nValue);
				m_kept_volume_out[DEV_HANDFREE] = num.nValue;
				SendAudioDeviceVolumn(DEVICE_HANDFREE_OUT);
				SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HANDFREE out volume keeper create failed!");
			}
#else
			if (m_pAudioMgr)
			{
				m_pAudioMgr->audio_set_device_volume(num.nValue, conf.audio_handfree_out_dev, false);
				m_kept_volume_out[DEV_HANDFREE] = num.nValue;
				SendAudioDeviceVolumn(DEVICE_HANDFREE_OUT);
				SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HANDFREE out volume keeper create failed!");
			}
#endif
		} 
		else if((sub_type == ACM_SET_PICKUP_OUTVOLUMN)&&(eStand2sType == m_eDeviceType))
		{
			CVolumnValue num;
			SpBuffer buf;
			buf.OpenRead(buffer,size);
			num.Serialize(buf);
#ifdef RVC_OS_WIN
			if (m_pKeeperOut[DEV_PICKUP])
			{
				if(eStand2sType == m_eDeviceType){
					volume_keeper_change(m_pKeeperOut[DEV_PICKUP],num.nValue);
					m_kept_volume_out[DEV_PICKUP] = num.nValue;
					SendAudioDeviceVolumn(DEVICE_PICKUP_OUT);
					SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE],m_kept_volume_out[DEV_PICKUP],m_kept_volume_in[DEV_HANDFREE],m_kept_volume_in[DEV_PICKUP]);
				}
				else   //pad版屏蔽当前PICKUP音量设置
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PAD type, ignore pickupout volume adj");
				}
			} 
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PICKUP out volume keeper create failed!");
			}
#else
			if (m_pAudioMgr)
			{
				if (eStand2sType == m_eDeviceType)
				{
					m_pAudioMgr->audio_set_device_volume(num.nValue, conf.audio_pickup_out_dev, false);
					m_kept_volume_out[DEV_PICKUP] = num.nValue;
					SendAudioDeviceVolumn(DEVICE_PICKUP_OUT);
					SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
				}
				else   //pad版屏蔽当前PICKUP音量设置
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PAD type, ignore pickupout volume adj");
				}
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PICKUP out volume keeper create failed!");
			}
#endif
		}
		else if (sub_type == ACM_SET_HANDFREE_INVOLUMN)
		{
			CVolumnValue num;
			SpBuffer buf;
			buf.OpenRead(buffer,size);
			num.Serialize(buf);
#ifdef RVC_OS_WIN
			if (m_pKeeperIn[DEV_HANDFREE])
			{
				volume_keeper_change(m_pKeeperIn[DEV_HANDFREE], num.nValue);
				m_kept_volume_in[DEV_HANDFREE] = num.nValue;
				SendAudioDeviceVolumn(DEVICE_HANDFREE_IN);
				SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
			}
			else{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("handfree in volume keeper create failed!");
			}
#else
			if (m_pAudioMgr)
			{
				m_pAudioMgr->audio_set_device_volume(num.nValue, conf.audio_handfree_in_dev, true);
				m_kept_volume_in[DEV_HANDFREE] = num.nValue;
				SendAudioDeviceVolumn(DEVICE_HANDFREE_IN);
				SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("handfree in volume keeper create failed!");
			}
#endif
		} 
		else if((sub_type == ACM_SET_PICKUP_INVOLUMN)&&(eStand2sType == m_eDeviceType))
		{
			CVolumnValue num;
			SpBuffer buf;
			buf.OpenRead(buffer,size);
			num.Serialize(buf);
#ifdef RVC_OS_WIN
			if (m_pKeeperIn[DEV_PICKUP])
			{
				if (eStand2sType == m_eDeviceType)
				{
					volume_keeper_change(m_pKeeperIn[DEV_PICKUP], num.nValue);
					m_kept_volume_in[DEV_PICKUP] = num.nValue;
					SendAudioDeviceVolumn(DEVICE_PICKUP_IN);
					SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
				}
				else   //pad版屏蔽当前PICKUP音量设置
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PAD type, ignore pickupin volume adj");
				}
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pickup in volume keeper create failed!");
			}
#else
			if (m_pAudioMgr)
			{
				if (eStand2sType == m_eDeviceType)
				{
					m_pAudioMgr->audio_set_device_volume(num.nValue, conf.audio_pickup_in_dev, true);
					m_kept_volume_in[DEV_PICKUP] = num.nValue;
					SendAudioDeviceVolumn(DEVICE_PICKUP_IN);
					SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
				}
				else   //pad版屏蔽当前PICKUP音量设置
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PAD type, ignore pickupin volume adj");
				}
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pickup in volume keeper create failed!");
			}
#endif
		} 
		else if (sub_type == ACM_CONTROL_PERSONAREA)   //控制人形框
		{
			CVolumnValue num;
			SpBuffer buf;
			buf.OpenRead(buffer,size);
			num.Serialize(buf);
			if (num.nValue == 0)  //隐藏人形框
			{
				LogEvent(Severity_Middle,LOG_EVT_UI_HIDELOCALVIDEO,"Agent send hide local video");
				LogEvent(Severity_Middle,LOG_EVT_UI_HIDEPERSONAREA,"Agent send Hide Person area");
			} 
			else if (num.nValue == 1)  //显示人形框
			{
				LogEvent(Severity_Middle,LOG_EVT_UI_SHOWLOCALVIDEO,"Agent send show local video");
				LogEvent(Severity_Middle,LOG_EVT_UI_SHOWPERSONAREA,"Agent send Show Person area");	
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("recv control person area sub_type error!");
			}
		}
	}
	else if (type == ACM_TYPE_VIDEOFREQ)
	{

	}	
}


#ifdef RVC_OS_LINUX
ErrorCodeEnum CSIPEntity::RvcGetAudioDeviceInfo()
{
	ErrorCodeEnum Error = Error_Param;
	if (NULL != m_pAudioMgr) {
		int icountmic = m_pAudioMgr->audio_get_device_count(true);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("audio input devices(%d):", icountmic);
		int i = 0;
		CSimpleStringA strJsonIn("");
		for (; i < icountmic; i++) {
			char strname[MAX_PATH] = { 0 };
			m_pAudioMgr->audio_get_device_name(strname, MAX_PATH, true, i);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%d = %s", i, strname);
			strJsonIn += CSimpleStringA::Format("\"%d\":\"%s\",", i, strname);
		}
		if (strJsonIn.GetLength() > 0) {
			strJsonIn[strJsonIn.GetLength() - 1] = '\0';
		}
		CSimpleStringA strJsonInData = CSimpleStringA::Format("audio in devices [{%s}]", strJsonIn.GetData());
		LogWarn(Severity_Low, Error_Debug, LOG_EVT_SIPPHONE_GET_AUDIO_IN_INFOS, strJsonInData.GetData());

		CSimpleStringA strJsonOut("");
		int icountspeaker = m_pAudioMgr->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_pAudioMgr->audio_get_device_name(strname, MAX_PATH, false, i);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%d = %s", i, strname);
			strJsonOut += CSimpleStringA::Format("\"%d\":\"%s\",", i, strname);
		}
		if (strJsonOut.GetLength() > 0) {
			strJsonOut[strJsonOut.GetLength() - 1] = '\0';
		}
		CSimpleStringA strJsonOutData = CSimpleStringA::Format("audio out devices [{%s}]", strJsonOut.GetData());
		LogWarn(Severity_Low, Error_Debug, LOG_EVT_SIPPHONE_GET_AUDIO_OUT_INFOS, strJsonOutData.GetData());

		Error = Error_Succeed;
	}
	return Error;
}


ErrorCodeEnum CSIPEntity::RvcSetSaveAudioVolume()
{
	ErrorCodeEnum Error = Error_Succeed;
	if (eStand2sType == m_eDeviceType) {
		if (m_pAudioMgr){
			m_pAudioMgr->audio_set_device_volume(m_kept_volume_out[DEV_HANDFREE], conf.audio_handfree_out_dev, false);
			m_pAudioMgr->audio_set_device_volume(m_kept_volume_in[DEV_HANDFREE], conf.audio_handfree_in_dev, true);
			m_pAudioMgr->audio_set_device_volume(m_kept_volume_out[DEV_PICKUP], conf.audio_pickup_out_dev, false);
			m_pAudioMgr->audio_set_device_volume(m_kept_volume_in[DEV_PICKUP], conf.audio_pickup_in_dev, true);
		}
	}
	return Error;
}
#endif

void CSIPEntity::HideLocalVideo()
{
	if (NULL != m_render) {
		if (NULL != m_render->plocal_render) {
			m_render->plocal_render->HideVideoWindow();
		}
	}
}

void CSIPEntity::ShowLocalVideo()
{
	if (NULL != m_render) {
		if (NULL != m_render->premote_render && NULL != m_render->plocal_render) {
			m_render->plocal_render->ShowVideoWindow();
			m_render->premote_render->HideVideoWindow();
			m_render->premote_render->ShowVideoWindow();
		}
	}
}

void CSIPEntity::HideBothVideo()
{
	if (NULL != m_render) {
		if (NULL != m_render->premote_render && NULL != m_render->plocal_render) {
			m_render->plocal_render->HideVideoWindow();
			m_render->premote_render->HideVideoWindow();
		}
	}
}


void CSIPEntity::ShowBothVideo()
{
	if (NULL != m_render) {
		if (NULL != m_render->premote_render && NULL != m_render->plocal_render) {
			m_render->plocal_render->ShowVideoWindow();
			m_render->premote_render->ShowVideoWindow();
		}
	}
}


ErrorCodeEnum CSIPEntity::AudioDspFlagsUseCentersetting(endpoint_conf_t* conf)
{
	SpIniMappingTable table;
	CSmartPointer<IConfigInfo> spConfig;

	endpoint_audiodsp_config_t audiodsp = { false, false, false, false, true, false, true, false, false, true };
	table.AddEntryBoolean("SipPhone", "pickup_out_agc", audiodsp.audio_pickup_out_agc, false);
	table.AddEntryBoolean("SipPhone", "pickup_in_agc", audiodsp.audio_pickup_in_agc, false);
	table.AddEntryBoolean("SipPhone", "handfree_in_agc", audiodsp.audio_handfree_in_agc, false);
	table.AddEntryBoolean("SipPhone", "handfree_out_agc", audiodsp.audio_handfree_out_agc, false);
	table.AddEntryBoolean("SipPhone", "pickup_out_ns", audiodsp.audio_pickup_out_ns, false);
	table.AddEntryBoolean("SipPhone", "pickup_in_ns", audiodsp.audio_pickup_in_ns, true);
	table.AddEntryBoolean("SipPhone", "handfree_in_ns", audiodsp.audio_handfree_in_ns, true);
	table.AddEntryBoolean("SipPhone", "handfree_out_ns", audiodsp.audio_handfree_out_ns, false);
	table.AddEntryBoolean("SipPhone", "pickup_aec", audiodsp.audio_pickup_aec, false);
	table.AddEntryBoolean("SipPhone", "handfree_aec", audiodsp.audio_handfree_aec, true);

	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
	if (Error == Error_Succeed) {
		Error = table.Load(spConfig);
		if (Error_Succeed == Error) {
			memcpy(&conf->audio_dsp, &audiodsp, sizeof(endpoint_audiodsp_config_t));
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AudioDspFlagsUseCentersetting load Centersetting failed!");
		memcpy(&conf->audio_dsp, &audiodsp, sizeof(endpoint_audiodsp_config_t));
}
	return Error;
}

bool CSIPEntity::IsPostAudioConfigInfo()
{
	bool bRet = false;
	if (eStand2sType == m_eDeviceType || eStand1SPlusType == m_eDeviceType) {
		if (strlen(conf.audio_handfree_in_dev) && strlen(conf.audio_handfree_out_dev) && strlen(conf.audio_pickup_in_dev) && strlen(conf.audio_pickup_out_dev)) {
			bRet = true;
		}
	}
	else {
		if (strlen(conf.audio_handfree_in_dev) && strlen(conf.audio_handfree_out_dev)) {
			bRet = true;
		}
	}

	return bRet;
}


ErrorCodeEnum CSIPEntity::GetLocalIP()
{
#ifdef RVC_OS_WIN
	char tmp[MAX_PATH] = { 0 };
	gethostname(tmp, sizeof(tmp));
	hostent* ent = gethostbyname(tmp);
	if (ent) {
		for (int i = 0; ent->h_addr_list[i]; ++i) {
			if (ent->h_addrtype == AF_INET) {
				struct in_addr* in = (struct in_addr*)ent->h_addr_list[i];
				char* p = inet_ntoa(*in);
				if (p[0] != '0')
				{
					if (strstr(p, "198.168.") == NULL)
					{
						strcpy(m_localip, p);
						return Error_Succeed;
					}
				}
			}
		}
	}
	return Error_Unexpect;
#else
	ErrorCodeEnum error = Error_Unexpect;
	int sockfd = -1;
	struct ifconf ifconf;
	struct ifreq* ifreq = NULL;
	char strbuf[MAX_PATH] = {0};
	ifconf.ifc_len = MAX_PATH;
	ifconf.ifc_buf = strbuf;
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("socket error");
		return error;
	}
	ioctl(sockfd, SIOCGIFCONF, &ifconf); //get all socket info
	ifreq = (struct ifreq*)ifconf.ifc_buf;
	for (int i = (ifconf.ifc_len / sizeof(struct ifreq)); i > 0; i--){
		if (ifreq->ifr_flags == AF_INET) { //for ipv4
			char* strIP = inet_ntoa(((struct sockaddr_in*) & (ifreq->ifr_addr))->sin_addr);
			ifreq++;
			if (NULL != strIP){
				if (NULL == strstr(strIP, "198.168.") && NULL == strstr(strIP, "127.0.0.1"))
				{
					strcpy(m_localip, strIP);
					error = Error_Succeed;
					break;
				}
			}
		}
	}
	close(sockfd);
	return error;
#endif // RVC_OS_WIN
}


//send audio device volume
void CSIPEntity::SendAudioDeviceVolumn(int nDevice)
{
	if (m_nSysCallType == 0)
	{
		ChannelService_Send_Info Info;
		Info.compress = false;
		Info.encrypt = false;
		Info.type = ACM_TYPE_DEVICE;
		Info.id = 0;

		int nValue = 0;
		bool rslt = false;
			
		void*keeper = NULL;
		if (nDevice == DEVICE_HANDFREE_OUT)
		{
			Info.sub_type = ACM_HANDFREE_OUTVOLUMN;
#ifdef RVC_OS_WIN
			keeper = m_pKeeperOut[DEV_HANDFREE];
#else
			m_pAudioMgr->audio_get_device_volume(&nValue, conf.audio_handfree_out_dev, false);
			rslt = true;
#endif // RVC_OS_WIN
		} 
		else if(nDevice == DEVICE_PICKUP_OUT)
		{
			if(eStand2sType == m_eDeviceType)
			{
				Info.sub_type = ACM_PICKUP_OUTVOLUMN;
#ifdef RVC_OS_WIN
				keeper = m_pKeeperOut[DEV_PICKUP];
#else
				m_pAudioMgr->audio_get_device_volume(&nValue, conf.audio_pickup_out_dev, false);
				rslt = true;
#endif
			}
			else   //pad版屏蔽当前PICKUP音量发送
			{
				return;
			}
		}
		else if(nDevice == DEVICE_HANDFREE_IN)
		{
			Info.sub_type = ACM_HANDFREE_INVOLUMN;
#ifdef RVC_OS_WIN
			keeper = m_pKeeperIn[DEV_HANDFREE];
#else
			m_pAudioMgr->audio_get_device_volume(&nValue, conf.audio_handfree_in_dev, true);
			rslt = true;
#endif
		}
		else if(nDevice == DEVICE_PICKUP_IN)
		{
			if(eStand2sType == m_eDeviceType)
			{
				Info.sub_type = ACM_PICKUP_INVOLUMN;
#ifdef RVC_OS_WIN
				keeper = m_pKeeperIn[DEV_PICKUP];
#else
				m_pAudioMgr->audio_get_device_volume(&nValue, conf.audio_pickup_in_dev, true);
				rslt = true;
#endif
			}
			else   //pad版屏蔽当前PICKUP音量发送
			{
				return;
			}
		}

		Info.data.Alloc(sizeof(int));
		SpBuffer buf;
		buf.OpenWrite();

#ifdef RVC_OS_WIN
		if (keeper){
			rslt = get_audiodevice_volumn(keeper, &nValue);
		}
#endif
		if (rslt == true)
		{
			buf & nValue;
			Info.data = buf.ToBlob();
			m_pSipphoneChannel->Send(Info);
		}
		else
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Get cur Audio device %d volume Fail!",nDevice);
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("cur call type cannot send pkt");
	}
}


ErrorCodeEnum CSIPEntity::SetHandfreeOutVolume(int iVolume)
{
	ErrorCodeEnum Error = Error_Succeed;

#ifdef RVC_OS_WIN
	if (m_pKeeperOut[DEV_HANDFREE]){
		volume_keeper_change(m_pKeeperOut[DEV_HANDFREE], num.nValue);
		m_kept_volume_out[DEV_HANDFREE] = iVolume;
		SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HANDFREE out volume keeper create failed!");
	}
#else
	if (m_pAudioMgr){
		m_pAudioMgr->audio_set_device_volume(iVolume, conf.audio_handfree_out_dev, false);
		m_kept_volume_out[DEV_HANDFREE] = iVolume;
		SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HANDFREE out volume keeper create failed!");
	}
#endif

	return Error;
}

ErrorCodeEnum CSIPEntity::SetPickupOutVolume(int iVolume)
{
	ErrorCodeEnum Error = Error_Succeed;

#ifdef RVC_OS_WIN
	if (m_pKeeperOut[DEV_PICKUP]){
		if (eStand2sType == m_eDeviceType){
			volume_keeper_change(m_pKeeperOut[DEV_PICKUP], iVolume);
			m_kept_volume_out[DEV_PICKUP] = iVolume;
			SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
		}
		else{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PAD type, ignore pickupout volume adj");
		}
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PICKUP out volume keeper create failed!");
	}
#else
	if (m_pAudioMgr){
		if (eStand2sType == m_eDeviceType || eStand1SPlusType == m_eDeviceType){
			m_pAudioMgr->audio_set_device_volume(iVolume, conf.audio_pickup_out_dev, false);
			m_kept_volume_out[DEV_PICKUP] = iVolume;
			SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
		}
		else{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PAD type, ignore pickupout volume adj");
		}
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PICKUP out volume keeper create failed!");
	}
#endif

	return Error;
}

ErrorCodeEnum CSIPEntity::SetHandfreeInVolume(int iVolume)
{
	ErrorCodeEnum Error = Error_Succeed;

#ifdef RVC_OS_WIN
	if (m_pKeeperIn[DEV_HANDFREE]) {
		volume_keeper_change(m_pKeeperIn[DEV_HANDFREE], iVolume);
		m_kept_volume_in[DEV_HANDFREE] = iVolume;
		SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
	}
#else
	if (m_pAudioMgr) {
		m_pAudioMgr->audio_set_device_volume(iVolume, conf.audio_handfree_in_dev, true);
		m_kept_volume_in[DEV_HANDFREE] = iVolume;
		SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HANDFREE in volume keeper create failed!");
	}
#endif

	return Error;
}


ErrorCodeEnum CSIPEntity::SetPickupInVolume(int iVolume)
{
	ErrorCodeEnum Error = Error_Succeed;

#ifdef RVC_OS_WIN
	if (m_pKeeperIn[DEV_PICKUP]) {
		volume_keeper_change(m_pKeeperIn[DEV_PICKUP], iVolume);
		m_kept_volume_in[DEV_PICKUP] = iVolume;
		SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
	}
#else
	if (m_pAudioMgr) {
		if (eStand2sType == m_eDeviceType || eStand1SPlusType == m_eDeviceType) {
			m_pAudioMgr->audio_set_device_volume(iVolume, conf.audio_pickup_in_dev, true);
			m_kept_volume_in[DEV_PICKUP] = iVolume;
			SaveAudioRunConfig(m_kept_volume_out[DEV_HANDFREE], m_kept_volume_out[DEV_PICKUP], m_kept_volume_in[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP]);
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PAD type, ignore pickupin volume adj");
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PICKUP in volume keeper create failed!");
	}
#endif
	return Error;
}



void CSIPEntity::OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext) 
{ 
	ErrorCodeEnum Error = __OnClose(Error_Succeed);
	pTransactionContext->SendAnswer(Error); 
}


ErrorCodeEnum CSIPEntity::__OnClose(ErrorCodeEnum preOperationError)
{
	int i;

#ifdef RVC_OS_WIN
	if (m_pKeeperIn[DEV_HANDFREE]) {
		volume_keeper_destroy(m_pKeeperIn[DEV_HANDFREE]);
		m_pKeeperIn[DEV_HANDFREE] = NULL;
	}
	if (m_pKeeperOut[DEV_HANDFREE]) {
		volume_keeper_destroy(m_pKeeperOut[DEV_HANDFREE]);
		m_pKeeperOut[DEV_HANDFREE] = NULL;
	}
	if (m_pKeeperIn[DEV_PICKUP]) {
		volume_keeper_destroy(m_pKeeperIn[DEV_PICKUP]);
		m_pKeeperIn[DEV_PICKUP] = NULL;
	}
	if (m_pKeeperOut[DEV_PICKUP]) {
		volume_keeper_destroy(m_pKeeperOut[DEV_PICKUP]);
		m_pKeeperOut[DEV_PICKUP] = NULL;
	}
#else
	if (NULL != m_pAudioMgr) {
		m_pAudioMgr->audio_mgr_terminate();
		DestroyIAudioMgrObj(m_pAudioMgr);
		m_pAudioMgr = NULL;
	}
#endif

	CSmartPointer<IEntityFunction> Func = GetFunction();
	Func->UnregistSysVarEvent(SYSVAR_AGENTCAMERASWITCH);
	Func->UnregistSysVarEvent(SYSVAR_ACTIVETRACKINGCAMERA);
	Func->UnregistSysVarEvent(SYSVAR_CAMERASTATE);
	Func->UnregistSysVarEvent(SYSVAR_CALLTYPE);
		
	for (i = 0; i < m_arrListener.GetCount(); ++i) {
		Func->UnsubscribeLog(m_arrListener[i]);
	}
	m_arrListener.Clear();

	endpoint_destroy(m_pEndpoint);
	m_pEndpoint = NULL;

	video_lib_deinit();
	audio_lib_deinit();
	endpoint_deinit_lib();

	return Error_Succeed;
}


void CSIPEntity::OnPaused()
{

}


void CSIPEntity::OnContinued()
{

}


CServerSessionBase*	CSIPEntity::OnNewSession(const char* /*pszRemoteEntityName*/, const char * /*pszClass*/)
{
	m_pCurrentSession = new CSIPPhoneSession(this);
	return m_pCurrentSession;
}


void CSIPEntity::OnTimeout(DWORD dwTimerID)
{
	if (dwTimerID == 1)
	{
		//如果当前动态帧频不等于之前的帧频，发送当前帧频
		//if (g_nDynamicFps != m_nDownDynamicFps)
		//{
		//	m_nDownDynamicFps = g_nDynamicFps;
		//	SendDynamicFps(g_nDynamicFps);
		//}
		GetFunction()->KillTimer(1);
		m_stVideoParam.nUpDynamicFps = -1;
	}
	else if (2 == dwTimerID)
	{
		if (!m_bConnectedAssist) {
			if (Error_Succeed == ConnectAssistChannel()) {
				m_bConnectedAssist = true;
			}
		}

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


ErrorCodeEnum CSIPEntity::InitEndpoint() 
{	
	ErrorCodeEnum eCode = Error_Param;
	CSmartPointer<IEntityFunction> Func = GetFunction();
	Func->GetSystemStaticInfo(staticInfo);
		
	CSimpleStringA strUri = MakeUri(staticInfo.strTerminalID);
	if (strUri.GetLength() > 0) 
	{
		strcpy(conf.uri, strUri);
		conf.media_start_port = REC_COMMON_AUDIO_PORT_START;
		conf.media_stop_port = REC_COMMON_AUDIO_PORT_STOP;
		m_pEndpoint = endpoint_create(this, &conf,DEV_HANDFREE);
		if (!m_pEndpoint) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create endpoint failed!");
			eCode = Error_Unexpect;
		}
		else{
			eCode = Error_Succeed;
		}
	} 
	else 
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("strUri length equals zero!");
		eCode =  Error_Unexpect;
	}

	return eCode;
}


void CSIPEntity::change_dev(int dev_type)
{
	if (m_pEndpoint) {
		endpoint_change_audio_dev(m_pEndpoint, dev_type);
	}
}


static int __change_dev(void *arg)
{
	ChangeDevCommand *pCmd = (ChangeDevCommand *)arg;
	pCmd->pEntity->change_dev(pCmd->dev_type);
	delete pCmd;
	return 0;
}


void CSIPEntity::SwitchHandFree()
{
	int rc = 0;
	ChangeDevCommand *pCmd = new ChangeDevCommand();
	pCmd->pEntity = this;
	pCmd->dev_type = DEV_HANDFREE;
	if (endpoint_invoke(m_pEndpoint, &__change_dev, pCmd, &rc) != 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("endpoint invoke failed!");
		delete pCmd;
	}
}


void CSIPEntity::SwitchPickup()
{
	int rc = 0;
	ChangeDevCommand *pCmd = new ChangeDevCommand();
	pCmd->pEntity = this;
	pCmd->dev_type = DEV_PICKUP;
	if (endpoint_invoke(m_pEndpoint, &__change_dev, pCmd, &rc) != 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("endpoint invoke failed!");
		delete pCmd;
	}
}


void CSIPEntity::SetState(int state)
{
	m_state = state;
}


ErrorCodeEnum CSIPEntity::RealSelfCheck()
{
	ErrorCodeEnum Error = Error_Succeed;
	if (m_pHMClient)
	{
		HealthManagerService_RealCheck_Req req;
		req.name = GetEntityName();
		HealthManagerService_RealCheck_Ans ans;
		DWORD Timeout = 500;
		Error = m_pHMClient->RealCheck(req,ans,Timeout);
		if (Error!=Error_Succeed){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RealSelfcheck fail!");
		}
	}
	return Error;
}


CSimpleStringA CSIPEntity::MakeUri(const char *terminal_id)
{
	return CSimpleStringA::Format("sip:%s@%s;transport=UDP", terminal_id, m_localip);
}


void CSIPEntity::Handle_RecordVideoLocation_Info(const char* pszMessage)
{
	if (NULL == pszMessage){
		return;
	}

	CSimpleStringA strMsg = pszMessage;

	int lxPos,lyPos,lwidth,lheight;
	CSimpleStringA str;
	sscanf(strMsg.GetData(), "%d@%d@%d@%d@%d@%s", &lxPos, &lyPos, &lwidth, &lheight, &str);
	m_RecordVideoLocation.x = lxPos;
	m_RecordVideoLocation.y = lyPos;
	m_RecordVideoLocation.width = lwidth;
	m_RecordVideoLocation.height = lheight;
}


void CSIPEntity::Handle_AdjustVideoEchoEvent(const char* pszMessage)
{
	if (NULL == pszMessage){
		return;
	}

	CSimpleStringA strMsg = pszMessage;

	int lxPos,lyPos,lwidth,lheight;
	CSimpleStringA str;
	sscanf(strMsg.GetData(), "%d@%d@%d@%d@%d@%s", &lxPos, &lyPos, &lwidth, &lheight, &str);
	if (DEFAULT_RECORD_VIDEO_WIDTH == lwidth && DEFAULT_RECORD_VIDEO_HEIGHT == lheight){
		m_stVideoParam.nWindowState = 0;
	}
	else if(SMALL_RECORD_VIDEO_WIDTH == lwidth && SMALL_RECORD_VIDEO_HEIGHT == lheight){
		m_stVideoParam.nWindowState = 5;
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("not support width and height.");
	}
	m_RecordVideoLocation.x = lxPos;
	m_RecordVideoLocation.y = lyPos;
	m_RecordVideoLocation.width = lwidth;
	m_RecordVideoLocation.height = lheight;
}


void CSIPEntity::InitFreshTimeConfig()
{
	int ileftvideo = RVC_MAX_VIDEO_FRESH_TIME;
	int irightvideo = RVC_MAX_VIDEO_FRESH_TIME;

    CSmartPointer<IConfigInfo> spCacheConfig;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_CenterSetting, spCacheConfig);
	if (Error_Succeed == Error){
		SpIniMappingTable table;
		table.AddEntryInt("SIPPhone", "lfreshtime", ileftvideo, RVC_MAX_VIDEO_FRESH_TIME);
		table.AddEntryInt("SIPPhone", "rfreshtime", irightvideo, RVC_MAX_VIDEO_FRESH_TIME);
		Error = table.Load(spCacheConfig);
		if (Error == Error_Succeed) {
			if (0 == ileftvideo) {
				ileftvideo = RVC_MAX_VIDEO_FRESH_TIME/2;
			}
			if (0 == irightvideo) {
				irightvideo = RVC_MAX_VIDEO_FRESH_TIME/2;
			}

			if (ileftvideo < RVC_MIN_VIDEO_FRESH_TIME) {
				ileftvideo = RVC_MIN_VIDEO_FRESH_TIME;
			}
			if (ileftvideo > RVC_MAX_VIDEO_FRESH_TIME) {
				ileftvideo = RVC_MAX_VIDEO_FRESH_TIME;
			}

			if (irightvideo < RVC_MIN_VIDEO_FRESH_TIME) {
				irightvideo = RVC_MIN_VIDEO_FRESH_TIME;
			}
			if (irightvideo > RVC_MAX_VIDEO_FRESH_TIME) {
				irightvideo = RVC_MAX_VIDEO_FRESH_TIME;
			}
		}
	}

	LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_OVERWRITE_FRESHVALUE,
			CSimpleStringA::Format("overwrite video freshtime from centersetting cache, left fresh time is %d, right fresh time is %d.", ileftvideo, irightvideo).GetData());
    m_ilocalvideo_freshtime = ileftvideo;
	m_iremotevideo_freshtime = irightvideo;	
}


ErrorCodeEnum CSIPEntity::LoadConfig(endpoint_conf_t *conf)
{
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSmartPointer<IConfigInfo> spRootConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Root, spRootConfig);
	if (Error == Error_Succeed) {
		CSimpleStringA strHandFreeIn;
		CSimpleStringA strHandFreeOut;
		CSimpleStringA strPickupIn;
		CSimpleStringA strPickupOut;
		SpIniMappingTable table;
		table.AddEntryString("audio", "handfree_in_dev", strHandFreeIn, "$");
		table.AddEntryString("audio", "handfree_out_dev", strHandFreeOut, "$");
		table.AddEntryString("audio", "pickup_in_dev", strPickupIn, "$");
		table.AddEntryString("audio", "pickup_out_dev", strPickupOut, "$");
		table.AddEntryBoolean("audio", "pickup_out_agc", conf->audio_dsp.audio_pickup_out_agc, false);
		table.AddEntryBoolean("audio", "pickup_in_agc", conf->audio_dsp.audio_pickup_in_agc, false);
		table.AddEntryBoolean("audio", "handfree_in_agc", conf->audio_dsp.audio_handfree_in_agc, false);
		table.AddEntryBoolean("audio", "handfree_out_agc", conf->audio_dsp.audio_handfree_out_agc, false);
		table.AddEntryBoolean("audio", "pickup_out_ns", conf->audio_dsp.audio_pickup_out_ns, false);
		table.AddEntryBoolean("audio", "pickup_in_ns", conf->audio_dsp.audio_pickup_in_ns, false);
		table.AddEntryBoolean("audio", "handfree_in_ns", conf->audio_dsp.audio_handfree_in_ns, false);
		table.AddEntryBoolean("audio", "handfree_out_ns", conf->audio_dsp.audio_handfree_out_ns, false);
		table.AddEntryBoolean("audio", "pickup_aec", conf->audio_dsp.audio_pickup_aec, false);
		table.AddEntryBoolean("audio", "handfree_aec", conf->audio_dsp.audio_handfree_aec, false);
		table.AddEntryInt("audio", "handfree_in_volume", m_kept_volume_in[DEV_HANDFREE], 0);
		table.AddEntryInt("audio", "handfree_out_volume", m_kept_volume_out[DEV_HANDFREE], 0);
		table.AddEntryInt("audio", "pickup_in_volume", m_kept_volume_in[DEV_PICKUP], 0);
		table.AddEntryInt("audio", "pickup_out_volume", m_kept_volume_out[DEV_PICKUP], 0);
		table.AddEntryInt("video", "quant", conf->quant, 0);
		table.AddEntryInt("video", "mtu", conf->mtu, 0);
		Error = table.Load(spRootConfig);
		if (Error == Error_Succeed) {			
			int id = -1;
			snprintf(conf->audio_handfree_in_dev, MAX_PATH, "%s", strHandFreeIn.GetData());
			snprintf(conf->audio_handfree_out_dev, MAX_PATH, "%s", strHandFreeOut.GetData());
			snprintf(conf->audio_pickup_in_dev, MAX_PATH, "%s", strPickupIn.GetData());
			snprintf(conf->audio_pickup_out_dev, MAX_PATH, "%s", strPickupOut.GetData());
			
			LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_AUDIO_VOLUME_INFO, generateVolumeJson(m_kept_volume_in[DEV_HANDFREE], m_kept_volume_out[DEV_HANDFREE], m_kept_volume_in[DEV_PICKUP], m_kept_volume_out[DEV_PICKUP]));
			LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_AUDIO_DSP_INFO, generateAudioDspFlags(conf->audio_dsp).GetData());
			
			if (m_iAudioDspUseCenter) {
				AudioDspFlagsUseCentersetting(conf);
				LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_CENTER_AUDIO_DSP_FLAGS, generateAudioDspFlags(conf->audio_dsp).GetData());
			}

#ifdef RVC_OS_WIN
			id = capture_get_audio_device_id(true, strHandFreeIn.GetData());
#else
			id = m_pAudioMgr->audio_get_device_id(strHandFreeIn.GetData(), true);
#endif
			if (id == -1) {
				CSimpleStringA strErrMsg = "外部麦克风配置错误，请重新配置！";
				LogWarn(Severity_Middle, Error_Param, EVENT_MOD_SIP_AUDIO_IN_DEVICE_NOT_EXIST, strErrMsg.GetData());
				Error = Error_Param;
			}
			
#ifdef RVC_OS_WIN					
			id = capture_get_audio_device_id(false, strHandFreeOut.GetData());
#else
			id = m_pAudioMgr->audio_get_device_id(strHandFreeOut.GetData(), false);
#endif
			if (id == -1) {
				CSimpleStringA strErrMsg = "外部扬声器配置错误，请重新配置！";
				LogWarn(Severity_Middle, Error_Param, EVENT_MOD_SIP_AUDIO_OUT_DEVICE_NOT_EXIST, strErrMsg.GetData());
				Error = Error_Param;
			}
			

#ifdef RVC_OS_WIN
			id = capture_get_audio_device_id(true, strPickupIn.GetData());
#else
			id = m_pAudioMgr->audio_get_device_id(strPickupIn.GetData(), true);
#endif
			if (id == -1) {
				CSimpleStringA strErrMsg = "话筒麦克风(大机)配置错误，请重新配置！";
				LogWarn(Severity_Middle, Error_Param, EVENT_MOD_SIP_AUDIO_IN_DEVICE_NOT_EXIST, strErrMsg.GetData());
				Error = Error_Param;
			}
			
#ifdef RVC_OS_WIN
			id = capture_get_audio_device_id(false, strPickupOut.GetData());
#else
			id = m_pAudioMgr->audio_get_device_id(strPickupOut.GetData(), false);
#endif				
			if (id == -1) {
				CSimpleStringA strErrMsg = "话筒扬声器(大机)配置错误，请重新配置！";
				LogWarn(Severity_Middle, Error_Param, EVENT_MOD_SIP_AUDIO_OUT_DEVICE_NOT_EXIST, strErrMsg.GetData());
				Error = Error_Param;
			}

			conf->ref_active_camera = &m_stVideoParam.iActiveCamera;
			conf->ref_camera_switch = &m_stVideoParam.iCameraSwitch;
			conf->ref_window_state = &m_stVideoParam.nWindowState;
			conf->ref_active_img = &m_stVideoParam.bShowActiveImg;
			conf->ref_Is_ActiveInspect = &m_stVideoParam.bActiveInspect;
			conf->ref_camera_state = &m_stVideoParam.iCameraState;
			conf->ref_Is_showPersonArea = &m_stVideoParam.bShowPersonArea;
			conf->ref_Is_showRecordArea = &m_stVideoParam.bShowRecordArea;

			m_stVideoParam.nUpDynamicFps = 0;
			
			conf->ref_Up_Fps = &m_stVideoParam.nUpDynamicFps;
			if (eStand1SPlusType == m_eDeviceType)
			{
				conf->camera_count = 1;
			}
			else if(eStand2sType == m_eDeviceType)
			{
				conf->camera_count = 2;
			}
			//DecideCameraCount(conf->camera_count);
			DecideScreenCount(conf->screen_count);

		}
	}

	InitFreshTimeConfig();

	return Error;
}


//载入运行时配置
ErrorCodeEnum CSIPEntity::LoadAudioRunConfig(int&nHandfreeout,int&nPickupout,int&nHandfreein,int&nPickupin)
{
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed) 
	{
		SpIniMappingTable table;
		table.AddEntryInt("Audio", "handfree_out_volume", nHandfreeout, 0);	
		table.AddEntryInt("Audio", "pickup_out_volume", nPickupout, 0);		
		table.AddEntryInt("Audio", "handfree_in_volume", nHandfreein, 0);	
		table.AddEntryInt("Audio", "pickup_in_volume", nPickupin, 0);	
		Error = table.Load(spConfig);
		if (Error != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] failed to load run config.");
		}
	}
	else 
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] failed to open run config.");
	}
	return Error;
}

	//保存运行时
ErrorCodeEnum CSIPEntity::SaveAudioRunConfig(int nHandfreeout,int nPickupout,int nHandfreein,int nPickupin)
{
	CSmartPointer<IEntityFunction> spFunction = GetFunction();;
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed) 
	{
		Error = spConfig->WriteConfigValueInt("Audio", "handfree_out_volume", nHandfreeout);
		if(Error == Error_Succeed)
		{
			Error = spConfig->WriteConfigValueInt("Audio", "pickup_out_volume", nPickupout);
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SaveAudioRunConfig handfree_out_volume fail!");
			return Error;
		}

		if(Error == Error_Succeed)
		{
			Error = spConfig->WriteConfigValueInt("Audio", "handfree_in_volume", nHandfreein);
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SaveAudioRunConfig pickup_out_volume fail!");
			return Error;
		}

		if(Error == Error_Succeed)
		{
			Error = spConfig->WriteConfigValueInt("Audio", "pickup_in_volume", nPickupin);
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SaveAudioRunConfig handfree_in_volume fail!");
			return Error;
		}

		if (Error != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SaveAudioRunConfig pickup_in_volume fail!");
			return Error;
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SaveAudioRunConfig is fail , open sipphone.ini fail!");
	}

	return Error;
}


ErrorCodeEnum CSIPEntity::DecideScreenCount(int &nCount)
{
	CSystemStaticInfo Info;
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	ErrorCodeEnum Error = spFunction->GetSystemStaticInfo(Info);
	if (Error == Error_Succeed) 
	{
		nCount = (int)Info.eScreen;
	}
	return Error;
}


DeviceTypeEnum CSIPEntity::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_INFO, LOG_TYPE_SYSTEM)("device type is %s.", Device_Type_Table[eType]);
	}
	return eType;
}



//
// CSIPPhoneSession
//


void CSIPPhoneSession::OnClose( ErrorCodeEnum eErrorCode )
{
}

void CSIPPhoneSession::Handle_MakeCall( SpReqAnsContext<PhoneService_MakeCall_Req, PhoneService_MakeCall_Ans>::Pointer ctx )
{
	DbgToBeidou(ctx->link, __FUNCTION__)();

	LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_CALL_URL, CSimpleStringA::Format("make call [%s]", ctx->Req.to_uri.GetData()).GetData());

	int rc = Error_Succeed;
	MakeCallCommand_t *cmd = new MakeCallCommand_t();
	cmd->pSIPPhoneSession = this;
	cmd->toUri = ctx->Req.to_uri;
	cmd->fromUri = ctx->Req.from_uri;
	cmd->callId = ctx->Req.call_id;
	cmd->imapped_audio_port = 0;
	cmd->imapped_video_port = 0;
	///////////重新初始化sip话机,防止断网导致IP改变//////////////////

	if (m_pEntity->m_pEndpoint){
		endpoint_destroy(m_pEntity->m_pEndpoint);
		m_pEntity->m_pEndpoint = NULL;
	}

	ErrorCodeEnum  Error = m_pEntity->GetLocalIP();
	if (Error != 0){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get local ip failed!");
		ctx->Answer(Error_Unexpect);
		return;
	}
	cmd->strlocalip = m_pEntity->m_localip;

	CSimpleStringA strUri = m_pEntity->MakeUri(m_pEntity->staticInfo.strTerminalID);
	if (strUri.GetLength() > 0) 
	{
		strcpy(m_pEntity->conf.uri, strUri);
		m_pEntity->conf.media_start_port = REC_COMMON_AUDIO_PORT_START;
		m_pEntity->conf.media_stop_port = REC_COMMON_AUDIO_PORT_STOP;
		m_pEntity->m_pEndpoint = endpoint_create(m_pEntity, &m_pEntity->conf,m_pEntity->m_iPickupPhoneState);
		if (!m_pEntity->m_pEndpoint){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create endpoint failed!");
			return;
		}
		else {
			cmd->iaudio_port = new_media_port(m_pEntity->m_pEndpoint);
			cmd->ivideo_port = REC_COMMON_VIDEO_PORT;
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("strUri length equals zero!");
	}

	///////////重新初始化sip话机,防止断网导致IP改变//////////////////
	if (m_pEntity->GetEndpoint()) {
		endpoint_invoke(m_pEntity->GetEndpoint(), &__make_call, cmd, &rc);
	}
	ctx->Answer((ErrorCodeEnum)rc);
}

void CSIPPhoneSession::Handle_HangupCall( SpReqAnsContext<PhoneService_HangupCall_Req, PhoneService_HangupCall_Ans>::Pointer ctx )
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	int rc = Error_Succeed;
	HangupCallCommand *cmd = new HangupCallCommand();
	cmd->pSIPPhoneSession = this;
	cmd->strSession_num = ctx->Req.session_num;
	cmd->strBranch_server_ip = ctx->Req.branch_server_ip;
	cmd->iBranch_server_port = ctx->Req.branch_server_port;
	if (m_pEntity->GetEndpoint())
	{
		endpoint_invoke(m_pEntity->GetEndpoint(), &__hangup_call, cmd, &rc);
	}
	ctx->Answer((ErrorCodeEnum)rc);
}


void CSIPPhoneSession::Handle_ReleaseCall( SpReqAnsContext<PhoneService_ReleaseCall_Req, PhoneService_ReleaseCall_Ans>::Pointer ctx )
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	int rc = Error_Succeed;
	g_IsExternalTerminalted = TRUE;
	endpoint_invoke(m_pEntity->GetEndpoint(), &__release_call, this, &rc);
	if (NULL != m_pEntity->m_pEndpoint){
		endpoint_destroy(m_pEntity->m_pEndpoint);
		m_pEntity->m_pEndpoint = NULL;
	}
	
	ctx->Answer((ErrorCodeEnum)rc);
}

void CSIPPhoneSession::Handle_SetCallingParam(SpOnewayCallContext<PhoneService_SetCallingParam_Info>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	m_pEntity->m_nCallType = (CallingTypeEnum)ctx->Info.CallType;
}

void CSIPPhoneSession::Handle_RealErrorCheck(SpOnewayCallContext<PhoneService_RealErrorCheck_Info>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	m_pEntity->m_SipErrorCode = Error_InvalidState;
	m_pEntity->RealSelfCheck();
}

void CSIPPhoneSession::Handle_StartVideo( SpOnewayCallContext<PhoneService_StartVideo_Info>::Pointer ctx )
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	int rc;
	ControlVideoCommand *pCmd = new ControlVideoCommand();
	pCmd->pSIPPhoneSession = this;
	pCmd->start = TRUE;
	pCmd->local_hwd_move = 0;
	pCmd->remote_hwd_move = 0;
	pCmd->local_ip = inet_addr(m_pEntity->m_localip);
	pCmd->local_port = REC_COMMON_VIDEO_PORT;
	pCmd->remote_ip = inet_addr(ctx->Info.remote_ip);
	pCmd->remote_port = ctx->Info.remote_port;
	pCmd->local_view_x = ctx->Info.local_view_x;
	pCmd->local_view_y = ctx->Info.local_view_y;
	pCmd->local_view_cx = ctx->Info.local_view_cx;
	pCmd->local_view_cy = ctx->Info.local_view_cy;
	pCmd->remote_view_x = ctx->Info.remote_view_x;
	pCmd->remote_view_y = ctx->Info.remote_view_y;
	pCmd->remote_view_cx = ctx->Info.remote_view_cx;
	pCmd->remote_view_cy = ctx->Info.remote_view_cy;
	pCmd->remote_width = ctx->Info.remote_width;
	pCmd->remote_height = ctx->Info.remote_height;
	pCmd->local_hwd_move = ctx->Info.local_hwd_move;
	pCmd->remote_hwd_move = ctx->Info.remote_hwd_move;
	pCmd->local_fresh_time = m_pEntity->m_ilocalvideo_freshtime;
	pCmd->remote_fresh_time = m_pEntity->m_iremotevideo_freshtime;

	endpoint_invoke(m_pEntity->GetEndpoint(), &__control_video, pCmd, &rc);
}

void CSIPPhoneSession::Handle_StopVideo( SpOnewayCallContext<PhoneService_StopVideo_Info>::Pointer ctx )
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	int rc;
	ControlVideoCommand *pCmd = new ControlVideoCommand();
	pCmd->pSIPPhoneSession = this;
	pCmd->start = FALSE;
	m_pEntity->GetFunction()->KillTimer(1);
	if (NULL != m_pEntity->GetEndpoint()){
		endpoint_invoke(m_pEntity->GetEndpoint(), &__control_video, pCmd, &rc);
	}

	m_pEntity->m_stVideoParam.bShowActiveImg = 0;  
	m_pEntity->m_stVideoParam.bActiveInspect = 0;
	//初始化窗口参数
	m_pEntity->m_stVideoParam.nWindowState = 0;
}

void CSIPPhoneSession::Handle_StartVideoRender(SpOnewayCallContext<PhoneService_StartVideoRender_Info>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	int rc;
	VideoRenderCommand_t* pCmd = new VideoRenderCommand_t();
	pCmd->pSIPPhoneSession = this;
	pCmd->bstart = true;

	pCmd->local_hwd_move = 0;
	pCmd->remote_hwd_move = 0;

	pCmd->local_view_x = ctx->Info.local_view_x;
	pCmd->local_view_y = ctx->Info.local_view_y;
	pCmd->local_view_cx = ctx->Info.local_view_cx;
	pCmd->local_view_cy = ctx->Info.local_view_cy;
	pCmd->remote_view_x = ctx->Info.remote_view_x;
	pCmd->remote_view_y = ctx->Info.remote_view_y;
	pCmd->remote_view_cx = ctx->Info.remote_view_cx;
	pCmd->remote_view_cy = ctx->Info.remote_view_cy;
	pCmd->local_hwd_move = ctx->Info.local_hwd_move;
	pCmd->remote_hwd_move = ctx->Info.remote_hwd_move;
	pCmd->local_fresh_time = m_pEntity->m_ilocalvideo_freshtime;
	pCmd->remote_fresh_time = m_pEntity->m_iremotevideo_freshtime;

	endpoint_invoke(m_pEntity->GetEndpoint(), &__video_render, pCmd, &rc);
}

void CSIPPhoneSession::Handle_StopVideoRender(SpOnewayCallContext<PhoneService_StopVideoRender_Info>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	VideoRenderCommand_t* pCmd = new VideoRenderCommand_t();
	int rc;
	pCmd->pSIPPhoneSession = this;
	pCmd->bstart = false;
	m_pEntity->GetFunction()->KillTimer(1);
	if (NULL != m_pEntity->GetEndpoint()) {
		endpoint_invoke(m_pEntity->GetEndpoint(), &__video_render, pCmd, &rc);
	}
}

void CSIPPhoneSession::Handle_GetHandfreeInVolume(SpReqAnsContext<PhoneService_GetHandfreeInVolume_Req, PhoneService_GetHandfreeInVolume_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	ctx->Ans.Volume = m_pEntity->m_kept_volume_in[DEV_HANDFREE];
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get hand free in volume is %d.", ctx->Ans.Volume);
	ctx->Answer(Error_Succeed);
}

void CSIPPhoneSession::Handle_SetHandfreeInVolume(SpReqAnsContext<PhoneService_SetHandfreeInVolume_Req, PhoneService_SetHandfreeInVolume_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	int iVolume = ctx->Req.Volume;
	if (iVolume > 100) {
		iVolume = 100;
	}
	if (iVolume < 0) {
		iVolume = 0;
	}

	m_pEntity->SetHandfreeInVolume(iVolume);
	ctx->Answer(Error_Succeed);
}

void CSIPPhoneSession::Handle_SetPickupInVolume(SpReqAnsContext<PhoneService_SetPickupInVolume_Req, PhoneService_SetPickupInVolume_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	if (eStand2sType == m_pEntity->m_eDeviceType || eStand1SPlusType == m_pEntity->m_eDeviceType) {
		int iVolume = ctx->Req.Volume;
		if (iVolume > 100) {
			iVolume = 100;
		}
		if (iVolume < 0) {
			iVolume = 0;
		}
		m_pEntity->SetPickupInVolume(iVolume);
	}
	ctx->Answer(Error_Succeed);
}

void CSIPPhoneSession::Handle_GetPickupInVolume(SpReqAnsContext<PhoneService_GetPickupInVolume_Req, PhoneService_GetPickupInVolume_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	if (eStand2sType == m_pEntity->m_eDeviceType || eStand1SPlusType == m_pEntity->m_eDeviceType) {
		ctx->Ans.Volume = m_pEntity->m_kept_volume_in[DEV_PICKUP];
	}
	else {
		ctx->Ans.Volume = 0;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get pick up in volume is %d.", ctx->Ans.Volume);
	ctx->Answer(Error_Succeed);
}

void CSIPPhoneSession::Handle_GetAudioDevices(SpReqAnsContext<PhoneService_GetAudioDevices_Req, PhoneService_GetAudioDevices_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();

	ctx->Ans.strHandfreeIn = m_pEntity->conf.audio_handfree_in_dev;
	ctx->Ans.strHandfreeOut = m_pEntity->conf.audio_handfree_out_dev;
	ctx->Ans.strPickupIn = m_pEntity->conf.audio_pickup_in_dev;
	ctx->Ans.strPickupOut = m_pEntity->conf.audio_pickup_out_dev;
	ctx->Ans.retCode = Error_Succeed;

	ctx->Answer(Error_Succeed);
}

void CSIPPhoneSession::Handle_BeginState( SpSubscribeContext<PhoneService_BeginState_Sub, PhoneService_PhoneState_Info>::Pointer ctx )
{
	m_spCallbackContext = ctx;
}

void CSIPPhoneSession::Handle_EndState( SpOnewayCallContext<PhoneService_EndState_Info>::Pointer ctx )
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	SpSubscribeContext<PhoneService_BeginState_Sub, PhoneService_PhoneState_Info>::Pointer tmp_ctx = m_spCallbackContext;
	m_spCallbackContext.Clear();
}


void CSIPPhoneSession::Handle_GetHandfreeOutVolume(SpReqAnsContext<PhoneService_GetHandfreeOutVolume_Req, PhoneService_GetHandfreeOutVolume_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	ctx->Ans.Volume = m_pEntity->m_kept_volume_out[DEV_HANDFREE];
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get hand free out volume is %d.", ctx->Ans.Volume);
	ctx->Answer(Error_Succeed);
}


void CSIPPhoneSession::Handle_SetHandfreeOutVolume(SpReqAnsContext<PhoneService_SetHandfreeOutVolume_Req, PhoneService_SetHandfreeOutVolume_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	int iVolume = ctx->Req.Volume;
	if (iVolume > 100){
		iVolume = 100;
	}
	if (iVolume < 0){
		iVolume = 0;
	}

	m_pEntity->SetHandfreeOutVolume(iVolume);
	ctx->Answer(Error_Succeed);
}


void CSIPPhoneSession::Handle_GetPickupOutVolume(SpReqAnsContext<PhoneService_GetPickupOutVolume_Req, PhoneService_GetPickupOutVolume_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	if (eStand2sType == m_pEntity->m_eDeviceType || eStand1SPlusType == m_pEntity->m_eDeviceType){
		ctx->Ans.Volume = m_pEntity->m_kept_volume_out[DEV_PICKUP];
	} 
	else{
		ctx->Ans.Volume = 0;
	}
	
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get pickup out volume is %d.", ctx->Ans.Volume);
	ctx->Answer(Error_Succeed);
}


void CSIPPhoneSession::Handle_SetPickupOutVolume(SpReqAnsContext<PhoneService_SetPickupOutVolume_Req, PhoneService_SetPickupOutVolume_Ans>::Pointer ctx)
{
	DbgToBeidou(ctx->link, __FUNCTION__)();
	if (eStand2sType == m_pEntity->m_eDeviceType || eStand1SPlusType == m_pEntity->m_eDeviceType){
		int iVolume = ctx->Req.Volume;
		if (iVolume > 100) {
			iVolume = 100;
		}
		if (iVolume < 0) {
			iVolume = 0;
		}
		m_pEntity->SetPickupOutVolume(iVolume);
	}
	ctx->Answer(Error_Succeed);
}

void CSIPPhoneSession::hangup_call(HangupCallCommand* cmd)
{
	if (m_pCall) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("normal hangup.");
		endpoint_call_hangup(m_pCall);
	}
}


void CSIPPhoneSession::release_call()
{
	if (m_pCall){
		terminatedcall(m_pCall);
	}

}


void CSIPPhoneSession::on_call_state(int state, const char *state_desc, const char *phrase)
{
	if (m_spCallbackContext != NULL) 
	{
		PhoneService_PhoneState_Info Info;
		Info.state = state;
		Info.status = CSimpleStringA::Format("%s,%s", state_desc, phrase);
		m_spCallbackContext->SendMessage(Info);
	}

	if (state == TERMINATED) 
	{
		if (NULL != m_pCall){
			endpoint_call_destroy(m_pCall);
			m_pCall = NULL;
		}

	}

	m_pEntity->SetState(state);
}

int CSIPPhoneSession::make_call( MakeCallCommand_t *pCmd)
{
	if (m_pCall) 
	{
		endpoint_call_destroy(m_pCall);
		m_pCall = NULL;
	}

	{
		endpoint_call_callback_t cb = {0};
		cb.on_call_state = &__on_call_state;
		cb.user_data = this;

		endpoint_call_params_t t_callparam = {0};
		t_callparam.to_uri = pCmd->toUri.GetData();
		t_callparam.call_id = (pCmd->callId.GetLength() > 0) ? pCmd->callId.GetData() : NULL;
		t_callparam.from_uri = (pCmd->fromUri.GetLength() > 0) ? pCmd->fromUri.GetData() : NULL;
		t_callparam.local_ip = (pCmd->strlocalip.GetLength() > 0) ? pCmd->strlocalip.GetData() : NULL;
		t_callparam.mapped_ip = (pCmd->strmappedip.GetLength() > 0) ? pCmd->strmappedip.GetData() : t_callparam.local_ip;
		t_callparam.ilocal_audio_port = pCmd->iaudio_port;
		t_callparam.ilocal_video_port = pCmd->ivideo_port;
		t_callparam.imapped_audio_port = pCmd->imapped_audio_port;
		t_callparam.imapped_video_port = pCmd->imapped_video_port;
		t_callparam.nDeviceType = m_pEntity->m_eDeviceType;
		t_callparam.nCallType = m_pEntity->m_nCallType;

		m_pCall = endpoint_call_create(m_pEntity->GetEndpoint(), &t_callparam, &cb);
		if (m_pCall) 
		{
			g_IsExternalTerminalted = FALSE;
			if (endpoint_call_start(m_pCall) == 0) 
			{
				return Error_Succeed;
			} 
			else 
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start call failed! and endpoint destroy call.");
				endpoint_call_destroy(m_pCall);
				m_pCall = NULL;
				return Error_Unexpect;
			}
		} 
		else 
		{
			g_IsExternalTerminalted = TRUE;
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("g_IsExternalTerminalted = TRUE");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create call endpoint failed!");
			m_pEntity->m_SipErrorCode = Error_InvalidState;
			m_pEntity->RealSelfCheck();			
			return Error_Unexpect;
		}
	}
}

void CSIPPhoneSession::control_video( ControlVideoCommand *pCmd )
{
	if (m_pCall) 
	{
		if (pCmd->start) 
		{
			endpoint_call_param_t callparam = { 0 };
			callparam.remote_ip = pCmd->remote_ip;
			callparam.remote_port = pCmd->remote_port;
			callparam.local_ip = pCmd->local_ip;
			callparam.local_port = pCmd->local_port;
			callparam.remote_width = pCmd->remote_width;
			callparam.remote_height = pCmd->remote_height;

			rvc_video_render_callback_t t_callback = { 0 };
			t_callback.user_data = m_pEntity;
			t_callback.on_remote_video_render = &__remote_video_render_callback;
			t_callback.on_stop_remote_video_render = &__on_stop_remote_video_render_callback;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s:%d video_render_cb = 0x%08x and video_render_cb->on_video_render = 0x%08x, video_render_cb->user_data = 0x%08x.", __FUNCTION__, __LINE__, &t_callback, t_callback.on_remote_video_render, t_callback.user_data);
			endpoint_call_start_video(m_pCall, &callparam, &t_callback);
			if (DOUBLERECORD_CALLTYPE != m_pEntity->m_nCallType) {
				rvc_video_render_params_t render_param = { 0 };
				render_param.ilocal_view_x = pCmd->local_view_x;
				render_param.ilocal_view_y = pCmd->local_view_y;
				render_param.ilocal_view_cx = pCmd->local_view_cx;
				render_param.ilocal_view_cy = pCmd->local_view_cy;
				render_param.iremote_view_x = pCmd->remote_view_x;
				render_param.iremote_view_y = pCmd->remote_view_y;
				render_param.iremote_view_cx = pCmd->remote_view_cx;
				render_param.iremote_view_cy = pCmd->remote_view_cy;
				render_param.ilocal_move = pCmd->local_hwd_move;
				render_param.iremote_move = pCmd->remote_hwd_move;
				render_param.ilocal_fresh_time = pCmd->local_fresh_time;
				render_param.iremote_fresh_time = pCmd->remote_fresh_time;
				start_video_render(&render_param, false);
			}
		} 
		else {
			endpoint_call_stop_video(m_pCall);
			if (NULL != m_pEntity->m_render) {
				stop_video_render();
			}
		}
	}
	else
	{
		if (pCmd->start)
		{
			endpoint_call_callback_t cb = {0};
			cb.on_call_state = &__on_call_state;
			cb.user_data = this;
			endpoint_call_params_t t_callparam = {0};
			t_callparam.to_uri = "test";
			t_callparam.call_id =  NULL;
			t_callparam.from_uri =  NULL;
			t_callparam.local_ip = m_pEntity->m_localip;
			t_callparam.nDeviceType = m_pEntity->m_eDeviceType;
			t_callparam.nCallType = m_pEntity->m_nCallType;
			m_pCall = endpoint_call_create(m_pEntity->GetEndpoint(), &t_callparam, &cb);
		}
		else {
			if (NULL != m_pEntity->m_render) {
				stop_video_render();
			}
		}
	}
}

void CSIPPhoneSession::video_render(VideoRenderCommand_t* pCmd)
{
	if (true== pCmd->bstart) {
		rvc_video_render_params_t render_param = { 0 };
		render_param.ilocal_view_x = pCmd->local_view_x;
		render_param.ilocal_view_y = pCmd->local_view_y;
		render_param.ilocal_view_cx = pCmd->local_view_cx;
		render_param.ilocal_view_cy = pCmd->local_view_cy;
		render_param.iremote_view_x = pCmd->remote_view_x;
		render_param.iremote_view_y = pCmd->remote_view_y;
		render_param.iremote_view_cx = pCmd->remote_view_cx;
		render_param.iremote_view_cy = pCmd->remote_view_cy;
		render_param.ilocal_move = pCmd->local_hwd_move;
		render_param.iremote_move = pCmd->remote_hwd_move;
		render_param.ilocal_fresh_time = pCmd->local_fresh_time;
		render_param.iremote_fresh_time = pCmd->remote_fresh_time;

		start_video_render(&render_param, true);
	}
	else {
		stop_video_render();
	}
}


int CSIPPhoneSession::start_video_render(rvc_video_render_params_t* render_param, bool bremote)
{
	m_pEntity->m_render = new rvc_video_render_t();
	videorender_callback_t t_callback = { 0 };
	t_callback.debug = &__video_render_log;

	m_pEntity->m_render->plocal_render = CreateVideoRenderObj(&t_callback);
	LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_LOCAL_VIDEO_RENDER_CREATE, "local video render create.");

	m_pEntity->m_render->premote_render = CreateVideoRenderObj(&t_callback);
	LogWarn(Severity_Low, Error_Debug, EVENT_MOD_SIP_REMOTE_VIDEO_RENDER_CREATE, "remote video render create.");

	memcpy(&m_pEntity->m_render->location_param, render_param, sizeof(rvc_video_render_params_t));
	m_pEntity->m_render->ui_threadid = 0;
	m_pEntity->m_render->remote_render_threadid = 0;

	rvc_video_box_move_callback_t t_render_callback = { 0 };
	t_render_callback.on_video_box_move = &__on_video_box_move;
	t_render_callback.user_data = this;

	rvc_video_render_window_type_callback_t t_window_type_callback = { 0 };
	t_window_type_callback.on_window_type = &__on_window_type_callback;
	t_window_type_callback.user_data = this->m_pEntity;
	memcpy(&m_pEntity->m_render->cb, &t_window_type_callback, sizeof(rvc_video_render_window_type_callback_t));
	m_pEntity->m_stVideoParam.bShowPersonArea = 0;

	if (Error_Succeed == rvc_start_video_render(m_pEntity->m_render, bremote, &t_render_callback)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start video render success.");
	}

	return 0;
}

int CSIPPhoneSession::stop_video_render()
{
	if (Error_Succeed == rvc_stop_video_render(m_pEntity->m_render)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop video render success.");
	}
	DestroyVideoRenderObj(m_pEntity->m_render->plocal_render);
	DestroyVideoRenderObj(m_pEntity->m_render->premote_render);
	delete(m_pEntity->m_render);
	m_pEntity->m_render = NULL;

	return 0;
}

int CSIPPhoneSession::on_video_box_move(int imessageType, int ivideotype, int ileft, int ibottom)
{
	int iret = -1;

	if (0 == imessageType){
		VideoBoxStartMove evt;
		evt.videoboxflag = ivideotype;
		evt.leftlowerx = ileft;
		evt.leftlowery = ibottom;
		iret = SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(VideoBoxStartMove), SP_MSG_SIG_OF(VideoBoxStartMove), evt);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("VideoBoxStartMove broadcast sent, video type is %d, left is %d, bottom is %d.", ivideotype, ileft, ibottom);
	}
	else{
		VideoBoxStopMove evt;
		evt.videoboxflag = ivideotype;
		evt.leftlowerx = ileft;
		evt.leftlowery = ibottom;
		iret = SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(VideoBoxStopMove), SP_MSG_SIG_OF(VideoBoxStopMove), evt);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("VideoBoxStopMove broadcast sent, video type is %d, left is %d, bottom is %d.", ivideotype, ileft, ibottom);
	}

	return iret;
}


ChannelSipphoneClient::ChannelSipphoneClient( CSIPEntity *pEntity ) : ChannelService_ClientBase(pEntity)
{

}

void ChannelSipphoneClient::OnMessage(ErrorCodeEnum Error, ChannelService_State_Info &Msg, CSmartPointer<IReleasable> pData)
{
	if (Error == Error_Succeed) 
	{
		CSIPEntity *pEntity = static_cast<CSIPEntity*>(m_pEntityBase);
		if (Msg.state == eChannelState_Connected) 
		{
#ifdef RVC_OS_WIN
			if (pEntity->m_pKeeperIn[DEV_HANDFREE])
#else
			if (pEntity->m_pAudioMgr)
#endif
			{
				pEntity->SendAudioDeviceVolumn(DEVICE_HANDFREE_IN);
			}

#ifdef RVC_OS_WIN
			if (pEntity->m_pKeeperOut[DEV_HANDFREE])
#else
			if (pEntity->m_pAudioMgr)
#endif
			{
				pEntity->SendAudioDeviceVolumn(DEVICE_HANDFREE_OUT);
			}

#ifdef RVC_OS_WIN
			if (pEntity->m_pKeeperOut[DEV_PICKUP])
#else
			if (pEntity->m_pAudioMgr)
#endif
			{
				pEntity->SendAudioDeviceVolumn(DEVICE_PICKUP_OUT);
			}

#ifdef RVC_OS_WIN
			if (pEntity->m_pKeeperIn[DEV_PICKUP])
#else
			if (pEntity->m_pAudioMgr)
#endif
			{
				pEntity->SendAudioDeviceVolumn(DEVICE_PICKUP_IN);
			}
		}
	}
}

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


SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CSIPEntity)
SP_END_ENTITY_MAP()