myvtm/Module/mod_counterconnector/ConnectorFSM.cpp

#include "stdafx.h"
#include "ConnectorFSM.h"
#include "EventCode.h"
#include "json/json.h"

#define RELEASEING_TIMER_INTERVAL	1200
#define RELEASEING_SIP_TIMER		20000
#define SIP_CALL_TIMER				70000  //sip呼叫超时时间，20170314，增加超时时间解决坐席忽闪问题
#define RELEASEING_SIP_TIMEOUT      30000
#define SIP_CONNECT_FAIL_TIMES       10
#define LIVEDETECT_CONNECT_INTERVAL	5000   //live detection实体检测间隔5s
#define LIVEDETECTION_TIMEOUT		60000  //活体检测超时时间60s
#define CALLROUTE_MAX_TRY_COUNT		3

#ifndef MAX_PATH
#define MAX_PATH 260
#endif

#ifndef RVC_CALLROUTE_HTTP_API
#define RVC_CALLROUTE_HTTP_API "/api/route/query"
#endif // !RVC_CALLROUTE_HTTP_API


static const char* connect_failed_case_table[] = {
	"",
	"[RTA3401] 连线失败，请检查网络",
	"[RTA3402] 坐席忙，请稍后再试",
	"[RTA3403] 声卡故障，请使用话筒重新办理",
	"[RTA3404] 声卡故障，请使用免提重新办理",
	"[RTA3405] 连线失败，系统忙，请稍后再试",
	"[RTA3406] 连接坐席失败，系统忙，请稍后再试",
	"[RTA3407] 连线失败，服务端异常，请稍后再试"
};

static const char* connect_failed_rtamsg_table[] = {
	"",
	"RTA3401",
	"RTA3402",
	"RTA3403",
	"RTA3404",
	"RTA3405",
	"RTA3406",
	"RTA3407"
};


class  SyncServiceClient:public SyncService_ClientBase
{
public:
	SyncServiceClient(CEntityBase *pEntity, ACMCallFSM* fsm) : SyncService_ClientBase(pEntity), m_fsm(fsm) {}
	ACMCallFSM *m_fsm;
};


class MyPhoneClient : public PhoneService_ClientBase
{
public:
	MyPhoneClient(CEntityBase *pEntity, ACMCallFSM* fsm) : PhoneService_ClientBase(pEntity), m_fsm(fsm) {m_bSipConnected = false;}
	virtual void OnMessage(ErrorCodeEnum Error, PhoneService_PhoneState_Info &Msg, CSmartPointer<IReleasable> pData)
	{
		if (Error == Error_Succeed) {
			switch (Msg.state) {
			case ePhone_Init:
			case ePhone_Terminated:
				{
					FSMEvent *e = new FSMEvent(USER_EVT_SIP_STATE_IDLE);
					m_fsm->PostEventFIFO(e);
				}
				break;
			case ePhone_Ready:
				{
					FSMEvent *e = new FSMEvent(USER_EVT_SIP_STATE_CONNECTED);
					m_fsm->PostEventFIFO(e);
					m_bSipConnected = true;
				}
				break;
			case ePhone_Calling:
				{
					m_bSipConnected = false;
				}
				break;
			default:
				break;
			}

			if (ePhone_Terminated == Msg.state){
				if (!m_bSipConnected){
					LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_SIP_CONNECT_FAILED, CSimpleStringA::Format("sip connect failed for %s.", Msg.status.GetData()).GetData());
				}
			}
		}
	}

public:
	ACMCallFSM *m_fsm;
	int m_bSipConnected;
};

class MyChannelClient : public ChannelService_ClientBase
{
public:
	MyChannelClient(CEntityBase *pEntity, ACMCallFSM* fsm) : ChannelService_ClientBase(pEntity), m_fsm(fsm) {}
	virtual void OnMessage(ErrorCodeEnum Error, ChannelService_State_Info &Msg, CSmartPointer<IReleasable> pData)
	{
		if (Error == Error_Succeed) {
			switch (Msg.state) {
			case eChannelState_Idle:
				{
					FSMEvent *e = new FSMEvent(USER_EVT_CHAN_STATE_IDLE);
					m_fsm->PostEventFIFO(e);
				}
				break;
			case eChannelState_Connected:
				{
					FSMEvent *e = new ChanStateConnectedEvent(Msg.param);
					m_fsm->PostEventFIFO(e);
				}
				break;
			default:
				break;
			}
		}
	}
	ACMCallFSM *m_fsm;
};



ACMCallFSM::ACMCallFSM()
	: m_pPhoneClient(NULL), m_pChannelClient(NULL), m_bRing(false),m_iFailedLastState(0)
{
	m_nCurSipServer = CurServerNum::MAIN_SERVER;
	m_nCurChanServer = CurServerNum::MAIN_SERVER;
	m_iNetAdapterNum = 1;
	m_pSyncServiceClient = NULL;
	m_bConAssist = false;
	m_bConSipphone = false;
	memset(m_strChanProxyIP, 0, sizeof(m_strChanProxyIP));
	memset(m_iChanProxyPort, 0, sizeof(m_iChanProxyPort));
	m_pCallRouteList = NULL;
	m_strDefaultServer = NULL;
	m_strHttpCallRouteAddr = NULL;
	m_strHttpServerAPI = RVC_CALLROUTE_HTTP_API;
	m_strQueueName = NULL;
	m_strAddClientLevel = NULL;
	m_LastSipError = Error_Succeed;
	m_LastAssistError = Error_Succeed;
	m_bNeedQueueName = false;
	m_iHttpTimeOut = RVC_DEFAULT_HTTPTIMEOUT;
	m_bHttpPrinttDbg = false;
}


ACMCallFSM::~ACMCallFSM()
{

}


ErrorCodeEnum ACMCallFSM::OnInit()
{
	ErrorCodeEnum Error = LoadConfig();
	int iCount = 0;

	if (Error != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("on_error");
		FSMEvent* e = new FSMEvent(USER_EVT_ERROR);
		PostEventFIFO(e); // jump to error state
		return Error;
	}
		
	GetEntityBase()->GetFunction()->SetSysVar("CallState", "O"); // set to offline state 
	Error = LoadTerminalId();
	if (Error != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("on_error");
		FSMEvent* e = new FSMEvent(USER_EVT_ERROR);
		PostEventFIFO(e); // jump to error state
		return Error;
	}

	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_strDefaultServer %s.", m_strDefaultServer.GetData());
	if(m_strDefaultServer.GetLength() > 0){
		iCount = ParseDefaultServer(m_strDefaultServer.GetData());
	}
	char strbuf[2 * MAX_PATH] = { 0 };
	snprintf(strbuf, 2 * MAX_PATH, "%s", RVC_DEFAULT_VOIPSERVER_ADDR);
	if (0 == iCount) {
		ParseDefaultServer(strbuf);
	}

	m_bHangup = false;
	m_bHandFree = true;
	m_bAgentHandFree = true;
	m_bIsAgentControl = false;
	m_nSipErrorNum = 0;
	memset(&m_CallingParam, 0, sizeof(m_CallingParam));
	m_uConnectTime = 0;
	m_bConnected = false;
	m_lConnectCostTime = 0;

	AddStateHooker(this);

	return Error;
}

bool ACMCallFSM::ReConnectionAssistchan()
{
	if (m_pChannelClient != NULL){
		m_pChannelClient->GetFunction()->CloseSession();
#ifdef RVC_OS_WIN
		m_pChannelClient->SafeDelete();
#endif
		m_pChannelClient = NULL;
	}

	if (m_pChannelClient == NULL){
		m_pChannelClient = new MyChannelClient(m_pEntity, this);
		ErrorCodeEnum Error = m_pChannelClient->Connect();
		if (Error != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_channelClient connect fail!");
#ifdef RVC_OS_WIN
			m_pChannelClient->SafeDelete();
#endif
			m_pChannelClient = NULL;
			return false;
		}

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

bool ACMCallFSM::ReConnectionSipphone(bool bLog)
{
	if (m_pPhoneClient != NULL){
		m_pPhoneClient->GetFunction()->CloseSession();
#ifdef RVC_OS_WIN
		m_pPhoneClient->SafeDelete();
#endif
		m_pPhoneClient = NULL;
	}

	if (m_pPhoneClient == NULL){
		m_pPhoneClient = new MyPhoneClient(m_pEntity, this);
		ErrorCodeEnum Error = m_pPhoneClient->Connect();
		if (Error != Error_Succeed) {
			if (bLog) {
				LogWarn(Severity_Low, Error_Debug, EVENT_MOD_CONNECT_SIPPHONE_ERROR, "connect sip phone error");
			}
#ifdef RVC_OS_WIN
			m_pPhoneClient->SafeDelete();
#endif
			m_pPhoneClient = NULL;
			return false;
		}

		if (Error == Error_Succeed)
		{
			PhoneService_BeginState_Sub PhoneSub;
			Error = (*m_pPhoneClient)(EntityResource::getLink().upgradeLink())->BeginState(PhoneSub);
			if (Error != Error_Succeed) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("BeginState sip failed!");
				m_pPhoneClient->GetFunction()->CloseSession();
#ifdef RVC_OS_WIN
				m_pPhoneClient->SafeDelete();
#endif			
				m_pPhoneClient = NULL;
				return false;
			}
		}
	}
	return true;
}


bool ACMCallFSM::ReConnectionSyncService()
{
	if (NULL != m_pSyncServiceClient){
		m_pSyncServiceClient->GetFunction()->CloseSession();
#ifdef RVC_OS_WIN
		m_pSyncServiceClient->SafeDelete();
#endif	
		m_pSyncServiceClient = NULL;
	}

	m_pSyncServiceClient = new SyncServiceClient(m_pEntity, this);
	ErrorCodeEnum Error = m_pSyncServiceClient->Connect();
	if (Error_Succeed != Error){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Connect SyncService Fail!");
#ifdef RVC_OS_WIN
		m_pSyncServiceClient->SafeDelete();
#endif
		m_pSyncServiceClient = NULL;
		return false;
	}

	return true;
}

int ACMCallFSM::GetCallRouteList()
{
	int iret = -1;

	if (m_strHttpCallRouteAddr.GetLength() != 0) {
		int ihttpcount = 0;
		http_call_info_t http_callinfo;
		http_callinfo.strServerURL = m_strHttpCallRouteAddr;
		http_callinfo.strAPI = m_strHttpServerAPI;

		if (m_bNeedQueueName) {
			http_callinfo.strQueueName = m_strQueueName;
			http_callinfo.strAddClientLevel = m_strAddClientLevel;
		}
		else {
			http_callinfo.strQueueName = NULL;
			http_callinfo.strAddClientLevel = NULL;
		}

		LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_CALL_QUEUE_INFO, CSimpleStringA::Format("call type is %d, http call route queue name is %s, and client level is %s.", m_CallingParam.nCallType, http_callinfo.strQueueName.GetData(), http_callinfo.strAddClientLevel.GetData()).GetData());

		http_callinfo.strTerminalNo = m_strTerminalId;

		do {
			m_pCallRouteList = get_http_callroute_list(&http_callinfo, m_iHttpTimeOut, m_bHttpPrinttDbg);
			ihttpcount++;
		} while (!m_pCallRouteList && ihttpcount < CALLROUTE_MAX_TRY_COUNT);

		if (ihttpcount > 1) {
			LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_TIMES, CSimpleStringA::Format("request http call route address{%s} %d times.", m_strHttpCallRouteAddr.GetData(), ihttpcount).GetData());
		}
	}

	if (NULL != m_pCallRouteList) {
		iret = 0;                    
	}
	else {
		LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_FAILED, "call route request failed!");
	}

	return iret;
}


int ACMCallFSM::GetDelayTime()
{
	ErrorCodeEnum error= Error_Unexpect;
	SyncService_GetMachineData_Req req;
	req.key = "DelayTime";
	SyncService_GetMachineData_Ans ans;
	DWORD Timeout = 500;
	if (m_pSyncServiceClient)
	{
		error = (*m_pSyncServiceClient)(EntityResource::getLink().upgradeLink())->GetMachineData(req,ans,Timeout);
	}
	if (error == Error_Succeed)
	{
		int delaytime = atoi(ans.value.GetData());
		return delaytime;
	}
	else
	{
		return -1;
	}
}

void ACMCallFSM::SetDelayTime()
{
	if (m_pSyncServiceClient)
	{
		SyncService_SetMachineData_Info info;
		info.key = "DelayTime";
		info.data = "0";
		(*m_pSyncServiceClient)(EntityResource::getLink().upgradeLink())->SetMachineData(info);
		//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("set delay time to 0");
	}
}


static int CStringSplit(char* str, char** result, size_t ucount, const char* del)
{
	char* ptr = NULL;
	size_t unum = ucount;
#if defined(RVC_OS_WIN)
	char* p = strtok_s(str, del, &ptr);
	while (p != NULL && unum > 0) {
		*result++ = p;
		p = strtok_s(NULL, del, &ptr);
		unum--;
	}
#else
	char* p = strtok_r(str, del, &ptr);
	while (p != NULL && unum > 0) {
		*result++ = p;
		p = strtok_r(NULL, del, &ptr);
		unum--;
	}
#endif //RVC_OS_WIN
	return ucount - unum;
}


static int GetCallInfoFromConfig(char* strcallurl, uint32_t ucalllen, char* strassist, uint32_t assitlen, int *iport, const char* psrc)
{
	int iRet = -1;
	if (NULL == psrc || NULL == strcallurl || NULL == strassist){
		return iRet;
	}

	char *result[MAX_VOIP_SERVER_NUM] = {0};
	int icount = CStringSplit((char*)psrc, result, MAX_VOIP_SERVER_NUM, ",");
	if(2 == icount){
		snprintf(strcallurl, ucalllen, "%s", result[0]);
		char *assitresult[MAX_VOIP_SERVER_NUM] = {0};
		icount = CStringSplit(result[1], assitresult, MAX_VOIP_SERVER_NUM, " ");
		if(2 == icount){
			snprintf(strassist, assitlen, "%s", assitresult[0]);
			*iport = atoi(assitresult[1]);
			iRet = 0;
		}
	}
	return iRet;
}

/*无符号长整形转字符型*/
#if defined(RVC_OS_LINUX)
namespace
{
	char* _ultoa(unsigned long value, char* pstring, int radix)
	{
		char tmp[33] = { 0 };
		char* tp = tmp;
		long i;
		unsigned long v = value;
		char* sp;

		if (radix > 36 || radix <= 1 || NULL == pstring) {
			return 0;
		}

		while (v || tp == tmp) {
			i = v % radix;
			v = v / radix;
			if (i < 10)
				*tp++ = i + '0';
			else
				*tp++ = i + 'a' - 10;
		}

		sp = pstring;

		while (tp > tmp)
			*sp++ = *--tp;
		*sp = 0;
		return pstring;
	}
}
#endif //RVC_OS_LINUX

static int get_interger_netaddr(char *strbuf, size_t ubufszie, const char* szip)
{
	int ret = -1;

	unsigned long ulip = 0;
	if (NULL == strbuf || NULL == szip){
		return ret;
	}

	ulip = inet_addr(szip);
	_ultoa(ulip, strbuf, 10);

	ret = 0;
	return ret;
}

int ACMCallFSM::ParseDefaultServer(const char* strServer)
{
	int iRet = 0;

	if(NULL == strServer){
		return iRet;
	}

	char *result[MAX_VOIP_SERVER_NUM] = {0};
	int icount = CStringSplit((char*)strServer, result, MAX_VOIP_SERVER_NUM, "|");
	int index = 0;
	while(index < icount && result[index]){
		m_voipserver.push_back(result[index]);
		//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("result[%d] = [%s].", index, result[index]);
		index++;
	}

	iRet = m_voipserver.size();

	return iRet;
}


ErrorCodeEnum ACMCallFSM::OnExit()
{
	return Error_Succeed;
}


int ACMCallFSM::GetFailedErrorCode(int iSrcState)
{
	int iState = 0;
	if (s20 != iSrcState){
		switch (m_iFailedLastState) {
		case s11:
			if(Error_Succeed != m_LastSipError){
				iState = 5;
			}
			else{
				iState = 1;
			}
			break;

		case s12:
			if (Error_Succeed != m_LastAssistError){
				iState = 5;
			}
			else{
				iState = 2;
			}
			break;

		default:
			break;
		}
	}

	return iState;
}


int ACMCallFSM::LogFailedWarns(int iFailedCode, const char* strmsg)
{
	int iRet = 0;
	if (m_bHangup){
		LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_FAILED_USER_HANGUP, strmsg);
	}
	else{
		switch (iFailedCode) {
		case 1:
			LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_FAILED_NETWORK_FAILURE, strmsg);
			break;

		case 2:
			LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_FAILED_AGENT_BUSY, strmsg);
			break;

		case 5:
			if (s11 == m_iFailedLastState){
				LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_FAILED_SIPPHONE_LOST, strmsg);
			} 
			else if(s12 == m_iFailedLastState){
				LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_FAILED_ASSISTCHANNEL_LOST, strmsg);
			}
			break;

		default:
			break;
		}
	}

	return iRet;
}

void ACMCallFSM::OnStateTrans(int iSrcState, int iDstState)
{
	if (CheckBeginRing(iSrcState, iDstState)) {
		StartRing();
	} else {
		if (CheckEndRing(iSrcState, iDstState))
			StopRing();
	}

	if (iSrcState != FSM_STATE_INIT && iDstState != FSM_STATE_EXIT) {
		int st1 = TranslateState(iSrcState);
		int st2 = TranslateState(iDstState);

		if (eState_Fail == st2){
			m_iFailedLastState = iSrcState;
		}

		if (st1 != st2) {
			PhoneState evt;
			evt.state = st2;
			evt.status = CSimpleStringA::Format("OnStateTrans from state %d to %d", st1, st2);
			evt.errinfo = "";
			//LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_CALL_STATE_TRANS, evt.status.GetData());
			//LOG_TRACE(evt.status);
			if (!((st2 == eState_Fail)&&(m_nCurChanServer != CurServerNum::Error_Server)&&(m_nCurSipServer != CurServerNum::Error_Server))||m_bHangup)
			{
				if (eState_Fail != st1 || eState_Connecting != st2){
					//char strmsg[MAX_PATH] = {0};
					//snprintf(strmsg, MAX_PATH,"Broadcast state from %d to %d", st1, st2);
					//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(strmsg);

					if (eState_Fail == st2){
						int ierrcode = GetFailedErrorCode(iSrcState);
						//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("connect_failed_case_table size is %d, and ierrcode = %d.", sizeof(connect_failed_case_table)/ sizeof(char*), ierrcode);
						if (ierrcode >= 0 && ierrcode < sizeof(connect_failed_case_table)/ sizeof(char*)){
							evt.errinfo = CSimpleStringA2W(connect_failed_case_table[ierrcode]);
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("connect failed for %s.", CSimpleStringW2A(evt.errinfo).GetData());
							DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(connect_failed_rtamsg_table[ierrcode])(connect_failed_case_table[ierrcode]);
						}

						char strerrmsg[MAX_PATH] = {0};
						if (m_bHangup){
							snprintf(strerrmsg, MAX_PATH, "connect failed for %s and last state is %d, and current src state is %d.","接通前客户主动挂机", m_iFailedLastState, iSrcState);
						} 
						else{
							snprintf(strerrmsg, MAX_PATH, "connect failed for %s and last state is %d, and current src state is %d.",CSimpleStringW2A(evt.errinfo).GetData(), m_iFailedLastState, iSrcState);
						}
						LogWarn(Severity_Middle, Error_Debug, LOG_WARN_COUNTERCONNECT_CONNECT_FAILED, strerrmsg);
						
						LogFailedWarns(ierrcode, strerrmsg);
					}

					SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(PhoneState), SP_MSG_SIG_OF(PhoneState), evt);
					//LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_BROADCAST_CALL_STATE, strmsg);
				} 
				else{
					LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_AUTO_RECONNECT,CSimpleString::Format("state from %d to %d, auto reconnect, not broadcast state to ui.", st1, st2).GetData());
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402304C5")("system auto reconnect.");
				}

				if (eState_HandFree == st2 || eState_Pickup == st2){
					if (eState_Connecting == st1){
						LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_CONNECT_SUCCESS, "connect success!");
					}
				}
			}
			SetCallState(st2);    
		}
	}
}

ErrorCodeEnum ACMCallFSM::SetCallState(int state)
{
	char *sts[] = {
		"O", // Offline
		"C", // Connecting
		"H", // HandFree
		"P", // Pickup
		"B", // Broken
		"F", // Fail
		"R", // Releasing
		"L", // LiveDetect
		"V"  // Recording
	};

	char* strCallState = "O";
	if (0 <= state && state < sizeof(sts)/sizeof(char*)){
		strCallState = sts[state];
	}

	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("set call state to [%s].", strCallState);
	return GetEntityBase()->GetFunction()->SetSysVar("CallState", strCallState);
}

void ACMCallFSM::s0_on_entry() 
{
	m_strHintCallNum.Clear();
	m_nCurChanServer = CurServerNum::MAIN_SERVER;
	m_nCurSipServer = CurServerNum::MAIN_SERVER;
	memset(&m_CallingParam,0,sizeof(m_CallingParam));
	if(m_pCallRouteList != NULL){
		free_node_list(m_pCallRouteList);	
		m_pCallRouteList = NULL;
	}
	m_iFailedLastState = 0;
}

void ACMCallFSM::s0_on_exit() 
{
	m_bHangup = false;
}

unsigned int ACMCallFSM::s0_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_PICKUP_CALL) 
	{
		memset(&m_CallingParam,0,sizeof(m_CallingParam));  //正常呼叫
		LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_PICKUPCALL,"begin pickup call");
		m_nStarttime = y2k_time_now();
	} 
	else if (event->iEvt == USER_EVT_HANDFREE_CALL) 
	{
		memset(&m_CallingParam,0,sizeof(m_CallingParam));							// 正常呼叫
		LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_HANDFREECALL,"begin hand free call");
		m_nStarttime = y2k_time_now();
	}
	else if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	else if (event->iEvt == USER_EVT_STARTVIDEODISPLAY) 
	{
		StartVideoDisplayEvent *e = static_cast<StartVideoDisplayEvent *>(event);
#ifdef RVC_OS_WIN
		StartVideo(e->m_param.GetData());
#else
		StartVideoRender(e->m_param.GetData());
#endif
	}
	else if (event->iEvt == USER_EVT_SHOWLOACALVIDEO)
	{
		ShowLocalVideoEvent *e = static_cast<ShowLocalVideoEvent *>(event);
		SetCallingType(NORMAL_CALLTYPE);
#ifdef RVC_OS_WIN
		StartVideo(e->m_param.GetData());
#else
		StartVideoRender(e->m_param.GetData());
#endif
	}
	else if (event->iEvt == USER_EVT_SHOWLOACALREMOTEVIDEO)
	{
		ShowLocalAndRemoteVideoEvent *e = static_cast<ShowLocalAndRemoteVideoEvent *>(event);
		SetCallingType(NORMAL_CALLTYPE);
#ifdef RVC_OS_WIN
		StartVideo(e->m_param.GetData());
#else
		StartVideoRender(e->m_param.GetData());
#endif
	}
	else if (event->iEvt == USER_EVT_DOUBLE_RECORD_CALL)
	{
		m_CallingParam.nCallType = DOUBLERECORD_CALLTYPE;
		LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_DOUBLERECORDCALL,"begin double record call");
		m_nStarttime = y2k_time_now();
	}
	else if (event->iEvt == USER_EVT_STOPLOACALREMOTEVIDEO) 
	{
#ifdef RVC_OS_WIN
		StopVideo();
		SetCallingType(NORMAL_CALLTYPE);
#endif
	}
	return 0;
}

void ACMCallFSM::s7_on_entry() 
{
	
}

void ACMCallFSM::s7_on_exit() 
{

}

unsigned int ACMCallFSM::s7_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_STOPLOCALVIDEO) 
	{
		StopVideo();
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	return 0;
}

void ACMCallFSM::s8_on_entry() 
{
	//get call route,采用直接总行方式
	if (0 != GetCallRouteList()) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get call route list failed.");
	}

	m_lConnectCostTime = SP::Module::Comm::RVCGetTickCount();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402304C1")("start remote video call");

	int time = GetDelayTime();

	if (time > 0){
		ScheduleTimer(8,time*1000);
	}	
	else{
		PostEventFIFO(new FSMEvent(EVT_TIMER));
	}
}

void ACMCallFSM::s8_on_exit() 
{
	CancelTimer(8);
}

unsigned int ACMCallFSM::s8_on_event(FSMEvent* event)
{
	return 0;
}

void ACMCallFSM::s10_on_entry()
{
	ErrorCodeEnum Error = Error_Succeed;
	if (m_nCurSipServer == CurServerNum::Error_Server)
	{
		Error = Error_NetBroken;
	}

	if (Error != Error_Succeed) 
	{
		PostEventFIFO(new FSMEvent(USER_EVT_JMP_FAIL));
	}
}

void ACMCallFSM::s10_on_exit() {}

unsigned int ACMCallFSM::s10_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	else if (event->iEvt == USER_EVT_STOPLOACALREMOTEVIDEO) 
	{
		PostEventFIFO(new FSMEvent(USER_EVT_HANGUP));
		m_bHangup=true;
		StopVideo();
	}
	return 0;
}


void ACMCallFSM::s11_on_entry() 
{
	m_LastSipError = Error_Succeed;

	LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_MAKECALL,"begin make call");
	m_uConnectTime = y2k_time_now();
	m_bConnected = false;

	if (m_nCurSipServer == CurServerNum::Error_Server){
		m_LastSipError = Error_NetBroken;
	}

	if (m_LastSipError == Error_Succeed){
		char ipstr[MAX_PATH] = {0};
		GetLocalIP(ipstr, MAX_PATH);

		//get call route,采用直接总行方式
		callurl_node_t *node = get_no_used_node(m_pCallRouteList);

		char callid_str[64] = { 0 };
		get_format_uuid(callid_str, 64);

		if (node != NULL){
			m_LastSipError = MakeCall(node->strcallurl, CSimpleStringA::Format("sip:%s@%s;transport=UDP", node->strnewcallernum, ipstr), 
					callid_str, m_CallingParam);
			m_iChanProxyPort[0] = node->uassistport;
			m_iChanProxyPort[1] = node->uassistport;
			m_strChanProxyIP[0] = node->strassistip;
			m_strChanProxyIP[1] = node->strassistip;
			node->bused = true;
		}	
		else{
			std::size_t icount = m_voipserver.size();
			if (icount > 0){
				int index = SP::Module::Comm::RVCGetTickCount()%icount;
				char strcallurl[MAX_PATH] = {0};
				char strassistip[32] = {0};
				int iport = 0;
				char strserver[MAX_PATH] = { 0 };
				snprintf(strserver, MAX_PATH, "%s", m_voipserver[index].c_str());
				if (0 == GetCallInfoFromConfig(strcallurl, MAX_PATH, strassistip, 32, &iport, strserver)){
					char strassitinter[32] = {0};
					get_interger_netaddr(strassitinter, 32, strassistip);
					m_LastSipError = MakeCall(strcallurl, CSimpleStringA::Format("sip:%s#%s@%s;transport=UDP", m_strTerminalId.GetData(), strassitinter, ipstr), 
						callid_str, m_CallingParam);
					m_iChanProxyPort[0] = iport;
					m_iChanProxyPort[1] = iport;
					m_strChanProxyIP[0] = strassistip;
					m_strChanProxyIP[1] = strassistip;
					LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_CALLROUTE_CONFIG, CSimpleStringA::Format("head office mode no more call router, use default config(call url is %s, assistip is %s).", strcallurl, strassistip).GetData());
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetCallInfoFromConfig failed!");
					m_LastSipError = Error_Param;
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("no default voip server config!");
				m_LastSipError = Error_Param;
			}
		}

		if (m_LastSipError!=Error_Succeed){
			(bool)m_nCurSipServer?(m_nCurSipServer= CurServerNum::Error_Server):(m_nCurSipServer= CurServerNum::BACK_SERVER);
		}
		m_nCurChanServer = CurServerNum::BACK_SERVER;
	}

	if (m_LastSipError != Error_Succeed) 
	{
		PostEventFIFO(new FSMEvent(USER_EVT_JMP_FAIL));
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C2").setResultCode("RTA3421")("send sip failed!");
	}
	else
	{
		ScheduleTimer(11,SIP_CALL_TIMER);
	}
}

void ACMCallFSM::s11_on_exit() 
{
	CancelTimer(11);
}

unsigned int ACMCallFSM::s11_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_HANGUP)
	{
		m_bHangup = true;
		LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_SIPCONNECT_HANGUP, CSimpleStringA::Format("sip connecting, customer active hangup after %ds.", y2k_time_now()- m_nStarttime).GetData());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402304C6")("connect failed for user hangup");
	}
	else if (event->iEvt == USER_EVT_SIP_STATE_IDLE) 
	{
		if (m_nCurSipServer == CurServerNum::MAIN_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_MAIN_SIPCONNECT_SIPSTATE_IDLE,"sipphone connect main server failed");
		}
		else if (m_nCurSipServer == CurServerNum::BACK_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_BAK_SIPCONNECT_SIPSTATE_IDLE,"sipphone connect bak server failed");
		}
		else{
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_SIPCONNECT_SIPSTATE_IDLE,"sipphone connect error server failed");
		}
		(bool)m_nCurSipServer?(m_nCurSipServer= CurServerNum::Error_Server):(m_nCurSipServer= CurServerNum::BACK_SERVER);
		m_nSipErrorNum++;
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C2").setResultCode("RTA3432")("sip connect failed for server error.");
	} 
	else if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (m_nCurSipServer == CurServerNum::MAIN_SERVER){
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_MAIN_SIPCONNECT_CHANSTATE_IDLE,"chan mod idle, main server");
		}
		else if (m_nCurSipServer == CurServerNum::BACK_SERVER){
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_BAK_SIPCONNECT_CHANSTATE_IDLE,"chan mod idle, bak server");
		}
		else{
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_SIPCONNECT_CHANSTATE_IDLE,"chan mod idle, error server");
		}
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (m_nCurSipServer == CurServerNum::MAIN_SERVER){
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_MAIN_SIPCONNECT_SIPENTITY_RESTART,"sipphone mod idle, main server");
		}
		else if (m_nCurSipServer == CurServerNum::BACK_SERVER){
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_BAK_SIPCONNECT_SIPENTITY_RESTART,"sipphone mod idle, bak server");
		}
		else{
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_SIPCONNECT_SIPENTITY_RESTART,"sipphone mod idle, error server");
		}
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C2").setResultCode("RTA3434")("sip connect failed for entity error");
	}
	else if (event->iEvt == EVT_TIMER)
	{
		if (m_nCurSipServer == CurServerNum::MAIN_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_MAIN_SIPCONNECT_TIMEOUT,"sipphone connect timeout, main server");
		}
		else if (m_nCurSipServer == CurServerNum::BACK_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_BAK_SIPCONNECT_TIMEOUT,"sipphone connect timeout, bak server");
		}
		else{
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_SIPCONNECT_TIMEOUT,"sipphone connect timeout, error server");
		}
		m_nSipErrorNum++;
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C2").setResultCode("RTA3435")("sip connect failed for timeout");
	}
	else if (event->iEvt == USER_EVT_JMP_FAIL)
	{
		if (m_nCurSipServer == CurServerNum::MAIN_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_MAIN_SIPCONNECT_FUNC_FAILED,"sipphone connect func failed, main server");
		}
		else if (m_nCurSipServer == CurServerNum::BACK_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_BAK_SIPCONNECT_FUNC_FAILED,"sipphone connect func failed, bak server");
		}
		else{
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_SIPCONNECT_FUNC_FAILED,"sipphone connect func failed, error server");
		}
		m_nSipErrorNum++;
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C2").setResultCode("RTA3436")("sip connect failed for entity error");
	}
	else if (event->iEvt == USER_EVT_STOPLOACALREMOTEVIDEO) 
	{
		PostEventFIFO(new FSMEvent(USER_EVT_HANGUP));
		m_bHangup= true;
		StopVideo();
	}
	return 0;
}

void ACMCallFSM::s12_on_entry() 
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402304C2")("sip channel connect success!");
	m_LastAssistError = Error_Succeed;
	if (m_nCurChanServer == CurServerNum::Error_Server)
	{
		m_LastAssistError = Error_NetBroken;
	}
	m_nSipErrorNum = 0;
	Sleep(200);
	if (m_LastAssistError == Error_Succeed) 
	{
		if (m_CallingParam.nCallType == NORMAL_CALLTYPE  && m_CallingParam.nCallType != DOUBLERECORD_CALLTYPE)
		{
			m_LastAssistError = StartChannel((int)m_nCurChanServer);
		} 
		else
		{
			m_LastAssistError = StartChannel((int)m_nCurChanServer,m_CallingParam);
		}

		if (m_LastAssistError != Error_Succeed) 
		{
			HangupCall();
			(bool)m_nCurChanServer?(m_nCurChanServer= CurServerNum::Error_Server):(m_nCurChanServer= CurServerNum::BACK_SERVER);
		}
	}

	if (m_LastAssistError != Error_Succeed) {
		PostEventFIFO(new FSMEvent(USER_EVT_JMP_FAIL));
		if (Error_NetBroken == m_LastAssistError) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C3").setResultCode("RTA3441")("assistant channel connect failed for net broken");
		}
		else if (Error_Param == m_LastAssistError) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C3").setResultCode("RTA3442")("assistant channel connect failed error param");
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C3").setResultCode("RTA3443")("assistant channel connect failed");
		}
	}
}

void ACMCallFSM::s12_on_exit() {}

unsigned int ACMCallFSM::s12_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_HANGUP)
	{
		m_bHangup = true;
		LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_CHANCONNECT_HANGUP, CSimpleStringA::Format("chan connecting, customer active hangup after %ds.", y2k_time_now() - m_nStarttime).GetData());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402304C6")("connect failed for user hangup");
	}
	else if (event->iEvt == USER_EVT_SIP_STATE_IDLE) 
	{
		if (m_nCurChanServer == CurServerNum::MAIN_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_MAIN_CHANCONNECT_SIPSTATE_IDLE,"sipphone connect server failed at channel connect, main server");
		}
		else if (m_nCurChanServer == CurServerNum::BACK_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_BAK_CHANCONNECT_SIPSTATE_IDLE,"sipphone connect server failed at channel connect, bak server");
		}
		else{
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_CHANCONNECT_SIPSTATE_IDLE,"sipphone connect server failed at channel connect, error server");
		}
		(bool)m_nCurSipServer?(m_nCurSipServer= CurServerNum::Error_Server):(m_nCurSipServer= CurServerNum::BACK_SERVER);
		StopChannel();
		if (!m_bHangup) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C3").setResultCode("RTA3455")("assistant channel bridge failed for timeout");
		}
	} 
	else if (event->iEvt == USER_EVT_CHAN_STATE_IDLE) 
	{
		if (!m_bHangup)
		{
			if (m_nCurChanServer == CurServerNum::MAIN_SERVER){
				LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_MAIN_CHANCONNECT_CHANSTATE_IDLE,"chan connect server failed, main server");
			}
			else if (m_nCurChanServer == CurServerNum::BACK_SERVER){
				LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_BAK_CHANCONNECT_CHANSTATE_IDLE,"chan connect server failed, bak server");
			}
			else{
				LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_CHANCONNECT_CHANSTATE_IDLE,"chan connect server failed, error server");
			}
			(bool)m_nCurChanServer?(m_nCurChanServer= CurServerNum::Error_Server):(m_nCurChanServer= CurServerNum::BACK_SERVER);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C3").setResultCode("RTA3452")("assistant channel bridge failed for server error");
		}
		HangupCall();
		//StopVideo();
	}
	else if (event->iEvt == USER_EVT_CHAN_STATE_CONNECTED) 
	{
		ChanStateConnectedEvent *e = static_cast<ChanStateConnectedEvent *>(event);
		StartVideo(e->m_param.GetData());
		long lnowtime = SP::Module::Comm::RVCGetTickCount();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setCostTime(lnowtime - m_lConnectCostTime).setLogCode("QLR0402304C3")("assistant channel bridge success!");
		m_lConnectCostTime = lnowtime;
	}
	else if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (m_nCurChanServer == CurServerNum::MAIN_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_MAIN_CHANCONNECT_CHANENTITY_RESTART,"chan mod idle, main server");
		}
		else if (m_nCurChanServer == CurServerNum::BACK_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_BAK_CHANCONNECT_CHANENTITY_RESTART,"chan mod idle, bak server");
		}
		else{
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_CHANCONNECT_CHANENTITY_RESTART,"chan mod idle, error server");
		}

		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C3").setResultCode("RTA3453")("assistant channel bridge failed for entity restart");
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (m_nCurChanServer == CurServerNum::MAIN_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_MAIN_CHANCONNECT_SIPENTITY_RESTART,"sipphone mod idle, main server");
		}
		else if (m_nCurChanServer == CurServerNum::BACK_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_BAK_CHANCONNECT_SIPENTITY_RESTART,"sipphone mod idle, bak server");
		}
		else{
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_CHANCONNECT_SIPENTITY_RESTART,"sipphone mod idle, error server");
		}

		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	else if (event->iEvt == USER_EVT_STOPLOACALREMOTEVIDEO) 
	{
		PostEventFIFO(new FSMEvent(USER_EVT_HANGUP));
		m_bHangup=true;
		StopVideo();
	}
	else if (event->iEvt == USER_EVT_JMP_FAIL) 
	{
		if (m_nCurChanServer == CurServerNum::MAIN_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_MAIN_CHANCONNECT_FUNC_FAILED,"chan connect func failed, main server");
		}
		else if (m_nCurChanServer == CurServerNum::BACK_SERVER){
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_BAK_CHANCONNECT_FUNC_FAILED,"chan connect func failed, bak server");
		}
		else{
			LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_COUNTERCONNECT_CHANCONNECT_FUNC_FAILED,"chan connect func failed, error server");
		}
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C3").setResultCode("RTA3454")("assistant channel bridge failed for entity error");
	}
	
	return 0;
}

void ACMCallFSM::s13_on_entry() 
{
	if (m_bHandFree) 
	{
		PostEventLIFO(new FSMEvent(USER_EVT_JMP_HANDFREE));
	} 
	else 
	{
		PostEventLIFO(new FSMEvent(USER_EVT_JMP_PICKUP));
	}
}

void ACMCallFSM::s13_on_exit() {}

unsigned int ACMCallFSM::s13_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	return 0;
}


void ACMCallFSM::s14_on_entry() 
{

}

void ACMCallFSM::s14_on_exit() 
{

}

unsigned int ACMCallFSM::s14_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_STOPLOACALREMOTEVIDEO) 
	{
#ifdef RVC_OS_WIN
		StopVideo();
#else
		StopVideoRender();
#endif
	}
	else if (event->iEvt == USER_EVT_STOP_RECORD_BROADCAST)
	{

	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	return 0;
}

void ACMCallFSM::s20_on_entry() 
{
	StopChannel();
}

void ACMCallFSM::s20_on_exit() {}

unsigned int ACMCallFSM::s20_on_event(FSMEvent* event) 
{
	if (event->iEvt == USER_EVT_CHAN_STATE_IDLE) 
	{
		StopVideo();
	}
	else if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	return 0;
}

void ACMCallFSM::s21_on_entry() 
{
	ScheduleTimer(21,RELEASEING_SIP_TIMER);
	HangupCall();
}

void ACMCallFSM::s21_on_exit() 
{
	CancelTimer(21);
	CancelTimer(210);
}

unsigned int ACMCallFSM::s21_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	else if (event->iEvt == EVT_TIMER)
	{
		if(event->param1 == 21)
		{
			ScheduleTimer(210,RELEASEING_SIP_TIMEOUT);
			ReleaseCall(0);
		}
		else if (event->param1 == 210)
		{
			PostEventFIFO(new FSMEvent(USER_EVT_JMP_FAIL));
			//RealSipErrorCheck();
			LogEvent(Severity_Middle, EVENT_MOD_RELEASESIP_TIMEOUT,"restart sipphone");
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_RESTART_SIPPHONE, "restart sipphone");
		}
	}
	return 0;
}

void ACMCallFSM::s22_on_entry() 
{
	StopChannel();
}

void ACMCallFSM::s22_on_exit() {}

unsigned int ACMCallFSM::s22_on_event(FSMEvent* event) 
{
	if (event->iEvt == USER_EVT_CHAN_STATE_IDLE)
	{
		StopVideo();
	}
	else if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	return 0;
}

void ACMCallFSM::s23_on_entry() 
{
	if((!m_bHangup)&&(((m_nCurSipServer== CurServerNum::BACK_SERVER)&&(m_nCurChanServer!= CurServerNum::Error_Server))||((m_nCurChanServer== CurServerNum::BACK_SERVER)&&(m_nCurSipServer!= CurServerNum::Error_Server))))
	{	
		PostEventLIFO(new FSMEvent(USER_EVT_RECONNECT));
	}
	else
	{
		ScheduleTimer(23, RELEASEING_TIMER_INTERVAL);
	}
}

void ACMCallFSM::s23_on_exit() 
{
	CancelTimer(23);
}

unsigned int ACMCallFSM::s23_on_event(FSMEvent* event) 
{
	if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	else if (event->iEvt == EVT_TIMER)
	{
		if (m_nSipErrorNum >= SIP_CONNECT_FAIL_TIMES)
		{
			m_nSipErrorNum = 0;
			LogEvent(Severity_Middle, EVENT_MOD_RELEASESIP_TIMEOUT,"restart sipphone ");
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_RESTART_SIPPHONE,"FAIL TIMES, restart sipphone ");
		}
	}
	return 0;
}

void ACMCallFSM::s24_on_entry() 
{
	ScheduleTimer(24, RELEASEING_TIMER_INTERVAL);
}

void ACMCallFSM::s24_on_exit() 
{
	CancelTimer(24);
}

unsigned int ACMCallFSM::s24_on_event(FSMEvent* event) 
{
	if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	return 0;
}

void ACMCallFSM::s3_on_entry() 
{
	if (false == m_bConnected) {
		m_bConnected = true;
		unsigned int unowtime = y2k_time_now();
		LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_CALL_CONNECTING_TIME, CSimpleStringA::Format("handfree call connecting time is %us.", unowtime - m_uConnectTime).GetData());
		m_uConnectTime = unowtime;
	}
}

void ACMCallFSM::s3_on_exit() {}

unsigned int ACMCallFSM::s3_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_TO_HANDFREE)
	{
		//m_bHandFree = TRUE;
	} 
	else if (event->iEvt == USER_EVT_TO_PICKUP) 
	{
		//m_bHandFree = FALSE;
	} 
	else if (event->iEvt == USER_EVT_SIP_STATE_IDLE) 
	{
		StopChannel();
	} 
	else if (event->iEvt == USER_EVT_CHAN_STATE_IDLE) 
	{
		HangupCall();
		StopVideo();
	} 
	else if (event->iEvt == USER_EVT_AGENT_WRITABLE) 
	{
		AllowAgentWrite();
	}
	else if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C4").setResultCode("RTA3461")("handfree mode disconnect the video connection for assist channel entity error");
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C4").setResultCode("RTA3462")("handfree mode disconnect the video connection for sipphone entity error");
	}
	return 0;
}

void ACMCallFSM::s4_on_entry() 
{
	if (false == m_bConnected) {
		m_bConnected = true;
		unsigned int unowtime = y2k_time_now();
		LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_CALL_CONNECTING_TIME, CSimpleStringA::Format("pickup call connecting time is %us.", unowtime - m_uConnectTime).GetData());
		m_uConnectTime = unowtime;
	}
}

void ACMCallFSM::s4_on_exit() {}

unsigned int ACMCallFSM::s4_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_TO_HANDFREE) 
	{
		//m_bHandFree = TRUE;
	} 
	else if (event->iEvt == USER_EVT_TO_PICKUP) 
	{
		//m_bHandFree = FALSE;
	} 
	else if (event->iEvt == USER_EVT_SIP_STATE_IDLE) {
		StopChannel();
	} 
	else if (event->iEvt == USER_EVT_CHAN_STATE_IDLE) {
		HangupCall();
		StopVideo();
	}
	else if (event->iEvt == USER_EVT_AGENT_WRITABLE) {
		AllowAgentWrite();
	}
	else if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL){
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C4").setResultCode("RTA3463")("pickup mode disconnect the video connection for assist channel entity error");
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402304C4").setResultCode("RTA3464")("pickup mode disconnect the video connection for sipphone entity error");
	}
	return 0;
}

void ACMCallFSM::s50_on_entry() {}

void ACMCallFSM::s50_on_exit() {}

unsigned int ACMCallFSM::s50_on_event(FSMEvent* event) 
{
	if (event->iEvt == USER_EVT_CHAN_STATE_IDLE) {
		StopVideo();
	}
	else if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	return 0;
}

void ACMCallFSM::s51_on_entry() 
{
	if (m_bConnected) {
		m_bConnected = false;
		LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_CALL_CONNECT_TIME, CSimpleStringA::Format("call connected time is %us.", y2k_time_now() - m_uConnectTime).GetData());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setCostTime(SP::Module::Comm::RVCGetTickCount() - m_lConnectCostTime).setLogCode("QLR0402304C4")("disconnect the video connection.");
	}
}

void ACMCallFSM::s51_on_exit() {}

unsigned int ACMCallFSM::s51_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_CHAN_STATE_IDLE) {
		StopVideo();
	}
	return 0;
}

void ACMCallFSM::s52_on_entry() 
{
	ScheduleTimer(52,RELEASEING_SIP_TIMER);
	if (m_bConnected) {
		m_bConnected = false;
		LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_CALL_CONNECT_TIME, CSimpleStringA::Format("call connected time is %us.", y2k_time_now() - m_uConnectTime).GetData());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setCostTime(SP::Module::Comm::RVCGetTickCount() - m_lConnectCostTime).setLogCode("QLR0402304C4")("disconnect the video connection.");
	}
}

void ACMCallFSM::s52_on_exit() 
{
	CancelTimer(52);
	CancelTimer(520);
}

unsigned int ACMCallFSM::s52_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	else if (event->iEvt == EVT_TIMER)
	{
		if (event->param1 == 52)
		{
			ScheduleTimer(520,RELEASEING_SIP_TIMEOUT);
			ReleaseCall(0);
		}
		else if (event->param1 == 520)
		{
			PostEventFIFO(new FSMEvent(USER_EVT_JMP_FAIL));
			LogEvent(Severity_Middle, EVENT_MOD_RELEASESIP_TIMEOUT,"restart sipphone ");
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_RESTART_SIPPHONE,"restart sipphone ");
		}

	}
	return 0;
}

void ACMCallFSM::s53_on_entry()
{
	ScheduleTimer(53, RELEASEING_TIMER_INTERVAL);
}

void ACMCallFSM::s53_on_exit() 
{
	CancelTimer(53);
}

unsigned int ACMCallFSM::s53_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	else if (event->iEvt == EVT_TIMER)
	{
		if (m_nSipErrorNum >= SIP_CONNECT_FAIL_TIMES)
		{
			m_nSipErrorNum = 0;
			LogEvent(Severity_Middle, EVENT_MOD_RELEASESIP_TIMEOUT,"restart sipphone ");
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_RESTART_SIPPHONE,"FAIL TIMES, restart sipphone ");
		}
	}
	return 0;
}

void ACMCallFSM::s60_on_entry() 
{
	StopChannel();
	HangupCall();
	if (m_bConnected) {
		m_bConnected = false;
		LogWarn(Severity_Low, Error_Debug, LOG_WARN_COUNTERCONNECT_CALL_CONNECT_TIME, CSimpleStringA::Format("call connected time is %us.", y2k_time_now() - m_uConnectTime).GetData());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setCostTime(SP::Module::Comm::RVCGetTickCount() - m_lConnectCostTime).setLogCode("QLR0402304C4")("disconnect the video connection.");
	}
}


void ACMCallFSM::s60_on_exit() {}

unsigned int ACMCallFSM::s60_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_CHAN_STATE_IDLE) 
	{
		StopVideo();
	}
	else if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	return 0;
}

void ACMCallFSM::s61_on_entry() {}

void ACMCallFSM::s61_on_exit() {}

unsigned int ACMCallFSM::s61_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_CHAN_STATE_IDLE) {
		StopVideo();
	}
	else if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	return 0;
}

void ACMCallFSM::s62_on_entry() 
{
	ScheduleTimer(62,RELEASEING_SIP_TIMER);
}

void ACMCallFSM::s62_on_exit() 
{
	CancelTimer(62);
	CancelTimer(620);
}

unsigned int ACMCallFSM::s62_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	else if (event->iEvt == EVT_TIMER)
	{
		if (event->param1 == 62)
		{
			ScheduleTimer(620,RELEASEING_SIP_TIMEOUT);
			ReleaseCall(0);
		}
		else if (event->param1 == 620)
		{
			PostEventFIFO(new FSMEvent(USER_EVT_JMP_FAIL));
			LogEvent(Severity_Middle, EVENT_MOD_RELEASESIP_TIMEOUT,"restart sipphone ");
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_RESTART_SIPPHONE,"restart sipphone ");
		}
	}
	return 0;
}

void ACMCallFSM::s63_on_entry() 
{
	ScheduleTimer(63, RELEASEING_TIMER_INTERVAL);
}

void ACMCallFSM::s63_on_exit() 
{
	CancelTimer(63);
}

unsigned int ACMCallFSM::s63_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_ASSISTCHAN_IDEL)
	{
		if (ReConnectionAssistchan()) {
			m_bConAssist = true;
		}
	}
	else if (event->iEvt == USER_EVT_SIPPHONE_IDEL)
	{
		if (ReConnectionSipphone()) {
			m_bConSipphone = true;
		}
	}
	else if (event->iEvt == EVT_TIMER)
	{
		if (m_nSipErrorNum >= SIP_CONNECT_FAIL_TIMES)
		{
			m_nSipErrorNum = 0;
			//RealSipErrorCheck();
			LogEvent(Severity_Middle, EVENT_MOD_RELEASESIP_TIMEOUT,"restart sipphone");
			LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_COUNTERCONNECT_RESTART_SIPPHONE,"FAIL TIMES, restart sipphone");
		}
	}
	return 0;
}

int ACMCallFSM::TranslateState( int innerState )
{
	switch (innerState) {
	case s0:
		return eState_Offline;
	case s8:
	case s10:
	case s11:
	case s12:
	case s13:
		return eState_Connecting;
	case s20:
	case s21:
	case s22:
	case s23:
	case s24:
		return eState_Fail;
	case s3:
		return eState_HandFree;
	case s4:
		return eState_Pickup;
	case s50:
	case s51:
	case s52:
	case s53:
		return eState_Broken;
	case s60:
	case s61:
	case s62:
	case s63:
		return eState_Releasing;
	case s7:
	case s14:
		return eState_Recording;
	default:
		assert(0);
		return 0;
	}
}