midware_ws/NetLib/FsLink/FsProxy.cpp

#include "StdAfx.h"
#include "FsProxy.h"
#include "ChanExten.h"
#include "ChanTrunk.h"
#include "Session.h"
#include "OperationReactor.h"
#include "../IVR/IvrSysInc.h"


SINGLETON_IMPLEMENT(CFsProxy)


CFsProxy::CFsProxy(void) : m_Gateway(this), m_pEventHandler(NULL)
{
}

CFsProxy::~CFsProxy(void)
{
}

/*****************************************************************
**【函数名称】	__transLogicState2CtiState
**【函数功能】	将逻辑状态转换为CTI识别的状态
**【参数】
**【返回值】
****************************************************************/
UINT CFsProxy::__transLogicState2CtiState(DEV_RES_TYPE ChanType, CHAN_LOGIC_STATE State)
{
	if (ChanType == DEV_RES_TYPE_EXT)
	{
		UINT HoldMask = State & HELD_STATE_IND_MASK;
		switch (State & HELD_STATE_FILTER_MASK)
		{
		case CHAN_LOGIC_STATE_DISABLED:		return INNER_STATE_DISABLED;	// 不可用
		case CHAN_LOGIC_STATE_FREE:			return INNER_STATE_FREE | HoldMask;			// 空闲
		case CHAN_LOGIC_STATE_INIT:			return INNER_STATE_INIT | HoldMask;			// 摘机等待拨号
		case CHAN_LOGIC_STATE_DIALING:		return INNER_STATE_DIALING | HoldMask;		// 拨号
		case CHAN_LOGIC_STATE_RING_BACK:	return INNER_STATE_RING_BACK | HoldMask;	// 呼出振铃
		case CHAN_LOGIC_STATE_ALERTING:		return INNER_STATE_ALERTING | HoldMask;		// 来电振铃
		case CHAN_LOGIC_STATE_TALKING:		return INNER_STATE_TALKING | HoldMask;		// 通话中
		default:
			ASSERT(FALSE);
			return INNER_STATE_DISABLED;
		}
	}
	else
	{
		switch (State)
		{
		case CHAN_LOGIC_STATE_DISABLED:		return TRUNK_STATE_DISABLED;	// 不可用
		case CHAN_LOGIC_STATE_FREE:			return TRUNK_STATE_FREE;		// 空闲
		case CHAN_LOGIC_STATE_DIALING:		return TRUNK_STATE_DIALING;		// 拨号
		case CHAN_LOGIC_STATE_RING_BACK:	return TRUNK_STATE_RING_BACK;	// 呼出振铃
		case CHAN_LOGIC_STATE_ALERTING:		return TRUNK_STATE_ALERTING;	// 来电振铃
		case CHAN_LOGIC_STATE_STANDBY:
		case CHAN_LOGIC_STATE_TALKING:		return TRUNK_STATE_TALKING;		// 通话中
		default:
			ASSERT(FALSE);
			return TRUNK_STATE_UNKNOWN;
		}
	}
}

/*****************************************************************
**【函数名称】	__addExten
**【函数功能】	添加分机
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::__addExten(UINT ExtenNo)
{
	std::lock_guard<std::mutex> lock(m_LockMapChanExt);
	CChanExten* pExten = new(std::nothrow) CChanExten(this, ExtenNo);
	if (pExten == NULL)return;
	m_MapChanExt.SetAt(ExtenNo, pExten);
	pExten->regist();
}

/*****************************************************************
**【函数名称】	delExten
**【函数功能】	删除分机
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::__delExten(UINT ExtenNo)
{
	std::lock_guard<std::mutex> lock(m_LockMapChanExt);
	CChanExten* pExten = NULL;
	if (m_MapChanExt.Lookup(ExtenNo, pExten))
	{
		if (pExten->isFree())
		{
			m_MapChanExt.RemoveKey(ExtenNo);
			FS_LINK_DELETE(pExten);
		}
		else pExten->discard(true);
	}
}

/*****************************************************************
**【函数名称】	__freeExten
**【函数功能】	清空分机
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::__freeExten(void)
{
	std::lock_guard<std::mutex> lock(m_LockMapChanExt);
	UINT ExtenNo = 0;
	CChanExten* pExten = NULL;
	POSITION Pos = m_MapChanExt.GetStartPosition();
	while (Pos != NULL)
	{
		m_MapChanExt.GetNextAssoc(Pos, ExtenNo, pExten);
		FS_LINK_DELETE(pExten);
	}
	m_MapChanExt.RemoveAll();
}

/*****************************************************************
**【函数名称】	__initTrunkChan
**【函数功能】	初始化中继通道
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::__initTrunkChan(void)
{
	std::lock_guard<std::mutex> lock(m_LockArrayTrunk);
	for (int i = 1; i <= CConfig::trunkCount(); ++i)
	{
		CChanTrunk* pTrunk = new(std::nothrow) CChanTrunk(this, i);
		if (pTrunk) {
			m_ArrayTrunk.Add(pTrunk);
			pTrunk->regist();
		}
	}
}

/*****************************************************************
**【函数名称】	__freeTrunkChan
**【函数功能】	清空中继通道
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::__freeTrunkChan(void)
{
	std::lock_guard<std::mutex> lock(m_LockArrayTrunk);
	CChanTrunk* pTrunk = NULL;
	for (int i = 0; i < m_ArrayTrunk.GetCount(); ++i)
	{
		pTrunk = m_ArrayTrunk[i];
		FS_LINK_DELETE(pTrunk);
	}
	m_ArrayTrunk.RemoveAll();
}

/*****************************************************************
**【函数名称】	__getSession
**【函数功能】	查找会话
**【参数】
**【返回值】
****************************************************************/
CSession* CFsProxy::__getSession(PCHAN_EVENT_NOTIFY pNotify, bool NewWhenNull /*= false*/)
{
	CSession* pSession = __getSession(pNotify->CallId);
	if (pSession == NULL && NewWhenNull)
	{
		pSession = new(std::nothrow) CSession(this, pNotify->CallId);
		if (pSession) {
			pSession->prepare(pNotify);
			std::lock_guard<std::mutex> lock(m_LockMapSesssoin);
			m_MapSession.SetAt(pNotify->CallId, pSession);
			LOGGER(LOG_LEVEL_NORMAL, _T("{CFsProxy}:Add Session[%s],ChanId[%s],EventId[%d],HangupCause[%s|%s]"), pSession->id(), pNotify->ChanId, pNotify->EventId, pNotify->HangupCause, pNotify->HangupDisposition);
		}
	}
	return pSession;
}

/*****************************************************************
**【函数名称】	__getSession
**【函数功能】	查找会话
**【参数】
**【返回值】
****************************************************************/
CSession* CFsProxy::__getSession(LPCTSTR SessionId)
{
	std::lock_guard<std::mutex> lock(m_LockMapSesssoin);
	CSession* pSession = NULL;
	m_MapSession.Lookup(SessionId, pSession);
	return pSession;
}

/*****************************************************************
**【函数名称】	__delSession
**【函数功能】	删除会话
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::__delSession(LPCTSTR SessionId)
{
	if (SessionId == NULL)
		return;
	CSession* pSession = NULL;
	std::lock_guard<std::mutex> lock(m_LockMapSesssoin);
	if (m_MapSession.Lookup(SessionId, pSession))
	{
		m_MapSession.RemoveKey(SessionId);
		LOGGER(LOG_LEVEL_NORMAL, _T("{FsProxy}: Delete Session[%s]"), pSession->id());
		FS_LINK_DELETE(pSession);
	}
}

/*****************************************************************
**【函数名称】	__freeSession
**【函数功能】	清空会话
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::__freeSession(void)
{
	CString SessionId = 0;
	CSession* pSession = NULL;
	std::lock_guard<std::mutex> lock(m_LockMapSesssoin);
	POSITION Pos = m_MapSession.GetStartPosition();
	while (Pos != NULL)
	{
		m_MapSession.GetNextAssoc(Pos, SessionId, pSession);
		FS_LINK_DELETE(pSession);
	}
	m_MapSession.RemoveAll();
}

/*****************************************************************
**【函数名称】	__kill
**【函数功能】	挂断通道
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::__kill(LONG JobId, LPCTSTR ChanId)
{
	CString EslCmd;
	if (JobId == FS_LINK_JOBID_INVALID)
		EslCmd.Format(_T("bgapi uuid_kill %s"), ChanId);
	else
		EslCmd.Format(_T("bgapi uuid_kill %s\r\n%s: %ld"), ChanId, ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	init
**【函数功能】	初始化
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::init(IEslEventHandler* pEventHandler)
{
	ASSERT(pEventHandler != NULL);
	m_pEventHandler = pEventHandler;

	__initTrunkChan();
	if (m_Gateway.start())
	{
		m_Gateway.hangupAll();
		if (m_Gateway.scanExten())
		{
			LOGGER(LOG_LEVEL_NORMAL, _T("{FsProxy}: FreeSWITCH代理初始化成功"));
			return true;
		}
		else
		{
			LOGGER(LOG_LEVEL_ERROR, _T("{FsProxy}: FreeSWITCH代理初始化失败, 扫描分机资源失败"));
			return false;
		}
	}
	else
	{
		LOGGER(LOG_LEVEL_ERROR, _T("{FsProxy}: FreeSWITCH代理初始化失败, ESL网关启动失败"));
		m_pEventHandler = NULL;
		return false;
	}
}

/*****************************************************************
**【函数名称】	release
**【函数功能】	释放资源
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::release(void)
{
	esl_disconnect(&m_EslHandle);
	m_Gateway.stop();
	__freeSession();
	__freeExten();
	__freeTrunkChan();
}

/*****************************************************************
**【函数名称】	onChanRegist
**【函数功能】	通道注册的处理函数
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::onChanRegist(DEV_RES_TYPE ChanType, UINT ChanNo, CHAN_LOGIC_STATE ChanState)
{
	CDevControl::GetInstance().onEventResDetail(ChanType, ChanNo);
	CDevControl::GetInstance().onEventResState(ChanType, ChanNo, __transLogicState2CtiState(ChanType, ChanState));
}

/*****************************************************************
**【函数名称】	onExtenDestroy
**【函数功能】	分机销毁的处理函数
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::onExtenDestroy(UINT ExtenNo)
{
	CDevControl::GetInstance().onEventResState(DEV_RES_TYPE_EXT, ExtenNo, INNER_STATE_REMOVE);
}

/*****************************************************************
**【函数名称】	onExtenDirectOp
**【函数功能】	分机直接操作启动
**【参数】		OpType			启动的操作类型
				pHostChan		触发事件的通道
				pNotify			触发操作事件内容
**【返回值】
****************************************************************/
void CFsProxy::onExtenDirectOp(DEV_OP OpType, CVirtualChan* pHostChan, PCHAN_EVENT_NOTIFY pNotify)
{
	switch (OpType)
	{
	case DEV_OP_CALL_OUT:
	{
		if (!COperationReactor::GetInstance().onExtenCallFromDev(pHostChan, pNotify))
			__kill(FS_LINK_JOBID_INVALID, pHostChan->chanId());
	}
	break;
	} // end switch
}

/*****************************************************************
**【函数名称】	onChanStateUpdate
**【函数功能】	通道状态更新处理
**【参数】
**【返回值】
*****************************************************************/
void CFsProxy::onChanStateUpdate(LONG OpInstance, CVirtualChan* pChan)
{
	if (OpInstance != FS_LINK_INSTANCE_INVALID)
		m_pEventHandler->onEslEvtChanState(OpInstance, pChan);

	CDevControl::GetInstance().onEventResState(pChan->type(), pChan->no(), __transLogicState2CtiState(pChan->type(), pChan->state()), pChan->callerNum(), pChan->calleeNum(),pChan->ActiveHanguper(),pChan->TmpChanID());
}

/*****************************************************************
**【函数名称】	onChanPoor
**【函数功能】	空闲通道枯竭处理
**【参数】
**【返回值】
*****************************************************************/
void CFsProxy::onChanPoor(CSession* pSession, PCHAN_EVENT_NOTIFY pNotify)
{
	__kill(FS_LINK_JOBID_INVALID, pNotify->ChanId);
}

/*****************************************************************
**【函数名称】	onTrunkCallIn
**【函数功能】	中继呼入
**【参数】
**【返回值】
*****************************************************************/
void CFsProxy::onTrunkCallIn(CChanTrunk* pTrunk)
{
	CDevControl::GetInstance().onEventDevOperation(pTrunk->no(), DEV_OP_CALL_IN, pTrunk->callerNum(), pTrunk->calleeNum());
}

/*****************************************************************
**【函数名称】	onEslDisconnect
**【函数功能】	ESL连接中断处理
**【参数】
**【返回值】
*****************************************************************/
void CFsProxy::onEslDisconnect(void)
{
	CDevControl::GetInstance().onEventDevDown();
}

/*****************************************************************
**【函数名称】	onEslSipReg
**【函数功能】	分机注册的处理函数
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::onEslExtenReg(UINT ExtenNo)
{
	CChanExten* pExten = getExten(ExtenNo);
	if (pExten == NULL)
	{
		__addExten(ExtenNo);
	}
	else
	{
		if (pExten->isVoid())	// 若被丢弃，则改变丢弃状态
			pExten->discard(false);
	}

#ifdef _DEBUG
	LOGGER(LOG_LEVEL_NORMAL, _T("{FsProxy}: 分机[%u]注册"), ExtenNo);
#endif
}

/*****************************************************************
**【函数名称】	onEslExtenUnreg
**【函数功能】	分机注销的处理函数
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::onEslExtenUnreg(UINT ExtenNo)
{
	__delExten(ExtenNo);

#ifdef _DEBUG
	LOGGER(LOG_LEVEL_NORMAL, _T("{FsProxy}: 分机[%u]注销"), ExtenNo);
#endif
}
/*****************************************************************
**【函数名称】	onEslGwExten
**【函数功能】	网关分机的处理函数
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::onEslGwExtenReg(LPCTSTR ExtenNo, LPCTSTR Ip)
{
	m_MapAddrGwExt.SetAt(ExtenNo, Ip);
	return;
}
void CFsProxy::onEslGwExtenUnreg(LPCTSTR ExtenNo)
{
	CString  t_ip;
	if (m_MapAddrGwExt.Lookup(ExtenNo, t_ip))
	{
		t_ip.Empty();
		m_MapAddrGwExt.RemoveKey(ExtenNo);
	}
}
/*****************************************************************
**【函数名称】	onEslEvtBgJobDone
**【函数功能】	后台任务执行结束事件处理
**【参数】
**【返回值】
*****************************************************************/
void CFsProxy::onEslEvtBgJobDone(PBG_JOB_NOTIFY pNotify)
{
	ASSERT(m_pEventHandler != NULL);
	m_pEventHandler->onEslEvtBgJobDone(pNotify);
}

/*****************************************************************
**【函数名称】	onEslEvtChannel
**【函数功能】	通道事件处理
**【参数】
**【返回值】
*****************************************************************/
void CFsProxy::onEslEvtChannel(PCHAN_EVENT_NOTIFY pNotify)
{
	ASSERT(pNotify != NULL);
	if (pNotify == NULL)
		return;
	CSession* pSession = __getSession(pNotify, true);
	ASSERT(pSession != NULL);
	if (pSession == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{FsProxy}: 通道事件，没有找到会话,EslEventId=%d,ChanId[%s],CallId[%s],Caller[%s],Callee[%s]"), pNotify->EventId, pNotify->ChanId, pNotify->CallId, pNotify->Caller, pNotify->Callee);
		return;
	}
	__try {
		pSession->onChanEvent(pNotify);
		if (pSession->isVoid())
			__delSession(pSession->id());
	}
	__except (EXCEPTION_EXECUTE_HANDLER)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{FsProxy}: 处理通道事件时异常[%u],EslEventId=%d,ChanId[%s],CallId[%s],Caller[%s],Callee[%s]"), GetExceptionCode(), pNotify->EventId, pNotify->ChanId, pNotify->CallId, pNotify->Caller, pNotify->Callee);
		__delSession(pSession->id());
	}
}

/*****************************************************************
**【函数名称】	onEslEvtDtmf
**【函数功能】	DTMF事件处理
**【参数】
**【返回值】
*****************************************************************/
void CFsProxy::onEslEvtDtmf(PDTMF_NOTIFY pNotify)
{
	ASSERT(pNotify != NULL);
	CSession* pSession = __getSession(pNotify->CallId);
	ASSERT(pSession != NULL);
	if (pSession != NULL)
		pSession->onChanDtmf(pNotify);
}

/*****************************************************************
**【函数名称】	onEslEvtHold
**【函数功能】	保持事件处理
**【参数】
**【返回值】
*****************************************************************/
void CFsProxy::onEslEvtHold(PHOLD_NOTIFY pNotify)
{
	ASSERT(pNotify != NULL);
	CSession* pSession = __getSession(pNotify->CallId);
	ASSERT(pSession != NULL);
	if (pSession != NULL)
		pSession->onChanHold(pNotify);
}

/*****************************************************************
**【函数名称】	getExten
**【函数功能】	查找分机
**【参数】
**【返回值】
****************************************************************/
CChanExten* CFsProxy::getExten(UINT ExtenNo)
{
	std::lock_guard<std::mutex> lock(m_LockMapChanExt);
	CChanExten* pExten = NULL;
	m_MapChanExt.Lookup(ExtenNo, pExten);
	return pExten;
}

/*****************************************************************
**【函数名称】	getTrunk
**【函数功能】	查找中继
**【参数】
**【返回值】
****************************************************************/
CChanTrunk* CFsProxy::getTrunk(UINT TrunkNo)
{
	std::lock_guard<std::mutex> lock(m_LockArrayTrunk);
	if (TrunkNo <= 0 || TrunkNo > (UINT)m_ArrayTrunk.GetCount())
		return NULL;

	--TrunkNo;
	return m_ArrayTrunk[TrunkNo];
}

/*****************************************************************
**【函数名称】	delChan
**【函数功能】	删除通道
**【参数】
**【返回值】
****************************************************************/
void CFsProxy::delChan(CVirtualChan* pChan)
{
	if (pChan->type() == DEV_RES_TYPE_EXT)
		__delExten(pChan->no());
}

/*****************************************************************
**【函数名称】	getFreeTrunk
**【函数功能】	查找空闲中继
**【参数】
**【返回值】
****************************************************************/
CChanTrunk* CFsProxy::getFreeTrunk(void)
{
	// 当前轮循到的索引
	static int PosStatic = 0;
	int CurPos = PosStatic;
	int BusyTruckCount = 0;
	std::lock_guard<std::mutex> lock(m_LockArrayTrunk);
	// 保证遍历一轮
	for (int i = 0; i < m_ArrayTrunk.GetCount(); ++i)
	{
		// 保证POS是有效的
		if (PosStatic >= m_ArrayTrunk.GetCount())
			PosStatic = 0;

		CChanTrunk* pTrunk = m_ArrayTrunk[PosStatic++];
		ASSERT(pTrunk != NULL);

		// 当前外线是否空闲
		if (pTrunk->isFree())
		{
			return pTrunk;
		}
		else
		{
			BusyTruckCount++;
		}
	}
	LOGGER(LOG_LEVEL_WARNING, _T("{FsProxy}: 没有空闲中继通道,起始索引=%d,当前索引=%d,中继总数量=%d,忙通道数量=%d"), CurPos, PosStatic, m_ArrayTrunk.GetCount(), BusyTruckCount);

	//2019.3.7
	PosStatic = CurPos;
	for (int i = 0; i < m_ArrayTrunk.GetCount(); ++i)
	{
		// 保证POS是有效的
		if (PosStatic >= m_ArrayTrunk.GetCount())
			PosStatic = 0;

		CChanTrunk* pTrunk = m_ArrayTrunk[PosStatic++];
		ASSERT(pTrunk != NULL);

		// 当前外线是否空闲
		if (pTrunk->state() == CHAN_LOGIC_STATE_FREE)
		{
			if (pTrunk->currOp() != NULL) {
				COperationReactor::GetInstance().releaseOpResult(pTrunk->currOp());
				pTrunk->releaseOp(pTrunk->currOp());

				LOGGER(LOG_LEVEL_WARNING, _T("{FsProxy}:没有空闲中继通道,通道[%u],释放操作."), pTrunk->no());
			}
			return pTrunk;
		}
	}
	LOGGER(LOG_LEVEL_WARNING, _T("{FsProxy}: 没有空闲中继通道,起始索引=%d,当前索引=%d"), CurPos, PosStatic);


	return NULL;
}

/*****************************************************************
**【函数名称】	getAssoChanInSession
**【函数功能】	获取会话中关联通道
**【参数】
**【返回值】
****************************************************************/
CVirtualChan* CFsProxy::getAssoChanInSession(CVirtualChan* pChan)
{
	CSession* pSession = __getSession(pChan->sessionId());
	if (pSession != NULL)
		return pSession->getAssoChan(pChan);
	else
		return NULL;
}

/*****************************************************************
**【函数名称】	getBusyChan
**【函数功能】	获取忙通道
**【参数】
**【返回值】
*****************************************************************/
CVirtualChan* CFsProxy::getBusyChan(LPCTSTR ChanId)
{
	std::lock_guard<std::mutex> lock(m_LockMapBusyChan);
	CVirtualChan* pBusyChan = NULL;
	m_MapBusyChan.Lookup(ChanId, pBusyChan);
	return pBusyChan;
}

/*****************************************************************
**【函数名称】	regBusyChan
**【函数功能】	登记忙通道
**【参数】
**【返回值】
*****************************************************************/
void CFsProxy::regBusyChan(CVirtualChan* pChan)
{
	std::lock_guard<std::mutex> lock(m_LockMapBusyChan);
	m_MapBusyChan.SetAt(pChan->chanId(), pChan);
}

/*****************************************************************
**【函数名称】	unregBusyChan
**【函数功能】	取消登记忙通道
**【参数】
**【返回值】
*****************************************************************/
void CFsProxy::unregBusyChan(CVirtualChan* pChan)
{
	std::lock_guard<std::mutex> lock(m_LockMapBusyChan);
	m_MapBusyChan.RemoveKey(pChan->chanId());
}

/*****************************************************************
**【函数名称】	ExtenCall
**【函数功能】	分机呼叫
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::ExtenCall(LONG JobId, CVirtualChan* pChan, LPCTSTR CallerNum, LPCTSTR CalleeNum, LPCTSTR CalleeHeader)
{
	CString EslCmd;
	
	CString Called;
	Called = CalleeNum;
	if (0 != strcmp(CalleeHeader, "")) {
		Called = Called.Mid(strlen(CalleeHeader), Called.GetLength());
	}
	EslCmd.Format(_T("bgapi originate {origination_caller_id_number=%s,%s=%lu,absolute_codec_string='PCMA,PCMU'}user/%lu %s XML %s\r\n%s: %ld"),
		Called, ESL_VAR_OP_CALLER, pChan->no(), pChan->no(), CalleeNum, CConfig::extContext(), ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}
/*
CString CalleeHeader = tEvent->szCalleeHeader;           //号码前缀
		m_strCalleeNum = tEvent->szCalleeNum;					// 被叫号码
		if (0 != strcmp(CalleeHeader, ""))                       //如果有号码前缀，则剔除前缀保存真实号码
		{
			m_strCalleeNum = m_strCalleeNum.Mid(CalleeHeader.GetLength(), m_strCalleeNum.GetLength());
		}
*/
/*****************************************************************
**【函数名称】	PredictionCall
**【函数功能】	预测外呼
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::PredictionCall(LONG JobId, CString CallerNum, CString CalleeNum)
{
	CString CallString;
	if (!m_CallStringMaker.makeCallStringWithDefault(CallerNum, CalleeNum, CallString))
		return false;

	CString EslCmd;
	EslCmd.Format(_T("bgapi originate {origination_caller_id_number=%s,%s=%ld}%s %s XML %s\r\n%s: %ld"),
		CallerNum, ESL_VAR_OP_INSTANCE, JobId, CallString, CalleeNum, CConfig::pCallContext(), ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	answer
**【函数功能】	应答通道
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::answer(LONG JobId, CVirtualChan* pChan)
{
	return false;
}

/*****************************************************************
**【函数名称】	kill
**【函数功能】	挂断通道
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::kill(LONG JobId, CVirtualChan* pChan)
{
	return __kill(JobId, pChan->chanId());
}

/*****************************************************************
**【函数名称】	consult
**【函数功能】	协商呼叫
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::consult(LONG JobId, CVirtualChan* pChan, CString DestNum)
{
	CString CallerNum;
	CString CallString;
	if (!m_CallStringMaker.makeCallString(CallerNum, DestNum, CallString))
		return false;

	CString EslCmd;
	EslCmd.Format(_T("bgapi uuid_broadcast %s att_xfer::%s\r\n%s: %ld"), pChan->chanId(), CallString, ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	insert
**【函数功能】	强插
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::insert(LONG JobId, CVirtualChan* pChan, LPCTSTR DestSessionId)
{
	CString EslCmd;
	/*EslCmd.Format(_T("bgapi originate {origination_caller_id_number=%lu}user/%lu &three_way(%s)\r\n%s: %ld"),
		pChan->no(), pChan->no(), DestSessionId, ESL_HEADER_JOB_UUID, JobId);*/
	EslCmd.Format(_T("bgapi originate {origination_caller_id_number=%lu,absolute_codec_string='PCMA,PCMU'}user/%lu &three_way(%s)\r\n%s: %ld"),
		pChan->no(), pChan->no(), DestSessionId, ESL_HEADER_JOB_UUID, JobId);
	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	intercept
**【函数功能】	强截
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::intercept(LONG JobId, CVirtualChan* pChan, LPCTSTR DestChanId)
{
	CString EslCmd;
	/*EslCmd.Format(_T("bgapi originate {origination_caller_id_number=%lu}user/%lu &intercept(%s)\r\n%s: %ld"),
		pChan->no(), pChan->no(), DestChanId, ESL_HEADER_JOB_UUID, JobId);*/
	EslCmd.Format(_T("bgapi originate {origination_caller_id_number=%lu,absolute_codec_string='PCMA,PCMU'}user/%lu &intercept(%s)\r\n%s: %ld"),
		pChan->no(), pChan->no(), DestChanId, ESL_HEADER_JOB_UUID, JobId);
	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	listen
**【函数功能】	监听
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::listen(LONG JobId, CVirtualChan* pChan, LPCTSTR DestChanId)
{
	CString EslCmd;
	/*EslCmd.Format(_T("bgapi originate {origination_caller_id_number=%lu}user/%lu &eavesdrop(%s)\r\n%s: %ld"),
		pChan->no(), pChan->no(), DestChanId, ESL_HEADER_JOB_UUID, JobId);*/
	EslCmd.Format(_T("bgapi originate {origination_caller_id_number=%lu,absolute_codec_string='PCMA,PCMU'}user/%lu &eavesdrop(%s)\r\n%s: %ld"),
		pChan->no(), pChan->no(), DestChanId, ESL_HEADER_JOB_UUID, JobId);
	return m_Gateway.sendCmd(EslCmd);
}

// ych
std::string CFsProxy::EslCommand(std::string strFsIp, int FsPort, std::string strName, std::string strPsWd, std::string strCommand)
{
	if (!m_EslHandle.connected)
	{
		esl_connect(&m_EslHandle, strFsIp.c_str(), FsPort, strName.c_str(), strPsWd.c_str());
	}

	if (m_EslHandle.connected)
	{
		esl_send_recv_timed(&m_EslHandle, strCommand.c_str(), 2000);
		if (m_EslHandle.last_sr_event && m_EslHandle.last_sr_event->body)
		{
			std::string strRet = m_EslHandle.last_sr_event->body;
			return strRet;
		}
	}
	return "";
}

/*****************************************************************
**【函数名称】	meeting
**【函数功能】	会议
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::meeting(LONG JobId, CString CallerNum, CString DestNum, LPCTSTR MeetingId)
{
	
	bool bMatchPrefix = m_CallStringMaker.isMatchPrefix(DestNum);
	TRUNK_MATCH* pMatch = NULL;
	CString CallString;
	if (!m_CallStringMaker.makeCallString(CallerNum, DestNum, CallString, pMatch))
		return false;

	if (pMatch != NULL)
	{
		SIP_ACCOUNT* pAccount = CConfig::sipAccount().getAccount(pMatch->TrunkItemId);
		if (bMatchPrefix && pAccount != NULL && pAccount->IsDynamicGw) // 外线且动态网关
		{
			std::string strSipAccount = pAccount->Account;
			std::string strGwIp = EslCommand(CConfig::fsAddr(), CConfig::fsPort(), "", CConfig::fsPwd(), "api sofia_contact " + strSipAccount);
			if (!strGwIp.empty())
			{
				size_t Index = strGwIp.find_first_of('@');
				if (Index != std::string::npos)
				{
					strGwIp = strGwIp.substr(Index);
					CallString = "sofia/internal/";
					CallString += DestNum;
					CallString += strGwIp.c_str();
				}
			}
		}
	}
	
	LOGGER(LOG_LEVEL_NORMAL, _T("{FsProxy}: 三方会议呼叫字符串: %s"), CallString);

	CString EslCmd;
	EslCmd.Format(_T("bgapi originate {origination_caller_id_name=%s,origination_caller_id_number=%s,%s=%ld,absolute_codec_string='PCMA,PCMU'}%s %s XML %s\r\n%s: %ld"),
		CallerNum,CallerNum, ESL_VAR_OP_INSTANCE, JobId, CallString, MeetingId, CConfig::meetingContext(), ESL_HEADER_JOB_UUID, JobId);
	LOGGER(LOG_LEVEL_NORMAL, _T("{FsProxy}: 三方会议呼叫字符串: %s"), EslCmd);
	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	muteOn
**【函数功能】	静音
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::muteOn(LONG JobId, CVirtualChan* pChan)
{
	CString EslCmd;
	EslCmd.Format(_T("bgapi uuid_audio %s start write mute -4\r\n%s: %ld"), pChan->chanId(), ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	muteOff
**【函数功能】	取消静音
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::muteOff(LONG JobId, CVirtualChan* pChan)
{
	CString EslCmd;
	EslCmd.Format(_T("bgapi uuid_audio %s stop write mute -4\r\n%s: %ld"), pChan->chanId(), ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	holdon
**【函数功能】	保持
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::holdon(LONG JobId, CVirtualChan* pChan)
{
	CString EslCmd;
	EslCmd.Format(_T("bgapi uuid_hold %s\r\n%s: %ld"), pChan->chanId(), ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	takeBack
**【函数功能】	接回
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::takeBack(LONG JobId, CVirtualChan* pChan)
{
	CString EslCmd;
	EslCmd.Format(_T("bgapi uuid_hold off %s\r\n%s: %ld"), pChan->chanId(), ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	record
**【函数功能】	录音
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::record(LONG JobId, CVirtualChan* pChan, LPCTSTR RcdFile)
{
	CString EslCmd;
	EslCmd.Format(_T("bgapi uuid_record %s start %s\r\n%s: %ld"), pChan->chanId(), RcdFile, ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	transfer
**【函数功能】	呼叫转移
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::transfer(LONG JobId, CVirtualChan* pChan, LPCTSTR DestNum)
{
	CString Param;
	Param.Format(_T("ringback=${us-ring}"));
	//Param.Format(_T("ringback=$${sound_prefix}\\ringback.mp3"));
	m_Gateway.Execte2(ESL_APP_SET, Param, pChan->chanId());

	CString EslCmd;
	EslCmd.Format(_T("bgapi uuid_transfer %s %s xml %s\r\n%s: %ld"), pChan->chanId(), DestNum, CConfig::extContext(), ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

/*****************************************************************
**【函数名称】	transfer2Context
**【函数功能】	转移通道至其它Context
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::transfer2Context(LONG JobId, LPCTSTR DestChanId, LPCTSTR Exten, LPCTSTR Context, bool BothSide /*= false*/)
{
	CString EslCmd;
	if (BothSide)
		EslCmd.Format(_T("bgapi uuid_transfer %s -both %s xml %s\r\n%s: %ld"), DestChanId, Exten, Context, ESL_HEADER_JOB_UUID, JobId);
	else
		EslCmd.Format(_T("bgapi uuid_transfer %s %s xml %s\r\n%s: %ld"), DestChanId, Exten, Context, ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

bool CFsProxy::transfer2Context(LONG JobId, LPCTSTR DestChanId, LPCTSTR Exten, LPCTSTR Context, LPCTSTR CallId, bool BothSide)
{
	CString Param;
	Param.Format(_T("call_id=%s"), CallId);
	m_Gateway.Execte2(ESL_APP_SET, Param, DestChanId);
	CString EslCmd;
	if (BothSide)
		EslCmd.Format(_T("bgapi uuid_transfer %s -both %s xml %s\r\n%s: %ld"), DestChanId, Exten, Context, ESL_HEADER_JOB_UUID, JobId);
	else
		EslCmd.Format(_T("bgapi uuid_transfer %s %s xml %s\r\n%s: %ld"), DestChanId, Exten, Context, ESL_HEADER_JOB_UUID, JobId);

	return m_Gateway.sendCmd(EslCmd);
}

bool CFsProxy::setChannelVariable(LONG JobId, LPCTSTR DestChanId, LPCTSTR VarName, LPCTSTR Content)
{
	CString EslCmd;
	EslCmd.Format(_T("bgapi uuid_setvar %s %s %s\r\n%s: %ld"), DestChanId, VarName, Content, ESL_HEADER_JOB_UUID, JobId);
	bool ret = m_Gateway.sendCmd(EslCmd);
	return ret;
}

bool CFsProxy::ExecteApp(LPCTSTR App, LPCTSTR Param, LPCTSTR ChanId)
{
	return m_Gateway.Execte2(App, Param, ChanId);
}

bool CFsProxy::sendDtmf(LONG JobId, LPCTSTR DestChanId, LPCTSTR Content)
{
	CString EslCmd;
	EslCmd.Format(_T("bgapi uuid_send_dtmf %s %s\r\n%s: %ld"), DestChanId, Content, ESL_HEADER_JOB_UUID, JobId);
	bool ret = m_Gateway.sendCmd(EslCmd);
	return ret;
}

bool CFsProxy::setConferencePlay(LONG JobId, LPCTSTR MeetingId, LPCTSTR MemberId, bool isPlay)
{
	CString EslCmd;
	if (isPlay)
		//EslCmd.Format(_T("bgapi conference %s play local_stream://moh %s\r\n%s: %ld"), MeetingId, MemberId, ESL_HEADER_JOB_UUID, JobId);
		EslCmd.Format(_T("bgapi conference %s play local_stream://moh %s"), MeetingId, MemberId);
	else
		EslCmd.Format(_T("bgapi conference %s stop all %s\r\n%s: %ld"), MeetingId, MemberId, ESL_HEADER_JOB_UUID, JobId);
	LOGGER(LOG_LEVEL_NORMAL, _T("{CFsProxy}: 执行会议放音命令[%s]"), EslCmd);
	bool ret = m_Gateway.sendCmd(EslCmd);
	return ret;
}

bool CFsProxy::getConferenceMemberId(LPCTSTR MeetingId, LPCTSTR ChanId, CString &MemberId)
{
	return m_Gateway.getConferenceMemberId(MeetingId, ChanId, MemberId);
}

bool CFsProxy::setConferenceExitSound(LPCTSTR MeetingId, bool isPlay)
{
	CString EslCmd;
	if (isPlay)
		EslCmd.Format(_T("bgapi conference %s exit_sound on"), MeetingId);
	else
		EslCmd.Format(_T("bgapi conference %s exit_sound off"), MeetingId);
	LOGGER(LOG_LEVEL_NORMAL, _T("{CFsProxy}: 设置会议人员离开是否播放声音[%s]"), EslCmd);
	bool ret = m_Gateway.sendCmd(EslCmd);
	return ret;
}

bool CFsProxy::setConferenceIsMute(LONG JobId, LPCTSTR MeetingId, LPCTSTR MemberId, bool isMute)
{
	CString EslCmd;
	if (isMute)
	{
		EslCmd.Format(_T("bgapi conference %s deaf %s"), MeetingId, MemberId);
		m_Gateway.sendCmd(EslCmd);
		EslCmd.Format(_T("bgapi conference %s mute %s\r\n%s: %ld"), MeetingId, MemberId, ESL_HEADER_JOB_UUID, JobId);
	}
	else
	{
		EslCmd.Format(_T("bgapi conference %s undeaf %s"), MeetingId, MemberId);
		m_Gateway.sendCmd(EslCmd);
		EslCmd.Format(_T("bgapi conference %s stop all %s"), MeetingId, MemberId);
		m_Gateway.sendCmd(EslCmd);
		EslCmd.Format(_T("bgapi conference %s unmute %s\r\n%s: %ld"), MeetingId, MemberId, ESL_HEADER_JOB_UUID, JobId);
	}
	LOGGER(LOG_LEVEL_NORMAL, _T("{CFsProxy}: 设置会议人员是否静音[%s]"), EslCmd);
	bool ret = m_Gateway.sendCmd(EslCmd);
	return ret;
}

/*****************************************************************
**【函数名称】	cancel
**【函数功能】	取消当前执行的应用
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::cancel(CChanTrunk* pChan)
{
	ASSERT(pChan != NULL);
	return m_Gateway.Execte2(ESL_APP_BREAK, NULL, pChan->chanId());
}

/*****************************************************************
**【函数名称】	hangup
**【函数功能】	挂机
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::hangup(CChanTrunk* pChan)
{
	ASSERT(pChan != NULL);
	return m_Gateway.execute(pChan->m_pEslHandle, ESL_APP_HANGUP, NULL);
}

/*****************************************************************
**【函数名称】	leaveWord
**【函数功能】	留言
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::leaveWord(CChanTrunk* pChan, LPCTSTR FileName, UINT LimitTime, TCHAR FinishKey)
{
	ASSERT(pChan != NULL);
	CString Param;
	Param.Format(_T("playback_terminators=%c"), FinishKey);
	m_Gateway.Execte2(ESL_APP_SET, Param, pChan->chanId());
	Param.Format(_T("%s %lu"), FileName, LimitTime);
	return m_Gateway.Execte2(ESL_APP_LEAVEWORD, Param, pChan->chanId());
}

/*****************************************************************
**【函数名称】	playAndDtmf
**【函数功能】	放音收按键
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::playAndDtmf(CChanTrunk* pChan, PlayVoiceContent* pPlayContent)
{
	ASSERT(pChan != NULL);
	ASSERT(pPlayContent != NULL);
	if (pChan == NULL || pPlayContent == NULL) return false;

	TCHAR AudioFile[MAX_PATH] = { 0 };
	// 如果使用了TTS，进行TTS转换
	switch (pPlayContent->nTts)
	{
	default:
	case PLAY_CONTENT_AUDIO:			// 不使用TTS
		lstrcpy(AudioFile, pPlayContent->szFileName);
		break;

	case PLAY_CONTENT_TTS_STR:			// TTS文本
	{
		ITtsInterface::getInstance().setTTSParam(pPlayContent->nTtsDigitMode, pPlayContent->nTtsSpeed, pPlayContent->nTtsVolume);
		if (!ITtsInterface::getInstance().string2Audio(pPlayContent->szFileName, AudioFile, MAX_PATH))
		{
			LOGGER(LOG_LEVEL_WARNING, _T("{FsProxy}: 中继通道[%lu]放音时TTS文本转换失败"), pChan->no());
			return false;
		}
	}
	break;

	case PLAY_CONTENT_TTS_FILE:			// TTS文件
	{
		ITtsInterface::getInstance().setTTSParam(pPlayContent->nTtsDigitMode, pPlayContent->nTtsSpeed, pPlayContent->nTtsVolume);
		if (!ITtsInterface::getInstance().file2Audio(pPlayContent->szFileName, AudioFile, MAX_PATH))
		{
			LOGGER(LOG_LEVEL_WARNING, _T("{FsProxy}: 中继通道[%lu]放音时TTS文件转换失败, File = %s"), pChan->no(), pPlayContent->szFileName);
			return false;
		}
	}
	break;
	}



	CString Param;
	if (pPlayContent->nModel == PVM_PLAY_ONLY && pPlayContent->cDtmfEnd == 0)
	{
		Param.Format(_T("playback_terminators=none"));
		m_Gateway.Execte2(ESL_APP_SET, Param, pChan->chanId());
		//m_Gateway.execute(pChan->m_pEslHandle,ESL_APP_SET,Param);
		Param.Format(_T("%s"), AudioFile);
		return m_Gateway.Execte2(ESL_APP_PLAY, Param, pChan->chanId());
		//return m_Gateway.execute(pChan->m_pEslHandle,ESL_APP_PLAY,Param);
	}
	else
	{
		Param.Format(_T("%lu %lu %d %lu %c %s silence_stream://250 %s"),1 /*pPlayContent->nDtmfCount*/, pPlayContent->nDtmfCount,pPlayContent->nPlayCount,
			pPlayContent->nDtmfCount * pPlayContent->nDtmfPeriod * 1000, pPlayContent->cDtmfEnd, AudioFile, ESL_VAR_DTMF_KEY);
		return m_Gateway.Execte2(ESL_APP_PLAY_DTMF, Param, pChan->chanId());
		//return m_Gateway.execute(pChan->m_pEslHandle,ESL_APP_PLAY_DTMF,Param);
	}
}

/*****************************************************************
**【函数名称】	bridge
**【函数功能】	桥接通道
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::bridge(CChanTrunk* pChan, CString CallerNum, CString CalleeNum)
{
	CString CallString;
	if (!m_CallStringMaker.makeCallString(CallerNum, CalleeNum, CallString))
		return false;
	CString Param;
	Param.Format(_T("ringback=${us-ring}"));
	m_Gateway.Execte2(ESL_APP_SET, Param, pChan->chanId());
	return m_Gateway.Execte2(ESL_APP_BRIDGE, CallString, pChan->chanId());
}

/*****************************************************************
**【函数名称】	bridge
**【函数功能】	桥接通道  动态网关方法
**【参数】
**【返回值】
****************************************************************/
bool CFsProxy::bridge(CChanTrunk* pChan, CString CalleeNum)
{
	CString EslCmd;
	EslCmd.Format(_T("bgapi uuid_transfer %s %s xml %s"), pChan->chanId(), CalleeNum, CConfig::extContext());
	return m_Gateway.sendCmd(EslCmd);
}