#include "StdAfx.h"
#include "MC.h"
#include "Config.h"
#include "ControlShell.h"
#include "PBX.h"
#include "SpanChannel.h"
#include "DspChannel.h"
#include "SessionShell.h"
#include "VoipChannel.h"
#include "IpmChannel.h"
#include "FaxChannel.h"
#include "ProxyShell.h"


SINGLETON_IMPLEMENT(CMC)


CMC::CMC(void) : m_pThreadObj(NULL), m_Stop(true), m_state(0)
{
}


CMC::~CMC(void)
{
	__freePbx();
}

/*****************************************************************
**【函数名称】	__translateResType
**【函数功能】	查找指定PBX
**【参数】		
**【返回值】	
****************************************************************/
LPCTSTR CMC::__translateResType( DEV_RES_TYPE ResType ) const
{
	switch(ResType)
	{
	case DEV_RES_TYPE_EXT: return _T("分机资源");
	case DEV_RES_TYPE_TRUNK: return _T("数字中继资源");
	case DEV_RES_TYPE_CONFERENCE: return _T("会议资源");
	case DEV_RES_TYPE_FAX: return _T("传真资源");
	case DEV_RES_TYPE_VOIP: return _T("VOIP资源");
	case DEV_RES_TYPE_DSP: return _T("DSP资源");
	case DEV_RES_TYPE_IPM: return _T("IPM资源");
	case DEV_RES_TYPE_MB: return _T("母板资源");
	default: return _T("未知资源");
	}
}

/*****************************************************************
**【函数名称】	__getPbx
**【函数功能】	查找指定PBX
**【参数】		
**【返回值】	
****************************************************************/
CPBX* CMC::__getPbx( int IsxNo )
{
	CPBX* pPbx = NULL;
	for(int i = 0; i < m_PbxList.GetCount(); ++i)
	{
		pPbx = m_PbxList[i];
		ASSERT(pPbx != NULL);
		if(pPbx->pbxNo() == IsxNo)
			return pPbx;
	}

	return NULL;
}

/*****************************************************************
**【函数名称】	__newPbx
**【函数功能】	创建新PBX
**【参数】		
**【返回值】	
****************************************************************/
CPBX* CMC::__newPbx( int IsxNo )
{
	CPBX* pPbx = __getPbx(IsxNo);
	if(pPbx == NULL)
	{
		pPbx = new CPBX(this, IsxNo);
		ASSERT(pPbx != NULL);
		m_PbxList.Add(pPbx);
	}

	return pPbx;
}

/*****************************************************************
**【函数名称】	__freePbx
**【函数功能】	释放PBX
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__freePbx( void )
{
	for(int i = 0; i < m_PbxList.GetCount(); ++i)
	{
		delete m_PbxList[i];
	}
	m_PbxList.RemoveAll();
}

/*****************************************************************
**【函数名称】	__regExten2Dev
**【函数功能】	向设备注册分机信息
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__regExten2Dev( void )
{
	CString ExtenId;
	CConfig::ExtenMap& ExtMap = CConfig::extenMap();
	const CConfig::ExtenMap::CPair* pPair = ExtMap.PGetFirstAssoc();
	while(pPair != NULL)
	{
		ExtenId.Format(_T("%u"), pPair->key);
		ISXE_gc_SipSetRegisterUser(ExtenId, ExtenId, pPair->value);
		pPair = ExtMap.PGetNextAssoc(pPair);
	}
}

/*****************************************************************
**【函数名称】	__onSipUserNew
**【函数功能】	SIP终端注册处理
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__onSipUserNew( void )
{
	ISXSIP_REGUSER* pUserInfo = (ISXSIP_REGUSER*)ISX_sr_getevtdatap();
	ASSERT(pUserInfo != NULL);

	UINT UserId = atoi(pUserInfo->UserId);
	DEV_RES_ID ResId;
	ResId.ResType = DEV_RES_TYPE_EXT;
	ResId.ChanNo = UserId;
	CSessionShell::GetInstance().onDevResourceNew(ResId);
//#ifdef _DEBUG
	LOGGER(LOG_CLASS_DEV, LOG_LEVEL_NORMAL, _T("{MC}: SIP用户[%d-%s]注册"), UserId, pUserInfo->IpAddr);
//#endif
}

/*****************************************************************
**【函数名称】	__onSipUserDel
**【函数功能】	SIP终端注销处理
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__onSipUserDel( void )
{
	ISXSIP_REGUSER* pUserInfo = (ISXSIP_REGUSER*)ISX_sr_getevtdatap();
	ASSERT(pUserInfo != NULL);

	UINT UserId = atoi(pUserInfo->UserId);
	DEV_RES_ID ResId;
	ResId.ResType = DEV_RES_TYPE_EXT;
	ResId.ChanNo = UserId;
	CSessionShell::GetInstance().onDevResourceDel(ResId);
//#ifdef _DEBUG
	LOGGER(LOG_CLASS_DEV, LOG_LEVEL_NORMAL, _T("{MC}: SIP用户[%d-%s]注销"), UserId, pUserInfo->IpAddr);
//#endif
}

/*****************************************************************
**【函数名称】	__procResourceStateUpdate
**【函数功能】	设备资源状态更新处理函数
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__procResourceStateUpdate( INT EvtType, SYS_EVT_DATA* pEvtData )
{
	ASSERT(pEvtData != NULL);

	LOG_LEVEL Level;

	CHAR State = pEvtData->u.cStatus;
	if(State == STATUS_WORKING)
		Level = LOG_LEVEL_NORMAL;
	else 
		Level = LOG_LEVEL_WARNING;

	switch(EvtType)
	{
	case SYSEV_MC_STATUS:
		{
			LOGGER(LOG_CLASS_DEV, Level, _T("{MC}: MC状态更新, state = %s"), transState(pEvtData->u.cStatus));
			if(m_state == STATUS_WORKING && State != STATUS_WORKING)
				CControlShell::GetInstance().onDevInvalid(DEVICE_MC_NO, DEVICE_MC_NO);

			m_state = State;
		}
		break;

	case SYSEV_DSP_STATUS:
	{
		if (m_DspIsxNo == -1) {
			m_DspIsxNo = pEvtData->cIsxNo;
			LOGGER(LOG_CLASS_DEV, Level, _T("{MC}: DSP状态更新,设置DSP节点[%d], state = %s"), m_DspIsxNo, transState(pEvtData->u.cStatus));
		}
		else if (m_DspIsxNo != pEvtData->cIsxNo)
		{
			LOGGER(LOG_CLASS_DEV, Level, _T("{MC}: DSP状态更新,mDspIsxNo[%d],DSP节点[%d], state = %s"), m_DspIsxNo, pEvtData->cIsxNo, transState(pEvtData->u.cStatus));
		}
	}
	case SYSEV_MB_STATUS:
	case SYSEV_PRI_STATUS:
	case SYSEV_SS7_STATUS:
	case SYSEV_SIP_STATUS:
	case SYSEV_XOIP_STATUS:
	case SYSEV_SPAN_STATUS:
		{
			CPBX* pPbx = __getPbx(pEvtData->cIsxNo);
			if(pPbx == NULL && State == STATUS_WORKING)
				pPbx = __newPbx(pEvtData->cIsxNo);

			if(pPbx != NULL)
				pPbx->onResourceStateUpdated(EvtType, pEvtData);
		}
		break;

	case SYSEV_PRD_STATUS:
		{
			LOGGER(LOG_CLASS_DEV, Level, _T("{MC}: PRD[%d]状态更新, state = %s"), pEvtData->cIsxNo, transState(pEvtData->u.cStatus));
			if(State == STATUS_WORKING)
			{
				if(!m_PrdDev.isOpened())
					m_PrdDev.open(pEvtData->cIsxNo);
			}
			else
			{
				if(m_PrdDev.isOpened() && m_PrdDev.devNo() == pEvtData->cIsxNo)
					m_PrdDev.close();
			}
		}
		break;

	case SYSEV_FXS_STATUS:
		{
			LOGGER(LOG_CLASS_DEV, Level, _T("{MC}: Fax设备状态更新, state = %s"), transState(pEvtData->u.cStatus));
			if(pEvtData->u.cStatus == STATUS_WORKING)
			{
				if(!m_FaxDev.isOpened())
					m_FaxDev.createFaxChannel();
			}
			else
			{
				if(m_FaxDev.isOpened())
					m_FaxDev.close();
			}
		}
		break;
	}
}

/*****************************************************************
**【函数名称】	__procResourceAlarm
**【函数功能】	设备资源状态告警处理函数
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__procResourceAlarm( INT EvtType, SYS_EVT_DATA* pEvtData )
{
	CPBX* pPbx = __getPbx(pEvtData->cIsxNo);
	if(pPbx != NULL)
		pPbx->onResourceAlarm(EvtType, pEvtData);
}

/*****************************************************************
**【函数名称】	__procResourceCapacity
**【函数功能】	设备资源容量处理函数
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__procResourceCapacity( INT EvtType, SYS_EVT_DATA* pEvtData )
{
	CPBX* pPbx = __getPbx(pEvtData->cIsxNo);
	if(pPbx != NULL)
		pPbx->onResourceCapacity(EvtType, pEvtData);
}

/*****************************************************************
**【函数名称】	__procVoiceEvent
**【函数功能】	处理语音相关事件
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__procVoiceEvent( METAEVENT* pMetaEvent )
{
	CDspChannel* pChannel = NULL;

	if(ISX_dx_GetUsrAttr(pMetaEvent->evtdev, (void**)&pChannel) != 0)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(pChannel != NULL);
	if(pChannel != NULL)
		pChannel->onDevEvent(pMetaEvent);
}

/*****************************************************************
**【函数名称】	__procIpmEvent
**【函数功能】	处理IPM通道相关事件
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__procIpmEvent( METAEVENT* pMetaEvent )
{
	CIpmChannel* pChannel = NULL;

	if(ISX_ipm_GetUsrAttr(pMetaEvent->evtdev, (void**)&pChannel) != 0)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(pChannel != NULL);
	if(pChannel != NULL)
		pChannel->onDevEvent(pMetaEvent);
}

/*****************************************************************
**【函数名称】	__procFaxEvent
**【函数功能】	处理fax通道相关事件
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__procFaxEvent( METAEVENT* pMetaEvent )
{
	CFaxChannel* pChannel = NULL;

	if(ISX_fxs_GetUsrAttr(pMetaEvent->evtdev, (void**)&pChannel) != 0)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(pChannel != NULL);
	if(pChannel != NULL)
		pChannel->onDevEvent(pMetaEvent);
}

/*****************************************************************
**【函数名称】	__procSipRegEvent
**【函数功能】	处理SIP注册发送事件
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__procSipRegSent( void )
{
	SEND_SIPREG_RET* pSent = (SEND_SIPREG_RET*)ISX_sr_getevtdatap();
	ASSERT(pSent != NULL);

	CPBX* pPbx = __getPbx(pSent->RegisterId.ucIsxNo);
	ASSERT(pPbx != NULL);
	if(pPbx != NULL)
		pPbx->onSipRegSent(pSent);
}

/*****************************************************************
**【函数名称】	__procSipRegAck
**【函数功能】	处理SIP注册确认事件
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__procSipRegAck( void )
{
	SIP_REGISTER_ACK* pAck = (SIP_REGISTER_ACK*)ISX_sr_getevtdatap();
	ASSERT(pAck != NULL);

	CPBX* pPbx = __getPbx(pAck->RegisterId.ucIsxNo);
	ASSERT(pPbx != NULL);
	if(pPbx != NULL)
		pPbx->onSipRegAck(pAck);
}

/*****************************************************************
**【函数名称】	__procSipTransaction
**【函数功能】	收到SIP事务事件的处理函数
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__procSipTransaction( void )
{
	SIP_TRANSACTION_IND* pTransaction = (SIP_TRANSACTION_IND*)ISX_sr_getevtdatap();
	ASSERT(pTransaction != NULL);

	CPBX* pPbx = __getPbx(pTransaction->ucIsxNo);
	ASSERT(pPbx != NULL);
	if(pPbx != NULL)
		pPbx->onSipTransaction(pTransaction);
}

/*****************************************************************
**【函数名称】	__onGcEvent
**【函数功能】	GC事件处理函数
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__onGcEvent(METAEVENT* pMetaEvent)
{
	CHAR SignallingType;

	ISX_gc_SignallingType(pMetaEvent->evtdev, &SignallingType);
	if(SignallingType == eGCPro_SIP)
	{
		CVoipChannel* pChannel = NULL;

		if(ISX_gc_GetUsrAttr(pMetaEvent->evtdev, (void**)&pChannel) != GC_SUCCESS)
		{
			ASSERT(FALSE);
			return;
		}

		ASSERT(pChannel != NULL);
		if(pChannel != NULL)
			pChannel->onDevEvent(pMetaEvent);
	}
	else
	{
		CSpanChannel* pChannel = NULL;

		if(ISX_gc_GetUsrAttr(pMetaEvent->evtdev, (void**)&pChannel) != GC_SUCCESS)
		{
			ASSERT(FALSE);
			return;
		}

		ASSERT(pChannel != NULL);
		if(pChannel != NULL)
			pChannel->onDevEvent(pMetaEvent);
	}	
}

/*****************************************************************
**【函数名称】	__onSysEvent
**【函数功能】	系统事件处理函数
**【参数】		
**【返回值】	
****************************************************************/
void CMC::__onSysEvent(METAEVENT* pMetaEvent)
{
	switch(pMetaEvent->evttype)
	{
	case TDX_ERROR:		
	case TDX_PLAY:		
	case TDX_PLAYBEGIN:
	case TDX_RECORD:
	case TDX_RECBEGIN:
	case TDX_GETDIG:
		__procVoiceEvent(pMetaEvent);
		break;

	case SYSEV_SIP_REGUSER_NEW:
		__onSipUserNew();
		break;

	case SYSEV_SIP_REGUSER_DEL:
		__onSipUserDel();
		break;

	case IPMEV_ANSWER:
	case IPMEV_SET_PARM:
	case IPMEV_FAX:
		__procIpmEvent(pMetaEvent);
		break;

	case TFX_FAXERROR:
	case TFX_STARTOP_ERR:
	case TFX_FAXRECV:
	case TFX_FAXSEND:
		__procFaxEvent(pMetaEvent);
		break;

	case SYSEV_MC_STATUS:
	case SYSEV_MB_STATUS:
	case SYSEV_DSP_STATUS:
	case SYSEV_PRD_STATUS:
	case SYSEV_PRI_STATUS:		
	case SYSEV_SS7_STATUS:
	case SYSEV_SIP_STATUS:
	case SYSEV_XOIP_STATUS:
	case SYSEV_SPAN_STATUS:
	case SYSEV_FXS_STATUS:
		__procResourceStateUpdate(pMetaEvent->evttype, (SYS_EVT_DATA*)pMetaEvent->evtdatap);
		break;

	case SYSEV_SPAN_ALARM:
	case SYSEV_PRIDCH_ALARM:
	case SYSEV_S7LINK_ALARM:
		__procResourceAlarm(pMetaEvent->evttype, (SYS_EVT_DATA*)pMetaEvent->evtdatap);
		break;

	case SYSEV_DSP_BRD_CAP:
	case SYSEV_SIP_BRD_CAP:
	case SYSEV_XOIP_BRD_CAP:
		__procResourceCapacity(pMetaEvent->evttype, (SYS_EVT_DATA*)pMetaEvent->evtdatap);
		break;

	case SYSEV_SIP_REGISTERSENT:
		__procSipRegSent();
		break;

	case SYSEV_SIP_RECVREGISTERACK:
		__procSipRegAck();
		break;

	case SYSEV_SIP_RECVTRANSACTION:
		__procSipTransaction();
		break;

	default:
		break;
	}
}

/*****************************************************************
**【函数名称】	__pbxEvtThread
**【函数功能】	设备事件处理线程
**【参数】		
**【返回值】	
****************************************************************/
UINT CMC::__pbxEvtThread( LPVOID pParam )
{
	CMC* pSelf = (CMC*)pParam;
	ASSERT(pSelf != NULL);

	int Res;
	METAEVENT metaevt;

	while (!pSelf->m_Stop)
	{
		Res = ISX_sr_waitevt(DEVICE_WAIT_TIME);
		if(Res != 0)
			continue;

		ISX_gc_GetMetaEvent(&metaevt);
		if(metaevt.flags & GCME_GC_EVENT)		// global call event
			pSelf->__onGcEvent(&metaevt);
		else
			pSelf->__onSysEvent(&metaevt);
	}

	return 0;
}

/*****************************************************************
**【函数名称】	open
**【函数功能】	设备打开
**【参数】		
**【返回值】	成功true，失败false
****************************************************************/
bool CMC::open( void )
{
	//m_ConfigLocal.load();

	LOGGER(LOG_CLASS_DEV, LOG_LEVEL_NORMAL, _T("{MC}: 开始初始化PBX设备"));

	m_DspIsxNo = -1;

	INT AutoDeleteDay = 2;
	ISX_sr_SetSysParam(SYS_PARMID_DAYNUM_FOR_AUTO_DELETE_LOG, &AutoDeleteDay);

	ISX_sr_Log2File(DEVICE_LOG_PATH);

	ISXE_gc_SipSetRegisterMode(SIP_REGMODE_INNER_AUTH);

	if(ISX_Api_Init(CConfig::mcAddr(), CConfig::mcPort(), DEVICE_KEEP_ALIVE) != 0)
	{
		LOGGER(LOG_CLASS_DEV, LOG_LEVEL_ERROR, _T("{MC}: 设备初始化失败"));
		return false;
	}

	__regExten2Dev();

	/*if(!m_FaxDev.open())
	{
	ISX_Api_Uninit();
	LOGGER(LOG_CLASS_DEV, LOG_LEVEL_ERROR, _T("{MC}: 设备初始化失败"));
	return false;
	}*/

	m_Stop = false;
	m_pThreadObj = AfxBeginThread(__pbxEvtThread, this);

	return true;
}

/*****************************************************************
**【函数名称】	close
**【函数功能】	设备关闭
**【参数】		
**【返回值】
****************************************************************/
void CMC::close( void )
{
	m_Stop = true;

	ISX_Api_Uninit();

	/*if(m_pThreadObj != NULL)
	{
	DWORD ExitCode;
	GetExitCodeThread(m_pThreadObj->m_hThread, &ExitCode);
	if(ExitCode == STILL_ACTIVE)
	WaitForSingleObject(m_pThreadObj->m_hThread, INFINITE);

	m_pThreadObj = NULL;
	}*/
}

/*****************************************************************
**【函数名称】	transState
**【函数功能】	翻译状态码
**【参数】		
**【返回值】	
****************************************************************/
LPCTSTR CMC::transState( INT Status )
{
	switch(Status)
	{
	case STATUS_RESET:		return "reset";
	case STATUS_OUT_OF_SRV:	return "out of service";
	case STATUS_REQ_STOP:	return "request stop";
	case STATUS_WORKING:	return "working";
	default: break;
	}
	return "unknown state";
}

/*****************************************************************
**【函数名称】	allocVoipCh
**【函数功能】	为分机分配空闲VOIP线路
**【参数】		
**【返回值】	
****************************************************************/
CVoipChannel* CMC::allocVoipCh4Exten( int IsxNo )
{
	CVoipChannel* pChan = NULL;
	for(int i = 0; i < m_PbxList.GetCount(); ++i)
	{
		CPBX* pPbx = m_PbxList[i];
		ASSERT(pPbx != NULL);
		if(IsxNo == DEVICE_NODE_NO_ANY || pPbx->pbxNo() == IsxNo)
		{
			pChan = pPbx->allocVoipCh4Exten();
			if(pChan != NULL)
				break;
		}
	}

	return pChan;
}

/*****************************************************************
**【函数名称】	allocIpmCh
**【函数功能】	通道分配IPM通道
**【参数】		
**【返回值】	
****************************************************************/
CIpmChannel* CMC::allocIpmCh4SipCh( int IsxNo, int BoardNo )
{
	CPBX* pPbx = __getPbx(IsxNo);
	ASSERT(pPbx != NULL);
	if(pPbx != NULL)
	{
		ULONG SipNetId = pPbx->getVoipNetId(BoardNo);

		CIpmChannel* pChan = NULL;
		for(int i = 0; i < m_PbxList.GetCount(); ++i)
		{
			pChan = m_PbxList[i]->allocIpmCh(SipNetId);
			if(pChan != NULL)
				break;
		}

		return pChan;
	}
	else
		return NULL;
}

/*****************************************************************
**【函数名称】	allocDspCh
**【函数功能】	分配DSP通道
**【参数】		
**【返回值】	
****************************************************************/
CDspChannel* CMC::allocDspCh( int IsxNo, int BoardNo )
{
	//CPBX* pPbx = __getPbx(IsxNo);
	//2018.4.9
	CPBX* pPbx = __getPbx(m_DspIsxNo);
	ASSERT(pPbx != NULL);
	if(pPbx != NULL)
		return pPbx->allocDspCh(BoardNo);
	else
		return NULL;
}

/*****************************************************************
**【函数名称】	allocFreeTrunk
**【函数功能】	分配空闲中继线路
**【参数】		
**【返回值】	
****************************************************************/
COneLeg* CMC::allocFreeTrunk( int IsxNo, int BoardNo, int SpanNo )
{
	CPBX* pPbx = __getPbx(IsxNo);
	ASSERT(pPbx != NULL);
	if(pPbx != NULL)
		return pPbx->allocFreeTrunk(BoardNo, SpanNo);
	else
		return NULL;
}

/*****************************************************************
**【函数名称】	getCallLeg
**【函数功能】	查找通话线路
**【参数】		
**【返回值】	
****************************************************************/
COneLeg* CMC::getCallLeg( CRDRID ResId )
{
	CPBX* pPbx = __getPbx(ResId.NodeNo);
	ASSERT(pPbx != NULL);
	if(pPbx != NULL)
		return pPbx->findLeg(ResId);
	else
		return NULL;
}

/*****************************************************************
**【函数名称】	isPbxOK
**【函数功能】	设备状态是否正常
**【参数】		
**【返回值】	
****************************************************************/
bool CMC::isPbxOK( int IsxNo )
{
	CPBX* pPbx = __getPbx(IsxNo);
	if(pPbx != NULL)
		return pPbx->isOk();
	else
		return false;
}

/*****************************************************************
**【函数名称】	onPbxResValid
**【函数功能】	设备资源处于可用状态的处理函数
**【参数】		
**【返回值】
****************************************************************/
void CMC::onPbxResValid( int IsxNo )
{
	CControlShell::GetInstance().onDevValid(IsxNo);
}

/*****************************************************************
**【函数名称】	onPbxResInvalid
**【函数功能】	设备资源处于不可用状态的处理函数
**【参数】		
**【返回值】
****************************************************************/
void CMC::onPbxResInvalid( int IsxNo, int BoardNo, DEV_RES_TYPE ResType )
{
	LOGGER(LOG_CLASS_DEV, LOG_LEVEL_ERROR, _T("{MC}: %s[%d-%d]状态不可用"), __translateResType(ResType), IsxNo, BoardNo);
	CControlShell::GetInstance().onDevInvalid(IsxNo, BoardNo);	
}

/*****************************************************************
**【函数名称】	onDevResCreate
**【函数功能】	设备资源创建的处理函数
**【参数】		
**【返回值】		
****************************************************************/
void CMC::onDevResCreate( CRDRID ResId )
{
	switch(ResId.ResType)
	{
	case DEV_RES_TYPE_TRUNK:
	case DEV_RES_TYPE_VOIP:
		CSessionShell::GetInstance().onDevResourceNew(ResId);
#ifdef _SC_UI_MODE
	case DEV_RES_TYPE_IPM:
	case DEV_RES_TYPE_DSP:
		{
			CMsgCenter::GetInstance().pushMsg(SYS_MSG_RES_NEW, &ResId);
		}
#endif
		break;
	}	
}

/*****************************************************************
**【函数名称】	onDevResDestroy
**【函数功能】	设备资源销毁的处理函数
**【参数】		
**【返回值】		
****************************************************************/
void CMC::onDevResDestroy( CRDRID ResId )
{
	switch(ResId.ResType)
	{
	case DEV_RES_TYPE_TRUNK:
	case DEV_RES_TYPE_VOIP:
		CSessionShell::GetInstance().onDevResourceDel(ResId);
#ifdef _SC_UI_MODE
	case DEV_RES_TYPE_IPM:
	case DEV_RES_TYPE_DSP:
		{
			CMsgCenter::GetInstance().pushMsg(SYS_MSG_RES_DEL, &ResId);
		}
#endif
		break;
	}	
}

/*****************************************************************
**【函数名称】	onDevResState
**【函数功能】	设备资源状态变化的处理函数
**【参数】		
**【返回值】		
****************************************************************/
void CMC::onDevResState( CRDRID ResId )
{
#ifdef _SC_UI_MODE
	switch(ResId.ResType)
	{
	case DEV_RES_TYPE_TRUNK:
	case DEV_RES_TYPE_VOIP:
	case DEV_RES_TYPE_IPM:
	case DEV_RES_TYPE_DSP:
		CMsgCenter::GetInstance().pushMsg(SYS_MSG_RES_STATE, &ResId);
		break;
	}
#endif
}

/*****************************************************************
**【函数名称】	bridgeDevice
**【函数功能】	设备双向连接/断开
**【参数】		SrcId			源端设备ID
DstId			目标设备ID
IsLink			是否连接
**【返回值】	
****************************************************************/
bool CMC::bridgeDevice( CRDRID SrcId, CRDRID DstId, bool IsLink )
{
	COneLeg* pLegA = getCallLeg(SrcId);
	if(pLegA == NULL)
		return false;

	COneLeg* pLegB = getCallLeg(DstId);
	if(pLegB == NULL)
		return false;

	return bridgeDevice(pLegA->routeChannel(), pLegB->routeChannel(), IsLink, false);
}

/*****************************************************************
**【函数名称】	bridgeDevice
**【函数功能】	设备双向连接/断开
**【参数】		
**【返回值】	
****************************************************************/
bool CMC::bridgeDevice( CChannelResource* pChanSrc, CChannelResource* pChanDst, bool IsLink, bool IsOneWay )
{
	if(pChanSrc == NULL || pChanDst == NULL)
		return false;

	UCHAR mode = IsOneWay ? SC_HALFDUP : SC_FULLDUP;

	if(IsLink)
		return ISX_nr_scroute(pChanSrc->handle(), pChanSrc->type(), pChanDst->handle(), pChanDst->type(), mode) == 0;
	else
		return ISX_nr_scunroute(pChanSrc->handle(), pChanSrc->type(), pChanDst->handle(), pChanDst->type(), mode) == 0;
}

/*****************************************************************
**【函数名称】	channelListen
**【函数功能】	监听指定线路
**【参数】		SrcId			源端设备ID
				PeerId			对端设备ID
				DstId			目标设备ID
				IsLink			是否连接
**【返回值】	
****************************************************************/
bool CMC::channelListen( CRDRID SrcId, CRDRID PeerId, CRDRID DstId, bool IsLink )
{
	// 查找监听主控线路
	COneLeg* pLegHost = getCallLeg(DstId);
	if(pLegHost == NULL) 
		return false;

	// 查找被监听线路
	COneLeg* pLegSrc = getCallLeg(SrcId);
	if(pLegHost == NULL) 
		return false;

	return pLegHost->monitor(pLegSrc, !IsLink);
}

/*****************************************************************
**【函数名称】	meetingListen
**【函数功能】	监听指定会议
**【参数】		
**【返回值】	
****************************************************************/
bool CMC::meetingListen( CRDRID DstId, MeetingInfo& MeetingId, bool IsLink )
{
	//CPBX* pPbx = __getPbx(MeetingId.NodeNo);
	//2018.4.9
	CPBX* pPbx = __getPbx(m_DspIsxNo);
	ASSERT(pPbx != NULL);

	// 查找监听主控线路
	COneLeg* pLegHost = getCallLeg(DstId);
	if(pLegHost == NULL) 
		return false;

	if(IsLink)
		return pPbx->meetingJoin(MeetingId.BoardNo, pLegHost, MeetingId, true);
	else
		return pPbx->meetingRemove(MeetingId.BoardNo, pLegHost, MeetingId);
}

/*****************************************************************
**【函数名称】	meetingMute
**【函数功能】	静音会议中线路
**【参数】		
**【返回值】	
****************************************************************/
bool CMC::meetingMute( CRDRID DstId, MeetingInfo& MeetingId, bool IsOff )
{
	//CPBX* pPbx = __getPbx(MeetingId.NodeNo);
	//2018.4.9
	CPBX* pPbx = __getPbx(m_DspIsxNo);
	ASSERT(pPbx != NULL);

	// 查找静音主控线路
	COneLeg* pLegHost = getCallLeg(DstId);
	if(pLegHost == NULL) 
		return false;

	return pPbx->meetingMute(MeetingId.BoardNo, pLegHost, MeetingId, IsOff);
}

/*****************************************************************
**【函数名称】	meetingRemove
**【函数功能】	线路离开会议
**【参数】	
**【返回值】	
****************************************************************/
bool CMC::meetingRemove( COneLeg* pLeg, MeetingInfo& MeetingId )
{
	//CPBX* pPbx = __getPbx(MeetingId.NodeNo);
	//2018.4.9
	CPBX* pPbx = __getPbx(m_DspIsxNo);
	ASSERT(pPbx != NULL);

	return pPbx->meetingRemove(MeetingId.BoardNo, pLeg, MeetingId);
}

/*****************************************************************
**【函数名称】	meetingRecord
**【函数功能】	会议录音
**【参数】		
**【返回值】	
****************************************************************/
bool CMC::meetingRecord( COneLeg* pLeg, MeetingInfo& MeetingId, RecordContent* pContent, bool IsStop )
{
	//CPBX* pPbx = __getPbx(MeetingId.NodeNo);
	//2018.4.9
	CPBX* pPbx = __getPbx(m_DspIsxNo);
	ASSERT(pPbx != NULL);

	return pPbx->meetingRecord(MeetingId.BoardNo, pLeg, MeetingId, pContent, IsStop);
}

/************************* ****************************************
**【函数名称】	setSessionInfo2Line
**【函数功能】	设定当前线路关联的会话
**【参数】		LineId			线路ID		
SessionCode		会话ID
**【返回值】	
****************************************************************/
void CMC::setSessionInfo2Line( CRDRID LineId, long SessionCode )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg != NULL)
		pLeg->sessionCode() = SessionCode;
}

/*****************************************************************
**【函数名称】	startRecord
**【函数功能】	线路录音启动
**【参数】		LineId			要进行录音的线路ID
pContent		录音内容
**【返回值】	
****************************************************************/
bool CMC::startRecord( CRDRID LineId, RecordContent* pContent )
{
	// 查找录音主控线路
	COneLeg* pLegHost = getCallLeg(LineId);
	ASSERT(pLegHost != NULL);
	if(pLegHost == NULL) 
		return false;

	return pLegHost->startRecord(pContent);
}

/*****************************************************************
**【函数名称】	stopRecord
**【函数功能】	线路录音结束
**【参数】		LineId			要停止录音的线路ID
**【返回值】	
****************************************************************/
bool CMC::stopRecord( CRDRID LineId )
{
	// 查找录音主控线路
	COneLeg* pLegHost = getCallLeg(LineId);
	ASSERT(pLegHost != NULL);
	if(pLegHost == NULL) 
		return false;

	return pLegHost->stopRecord();
}

/*****************************************************************
**【函数名称】	move2Meeting
**【函数功能】	线路加入会议
**【参数】		LineId			要加入会议的的线路ID
ConfId			要加入的会议ID
**【返回值】	
****************************************************************/
bool CMC::move2Meeting( CRDRID LineId, MeetingInfo& MeetId, bool IsOneWay )
{
	//CPBX* pPbx = __getPbx(MeetId.NodeNo);
	//2018.4.9
	CPBX* pPbx = __getPbx(m_DspIsxNo);
	ASSERT(pPbx != NULL);

	// 查找线路
	COneLeg* pLegHost = getCallLeg(LineId);
	if(pLegHost == NULL) 
		return false;

	return pPbx->meetingJoin(MeetId.BoardNo, pLegHost, MeetId, IsOneWay);
}

/*****************************************************************
**【函数名称】	removeFromMeeting
**【函数功能】	线路离开会议
**【参数】		LineId			要离开会议的线路ID
ConfId			要离开的会议ID
**【返回值】	
****************************************************************/
bool CMC::removeFromMeeting( CRDRID LineId, MeetingInfo& MeetId )
{
	CPBX* pPbx = __getPbx(MeetId.NodeNo);
	ASSERT(pPbx != NULL);

	// 查找线路
	COneLeg* pLegHost = getCallLeg(LineId);
	if(pLegHost == NULL) 
		return false;

	return pPbx->meetingRemove(MeetId.BoardNo, pLegHost, MeetId);
}

/*****************************************************************
**【函数名称】	playSound
**【函数功能】	线路放音收号操作
**【参数】		LineId			要放音的线路ID
pContend		放音内容
**【返回值】	
****************************************************************/
bool CMC::playSound( CRDRID LineId, PlayVoiceContent* pContent )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg == NULL)
		return false;

	return pLeg->playSound(pContent);
}

/*****************************************************************
**【函数名称】	playStop
**【函数功能】	线路停止放音操作
**【参数】		LineId			要停止放音的线路ID
**【返回值】	
****************************************************************/
bool CMC::playStop( CRDRID LineId )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg == NULL)
		return false;

	return pLeg->playStop();
}

/*****************************************************************
**【函数名称】	dropCall
**【函数功能】	线路挂机操作处理
**【参数】		LineId			要挂机的线路ID
bIsPassive		是否为被动挂机
**【返回值】	
****************************************************************/
bool CMC::dropCall( CRDRID LineId, bool IsPassive )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg == NULL)
		return false;

	return pLeg->dropCall(IsPassive);
}

/*****************************************************************
**【函数名称】	dial
**【函数功能】	线路拨号
**【参数】		LineId			要启动拨号的线路ID
lpCalleeNum		被叫号码
lpCallerNum		主叫号码
**【返回值】	
****************************************************************/
bool CMC::dial( CRDRID LineId, LPCTSTR Callee, LPCTSTR Caller, int AccountId )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg == NULL)
		return false;

	return pLeg->makeCall(Callee, Caller, AccountId);
}

/*****************************************************************
**【函数名称】	answer
**【函数功能】	应答呼叫
**【参数】		LineId			要应答呼叫的线路ID
**【返回值】	
****************************************************************/
bool CMC::answer( CRDRID LineId )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg == NULL)
		return false;

	return pLeg->answer();
}

/*****************************************************************
**【函数名称】	offHook
**【函数功能】	通知内线摘机（只对内线有效）
**【参数】		LineId			要进行摘机的线路ID
**【返回值】	
****************************************************************/
bool CMC::offHook( CRDRID LineId, bool IgnoreSession, LPCTSTR CallerNum /*= NULL*/ )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg == NULL)
		return false;

	return pLeg->offhook(IgnoreSession, CallerNum);
}

/*****************************************************************
**【函数名称】	fax
**【函数功能】	传真启动（只对外线有效）
**【参数】		LineId			要启动传真的线路
lpFileName		传真文件名
IsRevc			接收/发送
**【返回值】	
****************************************************************/
bool CMC::fax( CRDRID LineId, LPCTSTR lpFileName, bool IsRecv )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg == NULL)
		return false;

	if(IsRecv)
		return m_FaxDev.recv(pLeg, lpFileName);
	else
		return m_FaxDev.send(pLeg, lpFileName);
}

/*****************************************************************
**【函数名称】	selfCheck
**【函数功能】	线路自检（只对模拟外线有效）
**【参数】		LineId			要进行自检的线路ID
**【返回值】	
****************************************************************/
bool CMC::selfCheck( CRDRID LineId )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg == NULL)
		return false;

	return pLeg->check();
}

/*****************************************************************
**【函数名称】	playTone
**【函数功能】	线路播放信号音
**【参数】		LineId			要播放信号音的线路ID
Type			信号音类型
**【返回值】	
****************************************************************/
bool CMC::playTone( CRDRID LineId, int Type )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg == NULL)
		return false;

	return pLeg->playTone(Type);
}

/*****************************************************************
**【函数名称】	createMeeting
**【函数功能】	创建会议
**【参数】		
**【返回值】	
****************************************************************/
bool CMC::createMeeting( CRDRID LineId, MeetingInfo& MeetInfo )
{
	//CPBX* pPbx = __getPbx(LineId.NodeNo);
	//2018.4.9
	CPBX* pPbx = __getPbx(m_DspIsxNo);
	ASSERT(pPbx != NULL);
	if (pPbx == NULL)
		return false;

	return pPbx->meetingCreate(DEVICE_BRD_NO_ANY, MeetInfo);
}

/*****************************************************************
**【函数名称】	deleteMeeting
**【函数功能】	创建会议
**【参数】		
**【返回值】	
****************************************************************/
void CMC::deleteMeeting( MeetingInfo& MeetInfo )
{
	//CPBX* pPbx = __getPbx(MeetInfo.NodeNo);
	//2018.4.9
	CPBX* pPbx = __getPbx(m_DspIsxNo);

	ASSERT(pPbx != NULL);

	return pPbx->meetingDelete(MeetInfo);
}

/*****************************************************************
**【函数名称】	freeChanResource
**【函数功能】	释放绑定资源
**【参数】		
**【返回值】		
****************************************************************/
void CMC::freeChanResource( CRDRID LineId )
{
	COneLeg* pLeg = getCallLeg(LineId);
	ASSERT(pLeg != NULL);
	if(pLeg == NULL)
		return;

	return pLeg->freeResBinded();
}

/*****************************************************************
**【函数名称】	findIpmCh
**【函数功能】	查找IPM通道
**【参数】		
**【返回值】	
****************************************************************/
CIpmChannel* CMC::findIpmCh( CRDRID ResId )
{
	CPBX* pPbx = __getPbx(ResId.NodeNo);
	ASSERT(pPbx != NULL);

	return pPbx->findIpmCh(ResId);
}

/*****************************************************************
**【函数名称】	findDspCh
**【函数功能】	查找DSP通道
**【参数】		
**【返回值】	
****************************************************************/
CDspChannel* CMC::findDspCh( CRDRID ResId )
{
	//CPBX* pPbx = __getPbx(ResId.NodeNo);2018.4.9
	CPBX* pPbx = __getPbx(m_DspIsxNo);

	ASSERT(pPbx != NULL);

	return pPbx->findDspCh(ResId);
}

/*****************************************************************
**【函数名称】	findVoipCh
**【函数功能】	查找VOIP通道
**【参数】		
**【返回值】	
****************************************************************/
CVoipChannel* CMC::findVoipCh( CRDRID ResId )
{
	CPBX* pPbx = __getPbx(ResId.NodeNo);
	ASSERT(pPbx != NULL);

	return pPbx->findVoipCh(ResId);
}

/*****************************************************************
**【函数名称】	findSpanCh
**【函数功能】	查找SPAN通道
**【参数】		
**【返回值】	
****************************************************************/
CSpanChannel* CMC::findSpanCh( CRDRID ResId )
{
	CPBX* pPbx = __getPbx(ResId.NodeNo);
	ASSERT(pPbx != NULL);

	return pPbx->findSpanCh(ResId);
}