middleware_threemetting/StableCore/PBX.cpp

#include "StdAfx.h"
#include "PBX.h"
#include "DevDsp.h"
#include "MC.h"
#include "DevIpm.h"
#include "DevVoip.h"
#include "VoipChannel.h"
#include "Config.h"
#include "DevSpan.h"
#include "SpanChannel.h"


CPBX::CPBX(CMC* pParent, int IsxNo) : m_pParent(pParent), m_IsxNo(IsxNo), m_state(0)
{
}


CPBX::~CPBX(void)
{
	__free();
}

/*****************************************************************
**【函数名称】	__free
**【函数功能】	释放资源
**【参数】		
**【返回值】	
****************************************************************/
void CPBX::__free( void )
{
	if (!m_SpanList.IsEmpty())
	{
		for(int i = 0; i < m_SpanList.GetCount(); ++i)
		{
			m_SpanList[i]->close();
			delete m_SpanList[i];
		}
		m_SpanList.RemoveAll();
	}

	if (!m_DspList.IsEmpty())
	{
		for(int i = 0; i < m_DspList.GetCount(); ++i)
		{
			m_DspList[i]->close();
			delete m_DspList[i];
		}
		m_DspList.RemoveAll();
	}

	if (!m_VoipList.IsEmpty())
	{
		for(int i = 0; i < m_VoipList.GetCount(); ++i)
		{
			m_VoipList[i]->close();
			delete m_VoipList[i];
		}
		m_VoipList.RemoveAll();
	}

	if (!m_IpmList.IsEmpty())
	{
		for(int i = 0; i < m_IpmList.GetCount(); ++i)
		{
			m_IpmList[i]->close();
			delete m_IpmList[i];
		}
		m_IpmList.RemoveAll();
	}
}

/*****************************************************************
**【函数名称】	__getSpan
**【函数功能】	获取Span设备
**【参数】		
**【返回值】	
****************************************************************/
CDevSpan* CPBX::__getSpan( int BoardNo, bool NewWhenNull /*= false*/ )
{
	if(BoardNo == DEVICE_BRD_NO_ANY)
	{
		if(m_SpanList.IsEmpty())
			return NULL;
		else
			return m_SpanList[0];
	}
	else
	{
		CDevSpan* pSpan = NULL;
		for(int i = 0; i < m_SpanList.GetCount(); ++i)
		{
			pSpan = m_SpanList[i];
			ASSERT(pSpan != NULL);
			if(pSpan->boardNo() == BoardNo)
				return pSpan;
		}

		if(NewWhenNull)
		{
			// 查不到指定设备，则新建一个
			pSpan = new CDevSpan(m_IsxNo, BoardNo);
			ASSERT(pSpan != NULL);
			m_SpanList.Add(pSpan);
			return pSpan;
		}

		return NULL;
	}
}

/*****************************************************************
**【函数名称】	__getDsp
**【函数功能】	获取DSP设备
**【参数】		
**【返回值】	
****************************************************************/
CDevDsp* CPBX::__getDsp( int BoardNo, bool NewWhenNull /*= false*/ )
{
	if(BoardNo == DEVICE_BRD_NO_ANY)
	{
		if(m_DspList.IsEmpty())
			return NULL;
		else
			return m_DspList[0];
	}
	else
	{
		CDevDsp* pDsp = NULL;
		for(int i = 0; i < m_DspList.GetCount(); ++i)
		{
			pDsp = m_DspList[i];
			ASSERT(pDsp != NULL);
			if(pDsp->boardNo() == BoardNo)
				return pDsp;
		}

		if(NewWhenNull)
		{
			// 查不到指定设备，则新建一个
			pDsp = new CDevDsp(m_IsxNo, BoardNo);
			ASSERT(pDsp != NULL);
			m_DspList.Add(pDsp);
			return pDsp;
		}

		return NULL;
	}
}

/*****************************************************************
**【函数名称】	__getVoip
**【函数功能】	获取VOIP设备
**【参数】		
**【返回值】	
****************************************************************/
CDevVoip* CPBX::__getVoip( int BoardNo, bool NewWhenNull /*= false*/ )
{
	if(BoardNo == DEVICE_BRD_NO_ANY)
	{
		if(m_VoipList.IsEmpty())
			return NULL;
		else
			return m_VoipList[0];
	}
	else
	{
		CDevVoip* pVoip = NULL;
		for(int i = 0; i < m_VoipList.GetCount(); ++i)
		{
			pVoip = m_VoipList[i];
			ASSERT(pVoip != NULL);
			if(pVoip->boardNo() == BoardNo)
				return pVoip;
		}

		if(NewWhenNull)
		{
			// 查不到指定设备，则新建一个
			pVoip = new CDevVoip(m_IsxNo, BoardNo);
			ASSERT(pVoip != NULL);
			m_VoipList.Add(pVoip);
			return pVoip;
		}

		return NULL;
	}
}

/*****************************************************************
**【函数名称】	__getIpm
**【函数功能】	获取IPM设备
**【参数】		
**【返回值】	
****************************************************************/
CDevIpm* CPBX::__getIpm( int BoardNo, bool NewWhenNull /*= false*/ )
{
	if(BoardNo == DEVICE_BRD_NO_ANY)
	{
		if(m_IpmList.IsEmpty())
			return NULL;
		else
			return m_IpmList[0];
	}
	else
	{
		CDevIpm* pIpm = NULL;
		for(int i = 0; i < m_IpmList.GetCount(); ++i)
		{
			pIpm = m_IpmList[i];
			ASSERT(pIpm != NULL);
			if(pIpm->boardNo() == BoardNo)
				return pIpm;
		}

		if(NewWhenNull)
		{
			// 查不到指定设备，则新建一个
			pIpm = new CDevIpm(m_IsxNo, BoardNo);
			ASSERT(pIpm != NULL);
			m_IpmList.Add(pIpm);
			return pIpm;
		}

		return NULL;
	}
}

/*****************************************************************
**【函数名称】	__isSpanOk
**【函数功能】	Span设备目前是否可用
**【参数】		
**【返回值】	
****************************************************************/
bool CPBX::__isSpanOk( void ) const
{
	if(CConfig::digitalTrunkCount() <= 0)
		return true;

	if(m_SpanList.IsEmpty())
		return false;

	for(int i = 0; i < m_SpanList.GetCount(); ++i)
	{
		if(!m_SpanList[i]->isOk())
			return false;
	}

	return true;
}

/*****************************************************************
**【函数名称】	__isDspOk
**【函数功能】	DSP设备目前是否可用
**【参数】		
**【返回值】	
****************************************************************/
bool CPBX::__isDspOk( void ) const
{
	if(m_DspList.IsEmpty())
		return false;

	for(int i = 0; i < m_DspList.GetCount(); ++i)
	{
		if(!m_DspList[i]->isOk())
			return false;
	}

	return true;
}

/*****************************************************************
**【函数名称】	__isVoipOk
**【函数功能】	VOIP设备目前是否可用
**【参数】		
**【返回值】	
****************************************************************/
bool CPBX::__isVoipOk( void ) const
{
	if(m_VoipList.IsEmpty())
		return false;

	for(int i = 0; i < m_VoipList.GetCount(); ++i)
	{
		if(!m_VoipList[i]->isOk())
			return false;
	}

	return true;
}

/*****************************************************************
**【函数名称】	__isIpmOk
**【函数功能】	IPM设备目前是否可用
**【参数】		
**【返回值】	
****************************************************************/
bool CPBX::__isIpmOk( void ) const
{
	if(m_IpmList.IsEmpty())
		return false;

	for(int i = 0; i < m_IpmList.GetCount(); ++i)
	{
		if(!m_IpmList[i]->isOk())
			return false;
	}

	return true;
}

/*****************************************************************
**【函数名称】	isOk
**【函数功能】	设备目前是否可用
**【参数】		
**【返回值】	
****************************************************************/
bool CPBX::isOk( void ) const
{
	if(m_state != STATUS_WORKING)
		return false;

	if(!__isSpanOk())
		return false;

	if(!__isDspOk())
		return false;

	if(!__isVoipOk())
		return false;

	if(!__isIpmOk())
		return false;

	return true;
}

/*****************************************************************
**【函数名称】	getVoipNetId
**【函数功能】	获取VOIP卡网络标识
**【参数】		
**【返回值】	
****************************************************************/
ULONG CPBX::getVoipNetId( int BoardNo )
{
	CDevVoip* pVoip = __getVoip(BoardNo);
	ASSERT(pVoip != NULL);
	if(pVoip != NULL)
		return pVoip->netId();
	else
		return 0;
}

/*****************************************************************
**【函数名称】	allocVoipCh4Exten
**【函数功能】	为分机分配VOIP通道
**【参数】		
**【返回值】	
****************************************************************/
CVoipChannel* CPBX::allocVoipCh4Exten( void )
{
	CVoipChannel* pChan = NULL;
	for(int i = 0; i < m_VoipList.GetCount(); ++i)
	{
		CDevVoip* pVoip = m_VoipList[i];
		ASSERT(pVoip != NULL);
		if(pVoip->service4Exten())
		{
			pChan = pVoip->getFreeVoipCh();
			if(pChan != NULL)
				break;
		}
	}

	return pChan;
}

/*****************************************************************
**【函数名称】	allocIpmCh
**【函数功能】	根据网络标识分配IPM通道
**【参数】		
**【返回值】	
****************************************************************/
CIpmChannel* CPBX::allocIpmCh( ULONG NetId )
{
	CIpmChannel* pChan = NULL;

	if(m_IpmList.GetCount() == 1)	// 单IPM板则直接由此板分配IPM通道
	{
		pChan = m_IpmList[0]->getFreeIpmCh();
	}
	else	// 多IPM板则根据网络标识选择板子分配IPM通道
	{
		for(int i = 0; i < m_IpmList.GetCount(); ++i)
		{
			CDevIpm* pIpm = m_IpmList[i];
			ASSERT(pIpm != NULL);
			if(NetId == pIpm->netId())
			{
				pChan = pIpm->getFreeIpmCh();
				if(pChan != NULL)
					break;
			}
		}
	}

	return pChan;
}

/*****************************************************************
**【函数名称】	allocSpanCh
**【函数功能】	分配数字中继通道
**【参数】		
**【返回值】	
****************************************************************/
CSpanChannel* CPBX::allocSpanCh( int BoardNo, int SpanNo )
{
	CDevSpan* pSpan = __getSpan(BoardNo);
	ASSERT(pSpan != NULL);
	if(pSpan != NULL)
		return pSpan->getFreeSpanCh(SpanNo);
	else
		return NULL;
}

/*****************************************************************
**【函数名称】	allocVoipCh
**【函数功能】	分配VOIP通道
**【参数】		
**【返回值】	
****************************************************************/
CVoipChannel* CPBX::allocVoipCh( int BoardNo )
{
	CDevVoip* pVoip = __getVoip(BoardNo);
	ASSERT(pVoip != NULL);
	if(pVoip != NULL)
		return pVoip->getFreeVoipCh();
	else
		return NULL;
}

/*****************************************************************
**【函数名称】	allocDspCh
**【函数功能】	分配DSP通道
**【参数】		
**【返回值】	
****************************************************************/
CDspChannel* CPBX::allocDspCh( int p_BoardNo )
{
	CDspChannel* pChan = NULL;
	for(int i = 0; i < m_DspList.GetCount(); ++i)
	{
		CDevDsp* pDsp = m_DspList[i];
		ASSERT(pDsp != NULL);
		if(p_BoardNo == DEVICE_BRD_NO_ANY || pDsp->boardNo() == p_BoardNo)
		{
			pChan = pDsp->getFreeDspCh();
			if(pChan != NULL)
				break;
		}
	}
	if (pChan == NULL) 
		LOGGER(LOG_CLASS_DEV, LOG_LEVEL_WARNING, _T("{PBX_%d}:allocDspCh,brdNo=%d,No dsp channel."), m_IsxNo, p_BoardNo);
	else
		LOGGER(LOG_CLASS_DEV, LOG_LEVEL_NORMAL, _T("{PBX_%d}:allocDspCh,brdNo=%d"), m_IsxNo, p_BoardNo);

	return pChan;
}

/*****************************************************************
**【函数名称】	allocFreeTrunk
**【函数功能】	分配空闲中继线路
**【参数】		
**【返回值】	
****************************************************************/
COneLeg* CPBX::allocFreeTrunk(int BoardNo, int SpanNo)
{
	COneLeg* pCallLeg = NULL;

	// 从板子号不好确认中继类型，所以优先考虑E1数字中继
	if (CConfig::digitalTrunkCount() > 0 && SpanNo != INVALID_ID_DT_SPAN)
		pCallLeg = allocSpanCh(BoardNo, SpanNo);

	// 数字中继不行，使用VOIP中继
	if (pCallLeg == NULL && CConfig::voipTrunkCount() > 0)
	{
		pCallLeg = allocVoipCh(BoardNo);
		LOGGER(LOG_CLASS_DEV, LOG_LEVEL_WARNING, _T("{PBX_%d}:allocFreeTrunk,使用VOIP中继,brdNo=%d"), m_IsxNo, BoardNo);
	}
	return pCallLeg;
}

/*****************************************************************
**【函数名称】	findLineResource
**【函数功能】	查找指定的线路资源
**【参数】		
**【返回值】	
****************************************************************/
COneLeg* CPBX::findLeg( CRDRID Id )
{
	COneLeg* pLeg = NULL;
	if(Id.ResType == DEV_RES_TYPE_VOIP)		// 搜寻VOIP通道
	{
		CDevVoip* pVoip = __getVoip(Id.BoardNo);
		ASSERT(pVoip != NULL);
		pLeg = pVoip->findChan(Id.ChanNo);
	}
	else if(Id.ResType == DEV_RES_TYPE_TRUNK)	// 搜索DTI通道
	{
		CDevSpan* pSpan = __getSpan(Id.BoardNo);
		ASSERT(pSpan != NULL);
		pLeg = pSpan->findChan(Id.SpanNo, Id.ChanNo);
	}

	return pLeg;
}

/*****************************************************************
**【函数名称】	meetingCreate
**【函数功能】	创建会议
**【参数】		
**【返回值】	
****************************************************************/
bool CPBX::meetingCreate( int BoardNo, MeetingInfo& MeetingId )
{
	CDevDsp* pDsp = __getDsp(BoardNo);
	ASSERT(pDsp != NULL);
	if(pDsp != NULL)
		return pDsp->createMeeting(MeetingId);
	else
		return false;
}

/*****************************************************************
**【函数名称】	meetingDelete
**【函数功能】	删除会议
**【参数】		
**【返回值】	
****************************************************************/
void CPBX::meetingDelete( MeetingInfo& MeetingId )
{
	CDevDsp* pDsp = __getDsp(MeetingId.BoardNo);
	ASSERT(pDsp != NULL);
	if(pDsp != NULL)
		return pDsp->deleteMeeting(MeetingId);
}

/*****************************************************************
**【函数名称】	meetingJoin
**【函数功能】	加入会议
**【参数】		
**【返回值】	
****************************************************************/
bool CPBX::meetingJoin( int BoardNo, COneLeg* pLeg, MeetingInfo& MeetingId, bool IsOneWay )
{
	CDevDsp* pDsp = __getDsp(BoardNo);
	ASSERT(pDsp != NULL);
	if(pDsp != NULL)
	{
		if(pDsp->meetingAccept(MeetingId.MeetingId, pLeg, IsOneWay))
		{
			pLeg->setMeetingInfo(MeetingId.NodeNo, MeetingId.BoardNo, MeetingId.MeetingId);
			return true;
		}
	}
	
	return false;
}

/*****************************************************************
**【函数名称】	meetingRemove
**【函数功能】	离开会议
**【参数】		
**【返回值】	
****************************************************************/
bool CPBX::meetingRemove( int BoardNo, COneLeg* pLeg, MeetingInfo& MeetingId )
{
	CDevDsp* pDsp = __getDsp(BoardNo);
	ASSERT(pDsp != NULL);
	if(pDsp != NULL)
	{
		if(pDsp->meetingRemove(MeetingId.MeetingId, pLeg))
		{
			pLeg->setMeetingInfo(0, 0, MEETING_ID_INVALID);
			return true;
		}
	}

	return false;
}

/*****************************************************************
**【函数名称】	meetingRecord
**【函数功能】	会议录音
**【参数】		
**【返回值】	
****************************************************************/
bool CPBX::meetingRecord( int BoardNo, COneLeg* pLeg, MeetingInfo& MeetingId, RecordContent* pContent, bool IsStop )
{
	CDevDsp* pDsp = __getDsp(BoardNo);
	ASSERT(pDsp != NULL);
	if(pDsp != NULL)
		return pDsp->meetingRecord(MeetingId.MeetingId, pLeg, pContent, IsStop);
	else
		return false;
}

/*****************************************************************
**【函数名称】	meetingMute
**【函数功能】	静音会议中线路
**【参数】		
**【返回值】	
****************************************************************/
bool CPBX::meetingMute( int BoardNo, COneLeg* pLeg, MeetingInfo& MeetingId, bool IsOff )
{
	CDevDsp* pDsp = __getDsp(BoardNo);
	ASSERT(pDsp != NULL);
	if(pDsp != NULL)
		return pDsp->meetingMute(MeetingId.MeetingId, pLeg, IsOff);
	else
		return false;
}

/*****************************************************************
**【函数名称】	onResourceStateUpdated
**【函数功能】	设备资源状态更新处理函数
**【参数】		
**【返回值】	
****************************************************************/
void CPBX::onResourceStateUpdated( 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_MB_STATUS:
		{
			if(State != STATUS_WORKING)
			{
				if(m_state == STATUS_WORKING)
					m_pParent->onPbxResInvalid(m_IsxNo, m_IsxNo, DEV_RES_TYPE_MB);

				m_state = State;
			}
			else
			{
				m_state = STATUS_WORKING;
				if(isOk())
					m_pParent->onPbxResValid(m_IsxNo);
			}
			
			
			LOGGER(LOG_CLASS_DEV, Level, _T("{PBX_%d}: MB state is updated, state = %s"), m_IsxNo, m_pParent->transState(State));
		}
		break;

	case SYSEV_SPAN_STATUS:
		{
			CDevSpan* pSpan = __getSpan(pEvtData->cBrdNo, true);
			ASSERT(pSpan != NULL);

			if(State == STATUS_WORKING)
			{
				pSpan->state() = STATUS_WORKING;
				if(CConfig::digitalTrunkCount() > 0)
				{
					if(!pSpan->open(pEvtData->cSpanNum))
						m_pParent->onPbxResInvalid(m_IsxNo, pSpan->boardNo(), DEV_RES_TYPE_TRUNK);
				}

				if(isOk())
					m_pParent->onPbxResValid(m_IsxNo);
			}
			else
			{
				if(pSpan != NULL)
				{
					if(pSpan->state() == STATUS_WORKING)
					{
						pSpan->close(pEvtData->cSpanNum);
						m_pParent->onPbxResInvalid(m_IsxNo, pSpan->boardNo(), DEV_RES_TYPE_TRUNK);						
					}
					pSpan->state() = State;					
				}
			}

			LOGGER(LOG_CLASS_DEV, Level, _T("{PBX_%d}: SPAN[%d] state is updated, state = %s"), 
				m_IsxNo, pEvtData->cBrdNo, m_pParent->transState(State));
		}
		break;

	case SYSEV_DSP_STATUS:
		{
			CDevDsp* pDsp = __getDsp(pEvtData->cBrdNo, true);
			ASSERT(pDsp != NULL);

			if(State == STATUS_WORKING)
			{
				pDsp->state() = State;
				if(pDsp->capacity() > 0)
				{
					if(!pDsp->open())
						m_pParent->onPbxResInvalid(m_IsxNo, pDsp->boardNo(), DEV_RES_TYPE_DSP);
				}

				if(isOk())
					m_pParent->onPbxResValid(m_IsxNo);
			}
			else
			{
				if(pDsp != NULL)
				{
					if(pDsp->state() == STATUS_WORKING)
					{
						pDsp->close();
						m_pParent->onPbxResInvalid(m_IsxNo, pDsp->boardNo(), DEV_RES_TYPE_DSP);						
					}
					pDsp->state() = State;					
				}
			}
			
			LOGGER(LOG_CLASS_DEV, Level, _T("{PBX_%d}: DSP[%d] state is updated, state = %s"), 
				m_IsxNo, pEvtData->cBrdNo, m_pParent->transState(State));
		}
		break;	

	case SYSEV_SIP_STATUS:
		{
			CDevVoip* pVoip = __getVoip(pEvtData->cBrdNo, true);
			ASSERT(pVoip != NULL);

			if(State == STATUS_WORKING)
			{
				pVoip->state() = State;
				if(pVoip->capacity() > 0)
				{
					if(!pVoip->open())
						m_pParent->onPbxResInvalid(m_IsxNo, pVoip->boardNo(), DEV_RES_TYPE_VOIP);
				}

				if(isOk())
					m_pParent->onPbxResValid(m_IsxNo);
			}
			else
			{
				if(pVoip != NULL)
				{
					if(pVoip->state() == STATUS_WORKING)
					{
						pVoip->close();
						m_pParent->onPbxResInvalid(m_IsxNo, pVoip->boardNo(), DEV_RES_TYPE_VOIP);						
					}
					pVoip->state() = State;										
				}
			}

			LOGGER(LOG_CLASS_DEV, Level, _T("{PBX_%d}: SIP[%d] state is updated, state = %s"), 
				pEvtData->cIsxNo, pEvtData->cBrdNo, m_pParent->transState(State));
		}
		break;

	case SYSEV_XOIP_STATUS:
		{
			CDevIpm* pIpm = __getIpm(pEvtData->cBrdNo, true);
			ASSERT(pIpm != NULL);

			if(State == STATUS_WORKING)
			{
				pIpm->state() = State;
				if(pIpm->capacity() > 0)
				{
					if(!pIpm->open())
						m_pParent->onPbxResInvalid(m_IsxNo, pIpm->boardNo(), DEV_RES_TYPE_IPM);
				}

				if(isOk())
					m_pParent->onPbxResValid(m_IsxNo);
			}
			else
			{
				if(pIpm != NULL)
				{
					if(pIpm->state() == STATUS_WORKING)
					{
						m_pParent->onPbxResInvalid(m_IsxNo, pIpm->boardNo(), DEV_RES_TYPE_IPM);
						pIpm->close();
					}
					pIpm->state() = State;										
				}
			}

			LOGGER(LOG_CLASS_DEV, Level, _T("{PBX_%d}: XOIP[%d] state is updated, state = %s"), 
				pEvtData->cIsxNo, pEvtData->cBrdNo, m_pParent->transState(State));
		}
		break;

	case SYSEV_PRI_STATUS:
		LOGGER(LOG_CLASS_DEV, Level, _T("{PBX_%d}: PRI[%d] state is updated, state = %s"), 
			pEvtData->cIsxNo, pEvtData->cBrdNo, m_pParent->transState(State));
		break;

	case SYSEV_SS7_STATUS:
		LOGGER(LOG_CLASS_DEV, Level, _T("{PBX_%d}: SS7[%d] state is updated, state = %s"), 
			pEvtData->cIsxNo, pEvtData->cBrdNo, m_pParent->transState(State));
		break;
	}
}

/*****************************************************************
**【函数名称】	onResourceAlarm
**【函数功能】	设备资源告警处理函数
**【参数】		
**【返回值】	
****************************************************************/
void CPBX::onResourceAlarm( INT EvtType, SYS_EVT_DATA* pEvtData )
{
	ASSERT(pEvtData != NULL);

	switch(EvtType)
	{
	case SYSEV_SPAN_ALARM:
		{
			if(pEvtData->u.usAlarm == 0)
				LOGGER(LOG_CLASS_DEV, LOG_LEVEL_NORMAL, _T("{PBX_%d}: SPAN[%d-%d]告警解除"), 
				pEvtData->cIsxNo, pEvtData->cBrdNo, pEvtData->cSpanNum);
			else
				LOGGER(LOG_CLASS_DEV, LOG_LEVEL_WARNING, _T("{PBX_%d}: SPAN[%d-%d]告警, Code = 0x%x"), 
				pEvtData->cIsxNo, pEvtData->cBrdNo, pEvtData->cSpanNum, pEvtData->u.usAlarm);
		}
		break;

	case SYSEV_PRIDCH_ALARM:
		{
			if(pEvtData->u.dchAlarm.ucAlarm == 0)
				LOGGER(LOG_CLASS_DEV, LOG_LEVEL_NORMAL, _T("{PBX_%d}: PRI[%d-%d]D通道告警解除"), 
				pEvtData->cIsxNo, pEvtData->cBrdNo, pEvtData->u.dchAlarm.ch.spanno);
			else
				LOGGER(LOG_CLASS_DEV, LOG_LEVEL_WARNING, _T("{PBX_%d}: PRI[%d-%d]D通道告警, Code = 0x%x"), 
				pEvtData->cIsxNo, pEvtData->cBrdNo, pEvtData->u.dchAlarm.ch.spanno, pEvtData->u.dchAlarm.ucAlarm);
		}
		break;

	case SYSEV_S7LINK_ALARM:
		{
			if(pEvtData->u.linkAlarm.ucAlarm == 0)
				LOGGER(LOG_CLASS_DEV, LOG_LEVEL_NORMAL, _T("{PBX_%d}: SS7[%d]链路[%d]告警解除"), 
				pEvtData->cIsxNo, pEvtData->cBrdNo, pEvtData->u.linkAlarm.ucStackId);
			else
				LOGGER(LOG_CLASS_DEV, LOG_LEVEL_WARNING, _T("{PBX_%d}: SS7[%d]链路[%d]告警, Code = 0x%x"), 
				pEvtData->cIsxNo, pEvtData->cBrdNo, pEvtData->u.linkAlarm.ucStackId, pEvtData->u.linkAlarm.ucAlarm);
		}
		break;
	}
}

/*****************************************************************
**【函数名称】	onResourceCapacity
**【函数功能】	设备资源容量处理函数
**【参数】		
**【返回值】	
****************************************************************/
void CPBX::onResourceCapacity( INT EvtType, SYS_EVT_DATA* pEvtData )
{
	switch(EvtType)
	{
	case SYSEV_DSP_BRD_CAP:
		{
			CDevDsp* pDsp = __getDsp(pEvtData->cBrdNo, true);
			ASSERT(pDsp != NULL);
			if(pDsp->state() == STATUS_WORKING)
			{
				pDsp->capacity() = pEvtData->u.sCap;
				if(!pDsp->open())
					m_pParent->onPbxResInvalid(m_IsxNo, pDsp->boardNo(), DEV_RES_TYPE_DSP);
			}
		}
		break;

	case SYSEV_SIP_BRD_CAP:
		{
			CDevVoip* pVoip = __getVoip(pEvtData->cBrdNo, true);
			ASSERT(pVoip != NULL);
			if(pVoip->state() == STATUS_WORKING)
			{
				pVoip->capacity() = pEvtData->u.sCap;
				if(!pVoip->open())
					m_pParent->onPbxResInvalid(m_IsxNo, pVoip->boardNo(), DEV_RES_TYPE_VOIP);
			}
		}
		break;

	case SYSEV_XOIP_BRD_CAP:
		{
			CDevIpm* pIpm = __getIpm(pEvtData->cBrdNo, true);
			ASSERT(pIpm != NULL);
			if(pIpm->state() == STATUS_WORKING)
			{
				pIpm->capacity() = pEvtData->u.sCap;
				if(!pIpm->open())
					m_pParent->onPbxResInvalid(m_IsxNo, pIpm->boardNo(), DEV_RES_TYPE_IPM);
			}
		}
		break;
	}
}

/*****************************************************************
**【函数名称】	onSipRegSent
**【函数功能】	处理SIP注册发送事件
**【参数】		
**【返回值】	
****************************************************************/
void CPBX::onSipRegSent( SEND_SIPREG_RET* pSent )
{
	CDevVoip* pVoip = __getVoip(pSent->RegisterId.ucBrdNo);
	ASSERT(pVoip != NULL);
	pVoip->onSipRegSent(pSent);
}

/*****************************************************************
**【函数名称】	onSipRegAck
**【函数功能】	处理SIP注册确认事件
**【参数】		
**【返回值】	
****************************************************************/
void CPBX::onSipRegAck( SIP_REGISTER_ACK* pAck )
{
	CDevVoip* pVoip = __getVoip(pAck->RegisterId.ucBrdNo);
	ASSERT(pVoip != NULL);
	pVoip->onSipRegAck(pAck);
}

/*****************************************************************
**【函数名称】	onSipTransaction
**【函数功能】	收到SIP事务事件的处理函数
**【参数】		
**【返回值】	
****************************************************************/
void CPBX::onSipTransaction( SIP_TRANSACTION_IND* pTransaction )
{
	CDevVoip* pVoip = __getVoip(pTransaction->ucBrdNo);
	ASSERT(pVoip != NULL);
	pVoip->onSipTransaction(pTransaction);
}

/*****************************************************************
**【函数名称】	findIpmCh
**【函数功能】	查找IPM通道
**【参数】		
**【返回值】	
****************************************************************/
CIpmChannel* CPBX::findIpmCh( CRDRID ResId )
{
	CDevIpm* pIpm  = __getIpm(ResId.BoardNo);
	ASSERT(pIpm != NULL);
	return pIpm->findChan(ResId.ChanNo);
}

/*****************************************************************
**【函数名称】	findDspCh
**【函数功能】	查找DSP通道
**【参数】		
**【返回值】	
****************************************************************/
CDspChannel* CPBX::findDspCh( CRDRID ResId )
{
	CDevDsp* pDsp = __getDsp(ResId.BoardNo);
	ASSERT(pDsp != NULL);
	return pDsp->findChan(ResId.ChanNo);
}

/*****************************************************************
**【函数名称】	findVoipCh
**【函数功能】	查找VOIP通道
**【参数】		
**【返回值】	
****************************************************************/
CVoipChannel* CPBX::findVoipCh( CRDRID ResId )
{
	CDevVoip* pVoip = __getVoip(ResId.BoardNo);
	ASSERT(pVoip != NULL);
	return pVoip->findChan(ResId.ChanNo);
}

/*****************************************************************
**【函数名称】	findSpanCh
**【函数功能】	查找SPAN通道
**【参数】		
**【返回值】	
****************************************************************/
CSpanChannel* CPBX::findSpanCh( CRDRID ResId )
{
	CDevSpan* pSpan = __getSpan(ResId.BoardNo);
	ASSERT(pSpan != NULL);
	return pSpan->findChan(ResId.SpanNo, ResId.ChanNo);
}