myvtm/Module/mod_initiativetransfer/FlowControlFSM.cpp

#include "stdafx.h"
#include "FlowControlFSM.h"

#define LOG_EVT_EXIT_ACM_FLOW	 0x30500002          //退出坐席控制流程

void ChannelClient::OnMessage( ErrorCodeEnum Error, ChannelService_State_Info &Msg, CSmartPointer<IReleasable> pData )
{
	LOG_FUNCTION();
	if (Error == Error_Succeed) {
		if (Msg.state == eChannelState_Connected) {
			m_pFSM->PostEventFIFO(new FSMEvent(USER_EVT_CHAN_ON));
		} else if (Msg.state == eChannelState_Idle) {
			m_pFSM->PostEventFIFO(new FSMEvent(USER_EVT_CHAN_OFF));
		}
	}
}

void ChannelClient::OnMessage( ErrorCodeEnum Error, ChannelService_Packet_Info &Msg, CSmartPointer<IReleasable> pData )
{
	LOG_FUNCTION();
	if (Error == Error_Succeed) {
		m_pFSM->ProcessPacket(Msg.sub_type, Msg.data);
	}
}

CFlowControlFSM::CFlowControlFSM():	m_bIspad(FALSE)
{

}
CFlowControlFSM::~CFlowControlFSM()
{
}

void CFlowControlFSM::OnStateTrans( int iSrcState, int iDstState )
{
	LOG_TRACE("Trans from %s to %s", GetStateName(iSrcState), GetStateName(iDstState));
	switch (iDstState) {
	case s0:
		SetState("O", "Offline"); // offline
		break;
	case s1:
		SetState("F", "FrontFlow"); // frontflow
		break;
	case s2:
		SetState("B", "BackFlow"); // backflow
		break;
	case s3:
		SetState("C", "FrontCall"); // front call
		break;
	case s5:
		SetState("T", "Transferring"); // Transferring
		break;
	default:
		break;
	}
}

ErrorCodeEnum CFlowControlFSM::OnInit()
{
	ErrorCodeEnum Error;
	m_pClient = new ChannelClient(m_pEntity, this);
	Error = m_pClient->Connect();
	if (Error == Error_Succeed) {
		ChannelService_BeginState_Sub StateSub;
		Error = m_pClient->BeginState(StateSub);
		if (Error == Error_Succeed) {
			ChannelService_BeginRecv_Sub Sub;
			Sub.type = ACM_TYPE_FLW;
			Error = m_pClient->BeginRecv(Sub);
		}
		if (Error != Error_Succeed) {
			m_pClient->GetFunction()->CloseSession();
			m_pClient = NULL;
		}
	} else {
		m_pClient->SafeDelete();
		m_pClient = NULL;
	}

	if (Error == Error_Succeed) {
		AddStateHooker(this);
	}
	
	return Error;
}
ErrorCodeEnum CFlowControlFSM::OnExit()
{ 
	if (m_pClient != NULL) {
        m_pClient->GetFunction()->CloseSession();
        m_pClient = NULL;
	}

	RemoveStateHooker(this);

	void FinishClose(CEntityBase *pEntity, ErrorCodeEnum Error = Error_Succeed);

	FinishClose(m_pEntity);

	return Error_Succeed;
}

BOOL CFlowControlFSM::ReConnectionAssistchan()
{
	if (m_pClient != NULL)
	{
		m_pClient->GetFunction()->CloseSession();
		m_pClient = NULL;
		Dbg("Close AssistChannel Session ");
	}

	if (m_pClient == NULL)
	{
		Dbg("ReConnection AssistChannel Session");
		ErrorCodeEnum Error;
		m_pClient = new ChannelClient(m_pEntity, this);
		Error = m_pClient->Connect();
		if (Error != Error_Succeed) 
		{
			m_pClient->SafeDelete();
			Dbg("m_channelClient connect fail!");
			return FALSE;
		}

		if(Error == Error_Succeed)
		{
			ChannelService_BeginState_Sub ChannelSub;
			Error = m_pClient->BeginState(ChannelSub);
			if (Error != Error_Succeed) 
			{
				LOG_TRACE("BeginState biz channel failed!");
				m_pClient->GetFunction()->CloseSession();
				m_pClient = NULL;
				return FALSE;
			}
		}

		if(Error == Error_Succeed)
		{
			ChannelService_BeginRecv_Sub Sub;
			Sub.type = ACM_TYPE_FLW;
			Error = m_pClient->BeginRecv(Sub);
			if (Error != Error_Succeed) 
			{
				LOG_TRACE("BeginState biz channel failed!");
				m_pClient->GetFunction()->CloseSession();
				m_pClient = NULL;
				return FALSE;
			}
		}
	}

	return TRUE;
}

unsigned int CFlowControlFSM::s0_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_ANSACMFLOW) {
		AgentFlowResult evt;
		evt.error = Error_NetBroken;
		SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(AgentFlowResult), SP_MSG_SIG_OF(AgentFlowResult), evt);
	} else if (event->iEvt == USER_EVT_REQAGENTFLOW) {
		AgentFlowResult evt;
		evt.error = Error_NetBroken;
		SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(AgentFlowResult), SP_MSG_SIG_OF(AgentFlowResult), evt);
	}
	else if (event->iEvt == USER_EVT_ASSIS_IDEL)
	{
		ReConnectionAssistchan();
	}
	return 0;
}
unsigned int CFlowControlFSM::s1_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_REQAGENTFLOW) {
		ReqAgentFlowEvent *rafe = static_cast<ReqAgentFlowEvent*>(event);
		ErrorCodeEnum Error;
		if (m_pClient) {
			ChannelService_Send_Info Info;
			Info.compress = true;
			Info.encrypt = true;
			Info.sub_type = ACM_SUBTYPE_REQ_FLOW;
			Info.type = ACM_TYPE_FLW;
			SpBuffer buf;
			buf.OpenWrite();
			CSimpleString16Bit reqContext = CSimpleStringW216Bit(rafe->req_context);
			buf & reqContext;
			Dbg("%s After convert: %s", __FUNCTION__, CSimpleString16Bit2A(reqContext).GetData());
			Info.data = buf.ToBlob();
			Error = m_pClient->Send(Info);
		} else 
		{
			Error = Error_NetBroken;
		}
		return Error == Error_Succeed ? 1 : 0;
	} else if (event->iEvt == USER_EVT_NTFENTFLOW) {
		LOG_TRACE("spbroadcast NotifyEnterFlowEvent");
		NotifyEnterFlowEvent *nef = static_cast<NotifyEnterFlowEvent*>(event);
		NotifyEnterFlow evt;
		SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(NotifyEnterFlow), SP_MSG_SIG_OF(NotifyEnterFlow), evt);
	}
	else if (event->iEvt == USER_EVT_ASSIS_IDEL)
	{
		ReConnectionAssistchan();
	}
	return 0;
}

unsigned int CFlowControlFSM::s2_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_CHAN_OFF) {
		// notify UI to unlock the screen
		AgentFlowResult evt;
		evt.error = Error_NetBroken;
		SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(AgentFlowResult), SP_MSG_SIG_OF(AgentFlowResult), evt);
	} else if (event->iEvt == USER_EVT_ANSAGENTFLOW) {
		AnsAgentFlowEvent *afe = static_cast<AnsAgentFlowEvent*>(event);
		AgentFlowResult evt;
		CSimpleStringW ans_context = CSimpleString16Bit2W(afe->ans_context);
		evt.ans_context = ans_context;
		evt.error = afe->err ? Error_Unexpect : Error_Succeed;
		Dbg("AgentFlowResult!!!!!");
		SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(AgentFlowResult), SP_MSG_SIG_OF(AgentFlowResult), evt);
	} else if (event->iEvt == USER_EVT_REQACMFLOW) {
		ReqACMFlowEvent *afe = static_cast<ReqACMFlowEvent *>(event);
		ACMFlowInvoke evt;
		CSimpleStringW req_context = CSimpleString16Bit2W(afe->req_context);
		evt.req_context = req_context;
		SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(ACMFlowInvoke), SP_MSG_SIG_OF(ACMFlowInvoke), evt);
	} else if (event->iEvt == USER_EVT_NTFENTFLOW) {
		LOG_TRACE("notify enter flow, disallow control!");
		DisallowControl();
	}
	else if (event->iEvt == USER_EVT_ASSIS_IDEL)
	{
		ReConnectionAssistchan();
	}
	return 0;
}
void CFlowControlFSM::s2_on_exit() 
{
		//only pad vervison use
		if (m_bIspad)
		{
			LogEvent(Severity_Middle,LOG_EVT_EXIT_ACM_FLOW,"exit acm flow");
		}
}

void CFlowControlFSM::s3_on_entry()
{
	
}
void CFlowControlFSM::s3_on_exit() {}
unsigned int CFlowControlFSM::s3_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_ANSACMFLOW) {
		AnsACMFlowEvent *afe = static_cast<AnsACMFlowEvent*>(event);
		ErrorCodeEnum Error;
		if (m_pClient) {
			ChannelService_Send_Info Info;
			Info.compress = true;
			Info.encrypt = true;
			Info.sub_type = ACM_SUBTYPE_ANS_FLOW;
			Info.type = ACM_TYPE_FLW;
			SpBuffer buf;
			buf.OpenWrite();
            CSimpleString16Bit ansContext = CSimpleStringW216Bit(afe->ans_context);
            buf& ansContext;
            Dbg("%s After convert: %s", __FUNCTION__, CSimpleString16Bit2A(ansContext).GetData());
			Info.data = buf.ToBlob();
			Error = m_pClient->Send(Info);
		} else {
			Error = Error_NetBroken;
		}
		return Error == Error_Succeed ? 1 : 0;
	} else if (event->iEvt == USER_EVT_CHAN_OFF) {
		AgentFlowResult evt;
		evt.error = Error_NetBroken;
		SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(AgentFlowResult), SP_MSG_SIG_OF(AgentFlowResult), evt);
	}
	else if (event->iEvt == USER_EVT_ASSIS_IDEL)
	{
		ReConnectionAssistchan();
	}
	return 0;
}
void CFlowControlFSM::s5_on_entry()
{
	
}
void CFlowControlFSM::s5_on_exit() { }
unsigned int CFlowControlFSM::s5_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_DISCTRL) {
		DisallowControl();
	} else if (event->iEvt == USER_EVT_REQAGENTFLOW) {
		ReqAgentFlowEvent *rafe = static_cast<ReqAgentFlowEvent*>(event);
		ErrorCodeEnum Error;
		if (m_pClient) {
			ChannelService_Send_Info Info;
			Info.compress = true;
			Info.encrypt = true;
			Info.sub_type = ACM_SUBTYPE_REQ_FLOW;
			Info.type = ACM_TYPE_FLW;
			SpBuffer buf;
			buf.OpenWrite();
            CSimpleString16Bit reqContext = CSimpleStringW216Bit(rafe->req_context);
            buf& reqContext;
            Dbg("%s After convert: %s", __FUNCTION__, CSimpleString16Bit2A(reqContext).GetData());
			Info.data = buf.ToBlob();
			Error = m_pClient->Send(Info);
		} else {
			Error = Error_NetBroken;
		}
		return Error == Error_Succeed ? 1 : 0;
	}
	else if (event->iEvt == USER_EVT_ASSIS_IDEL)
	{
		ReConnectionAssistchan();
	}
	return 0;
}

unsigned int CFlowControlFSM::s7_on_event(FSMEvent* event)
{
	if (event->iEvt == USER_EVT_ASSIS_IDEL)
	{
			ReConnectionAssistchan();
	}
	return 0;
}

void CFlowControlFSM::ProcessPacket( int sub_type, CBlob &blob )
{
	if (sub_type == ACM_SUBTYPE_ANS_FLOW) {
		AnsAgentFlowEvent *e = new AnsAgentFlowEvent();
		SpBuffer buf;
		buf.OpenRead((const char*)blob.m_pData, blob.m_iLength);
		buf.SetLength(blob.m_iLength);
		buf & e->err & e->ans_context;
		PostEventFIFO(e);
	} else if (sub_type == ACM_SUBTYPE_REQ_FLOW) {
		ReqACMFlowEvent *e = new ReqACMFlowEvent();
		SpBuffer buf;
		buf.OpenRead((const char*)blob.m_pData, blob.m_iLength);
		buf.SetLength(blob.m_iLength);
		buf & e->req_context;
		PostEventFIFO(e);
	} else if (sub_type == ACM_SUBTYPE_NTF_ENTFLOW) {
		NotifyEnterFlowEvent *e = new NotifyEnterFlowEvent();
		e->m_pFSM = this;
		SpBuffer buf;
		buf.OpenRead((const char*)blob.m_pData, blob.m_iLength);
		buf.SetLength(blob.m_iLength);
		buf & e->context;
		PostEventFIFO(e);
	} else {
		LOG_TRACE("unknown sub_type from agent!");
	}
}

ErrorCodeEnum CFlowControlFSM::SetState(const char *s, const char *sdesc)
{
	LOG_TRACE("set BackInitiative to %s, %s", s, sdesc);
	return m_pEntity->GetFunction()->SetSysVar("BackInitiative", s);
}

ErrorCodeEnum CFlowControlFSM::DisallowControl()
{
	LOG_FUNCTION();
	if (m_pClient) {
		ChannelService_Send_Info Info;
		Info.compress = false;
		Info.encrypt = true;
		Info.id = 0;
		Info.sub_type = ACM_SUBTYPE_DIS_CONTROL;
		Info.type = ACM_TYPE_FLW;
		return m_pClient->Send(Info);
	} else {
		return Error_NetBroken;
	}	
}




void NotifyEnterFlowEvent::OnUnhandled()
{
	LOG_FUNCTION();
	m_pFSM->DisallowControl();
}