void UCEventMgr::EventAgent::NotifyCallClosed() const
{
INFO_PARAM1(m_EventPara);
ctk::xml::XMLInStream xmlStr(m_EventPara);
std::string id;
xmlStr["id"] >> id;
std::string callerNum;
xmlStr["callerNum"] >> callerNum;
std::string reason;
xmlStr["reason"] >> reason;
std::string conversationId;
xmlStr["conversationId"] >> conversationId;
if (conversationId == UCCallManager::Instance().GetConvID())
{
(void)UCCallManager::Instance().ClearCallMember();
(void)UCCallManager::Instance().ClearConvMember();
(void)UCCallManager::Instance().ClearConvID();
}
if(NULL == UCCallManager::OnAVSessionClosedCB)
{
ERROR_LOG() << "UCCallManager::OnAVSessionClosedCB is null.";
return;
}
STMsgAVSessionClosedParam item = {0};
(void)strcpy_s(item.AVSessionId_,id.c_str());
(void)strcpy_s(item.callerUri_,callerNum.c_str());
(void)strcpy_s(item.reason_,reason.c_str());
DEBUG_LOG() << "--- OnAVSessionClosedCB ENTER ";
UCCallManager::OnAVSessionClosedCB(item);
DEBUG_LOG() << "--- OnAVSessionClosedCB LEAVE ";
}
void UCEventMgr::EventAgent::NotifyCallIncoming() const
{
if (NULL == UCCallManager::OnAVSessAddedCB)
{
WARN_LOG() << "OnAVSessAddedCB is null";
return;
}
INFO_PARAM1(m_EventPara);
ctk::xml::XMLInStream xmlStr(m_EventPara);
std::string callerUri;
xmlStr["callerUri"] >> callerUri;
std::string video;
xmlStr["video"] >> video;
std::string callmode;
xmlStr["callmode"] >> callmode;
std::string accountType;
xmlStr["accounttype"] >> accountType;
STAudioVideoParam item = {0};
item.isvideo_ = 0;
item.callMode = 0;
item.AccountType = 0;
Contact ctact;
if(eSDKTool::IsValidUri(callerUri))
{
if(UC_SDK_Success == UCContactMgr::Instance().getContactByUri(callerUri,ctact))
{
ctk::MemSet(item.ucAcc,0,STRING_LENGTH);
ctk::MemCopy(item.ucAcc,ctact.ucAcc_.c_str(),(ctact.ucAcc_.size()<(STRING_LENGTH)) ? (ctact.ucAcc_.size()) : (STRING_LENGTH-1));
}
else
{
ctk::MemSet(item.ucAcc,0,STRING_LENGTH);
ctk::MemCopy(item.ucAcc,callerUri.c_str(),(callerUri.size()<(STRING_LENGTH)) ? (callerUri.size()) : (STRING_LENGTH-1));
}
}
else
{
ctk::MemSet(item.ucAcc,0,STRING_LENGTH);
ctk::MemCopy(item.ucAcc,callerUri.c_str(),(callerUri.size()<(STRING_LENGTH)) ? (callerUri.size()) : (STRING_LENGTH-1));
}
if("true" == video)
{
item.isvideo_ = 1;
}
if("IPPhone" == callmode)
{
item.callMode = 1;
}
if("IPPhone" == accountType)
{
item.AccountType = 1;
}
DEBUG_LOG() << "--- OnAVSessAddedCB ENTER ";
UCCallManager::OnAVSessAddedCB(item);
DEBUG_LOG() << "--- OnAVSessAddedCB LEAVE ";
}
void UCEventMgr::EventAgent::NotifyRejectNewCall(void) const
{
INFO_PARAM1(m_EventPara);
ctk::xml::XMLInStream xmlStr(m_EventPara);
std::string conversationID;
xmlStr["conversationID"] >> conversationID;
(void)UCCallManager::Instance().RejectCall(conversationID);
}
void LogXml_Failure( const char* inMsg )
{
I_LogFile& log = *GetTestsLogXml();
String xmlStr( inMsg );
xmlStr.addXmlEncoding();
log << "<failure message=\"" << xmlStr.c_str() << "\" type=\"\"> </failure>\n";
}
void LogXml_TestCase_start( const char* inTestCaseName )
{
I_LogFile& log = *GetTestsLogXml();
String xmlStr( inTestCaseName );
xmlStr.addXmlEncoding();
log << "<testcase name=\"" << xmlStr.c_str()
<< "\" classname=\"" << (pCurrentClass ? pCurrentClass : "VKERNEL")
<< "\">\n";
}
void UCEventMgr::EventAgent::NotifyPhoneJointCB() const
{
INFO_PARAM1(m_EventPara);
ctk::xml::XMLInStream xmlStr(m_EventPara);
std::string strStatus;
xmlStr["status"] >> strStatus;
int iStatus = -1;
if("0" == strStatus)
{
iStatus = STATUS_START_SUCC;
}
else if("1" == strStatus)
{
iStatus = STATUS_START_FAILED;
}
else if("2" == strStatus)
{
iStatus = STATUS_STOP_SUCC;
}
else if("3" == strStatus)
{
iStatus = STATUS_STOP_FAILED;
}
else if("4" == strStatus)
{
iStatus = STATUS_ONLINE;
}
else if("5" == strStatus)
{
iStatus = STATUS_OFFLINE;
}
else if("6" == strStatus)
{
iStatus = STATUS_OFFHOOK;
}
if(NULL == UCConfigMgr::m_OnPJEventCB)
{
WARN_LOG() << "m_OnPJEventCB is null";
return;
}
DEBUG_LOG() << "--- OnPJEventCB ENTER ";
UCConfigMgr::m_OnPJEventCB((EM_PhoneJointStatusType)iStatus);
DEBUG_LOG() << "--- OnPJEventCB LEAVE ";
return;
}
void GameConsoleWindow::CreateCEGUIWindow()
{
// Get a local pointer to the CEGUI Window Manager, Purely for convenience to reduce typing
CEGUI::WindowManager *pWindowManager = CEGUI::WindowManager::getSingletonPtr();
// Now before we load anything, lets increase our instance number to ensure no conflicts.
// I like the format #_ConsoleRoot so thats how i'm gonna make the prefix. This simply
// Increments the iInstanceNumber then puts it + a _ into the sNamePrefix string.
sNamePrefix = ++iInstanceNumber + "_";
// Now that we can ensure that we have a safe prefix, and won't have any naming conflicts lets create the window
// and assign it to our member window pointer m_ConsoleWindow
// inLayoutName is the name of your layout file (for example "console.layout"), don't forget to rename inLayoutName by our layout file
CasaEngine::IFile* pFile = CasaEngine::MediaManager::Instance().FindMedia("GameConsole.layout", CasaEngine::FileMode::READ);
if (pFile != nullptr)
{
CEGUI::String xmlStr(pFile->GetBuffer());
m_ConsoleWindow = pWindowManager->loadLayoutFromString(xmlStr);
DELETE_AO pFile;
pFile = nullptr;
}
else
{
throw CasaEngine::CLoadingFailed("GameConsole.layout", "");
}
// Being a good programmer, its a good idea to ensure that we got a valid window back.
if (m_ConsoleWindow)
{
CEGUI::System::getSingleton().getDefaultGUIContext().setRootWindow(m_ConsoleWindow);
// Lets add our new window to the Root GUI Window
//CEGUI::System::getSingleton().getDefaultGUIContext().getRootWindow()->addChildWindow(m_ConsoleWindow);
//CEGUI::System::getSingleton().getDefaultGUIContext().getRootWindow()->addChild(m_ConsoleWindow);
// Now register the handlers for the events (Clicking, typing, etc)
(this)->RegisterHandlers();
}
else
{
// Something bad happened and we didn't successfully create the window lets output the information
CEGUI::Logger::getSingleton().logEvent("Error: Unable to load the ConsoleWindow from .layout");
}
}
void UCEventMgr::EventAgent::NotifyCallConnect() const
{
if (NULL == UCCallManager::OnAVSessionConnectedCB)
{
WARN_LOG() << "OnAVSessionConnectedCB is null";
return;
}
INFO_PARAM1(m_EventPara);
ctk::xml::XMLInStream xmlStr(m_EventPara);
std::string caller;
xmlStr["caller"] >> caller;
std::string conID ;
xmlStr["convid"] >> conID;
DEBUG_LOG() << "--- OnAVSessionConnectedCB ENTER ";
UCCallManager::OnAVSessionConnectedCB();
DEBUG_LOG() << "--- OnAVSessionConnectedCB LEAVE ";
}
void UCEventMgr::EventAgent::NotifyContactStatus(void) const
{
INFO_PARAM1(m_EventPara);
ctk::xml::XMLInStream xmlStr(m_EventPara);
std::string uri;
xmlStr["caller"] >> uri;
Contact _contact;
if(UC_SDK_Success != UCContactMgr::Instance().getContactByUri(uri,_contact))
{
return;
}
if(NULL == UCRegManager::Instance().m_pSubscribeMgr)
{
WARN_LOG() << "m_pSubscribeMgr is null";
return;
}
std::string _desc;
ContactAvailability _state = UCRegManager::Instance().m_pSubscribeMgr->GetContactStatus(uri,_desc);
(void)UCRegManager::Instance().NotifyStatus(_contact,_state,_desc);
}
void UCEventMgr::EventAgent::NotifyVideo() const
{
if(NULL == UCCallManager::OnVideoCallEventCB)
{
WARN_LOG() << "OnVideoCallEventCB is null";
return;
}
INFO_PARAM1(m_EventPara);
ctk::xml::XMLInStream xmlStr(m_EventPara);
std::string strVideoState;
xmlStr["video"] >> strVideoState;
std::string strAcc;
xmlStr["account"] >> strAcc;
STVideoCallParam st={0};
ctk::MemSet(st.ucAcc,0,STRING_LENGTH);
ctk::MemCopy(st.ucAcc,strAcc.c_str(),(strAcc.size()<(STRING_LENGTH)) ? (strAcc.size()) : (STRING_LENGTH-1));
if("connecting" == strVideoState)
{
st.callStatus = CALL_VIDEO_REQ;
}
else if("connected" == strVideoState)
{
st.callStatus = CALL_VIDEO_CONNECTED;
}
else
{
st.callStatus = CALL_VIDEO_CLOSE;
}
DEBUG_LOG() << "--- OnVideoCallEventCB ENTER ";
UCCallManager::OnVideoCallEventCB(st);
DEBUG_LOG() << "--- OnVideoCallEventCB LEAVE ";
}
void UCEventMgr::EventAgent::NotifyConv(void) const
{
if(NULL == UCCallManager::OnConfMemberEventCB)
{
WARN_LOG() << "OnConfMemberEventCB is NULL.";
return;
}
INFO_PARAM1(m_EventPara);
STConfParam item;
ctk::xml::XMLInStream xmlStr(m_EventPara);
std::string membType;
xmlStr["type"] >> membType;
if("UCAccount" == membType)
{
item.memType = UC_ACCOUNT;
}
else if("IPPhone" == membType)
{
item.memType = UC_IPPHONE;
}
else
{
WARN_LOG() << "Event Para membType is invalid";
return;
}
std::string membStatus;
xmlStr["status"] >> membStatus;
if("Inviting" == membStatus)
{
item.memStatus = CONF_MEM_INVITING;
}
else if("Hangup" == membStatus)
{
item.memStatus = CONF_MEM_HANGUP;
}
else if("Quit" == membStatus)
{
item.memStatus = CONF_MEM_QUIT;
}
else if("Mute" == membStatus)
{
item.memStatus = CONF_MEM_MUTE;
}
else if("UnMute" == membStatus)
{
item.memStatus = CONF_MEM_UnMute;
}
else if("Speaking" == membStatus)
{
item.memStatus = CONF_MEM_SPK;
}
else if("Delete" == membStatus)
{
item.memStatus = CONF_MEM_DEL;
}
else if("Add" == membStatus)
{
item.memStatus = CONF_MEM_ADD;
}
else
{
WARN_LOG() << "Event Para membStatus is invalid";
return;
}
std::string membAccount;
xmlStr["account"] >> membAccount;
ctk::MemSet(item.ucAcc,0,STRING_LENGTH);
ctk::MemCopy(item.ucAcc,membAccount.c_str(),(membAccount.size()<(STRING_LENGTH)) ? (membAccount.size()) : (STRING_LENGTH-1));
if(CONF_MEM_SPK == item.memStatus)
{
//speak状态提前处理
UCCallManager::OnConfMemberEventCB(item);
}
else
{
if(UC_SDK_Success == UCCallManager::Instance().UpdateConvMember(membAccount,(EM_MemStatusInCall)item.memStatus))
{
UCCallManager::OnConfMemberEventCB(item);
if(CONF_MEM_ADD == item.memStatus)
{
//增加成员时，推送一下在线状态
ctk::xml::XMLOutStream eventXML("event");
Contact _cont;
(void)UCContactMgr::Instance().getContactByAccount(membAccount,_cont);
eventXML["caller"] << _cont.uri_;
UCEventMgr::Instance().NotifyStatusEvent(eventXML.str());
}
}
}
}
void
XMLTagParser::FindCommentClose(const char*& buf,
const char* start,
const char* end)
{
UINT16 nCommentDepth = 1;
CHXXMLEncode xmlStr(m_pEncoding, (BYTE*)start, end - start);
UINT16 uLen = 0;
const char* pos = (const char*)xmlStr.GetNextChar(uLen);
while(pos < end && m_comment_state > 0)
{
switch(m_comment_state)
{
case 1:
if(*pos == '-')
m_comment_state = 2;
else if (*pos == '<')
m_comment_state = 4;
else if(m_comment_start)
{
if(*pos == '#')
{
if(end - pos < 8)
{
buf = pos;
return;
}
pos = (const char*)xmlStr.GetNextChar(uLen);
if(strncasecmp(pos, "include", 7) == 0)
{
pos += 7;
m_comment_get_arg = 1;
m_comment_pos = 0;
strcpy(m_comment_command, "include"); /* Flawfinder: ignore */
}
}
}
break;
case 2:
if(*pos == '-')
m_comment_state = 3;
else
m_comment_state = 1;
break;
case 3:
if(*pos == '>')
{
nCommentDepth--;
if (nCommentDepth == 0)
{
m_comment_state = 0;
buf = (const char*)xmlStr.GetNextChar(uLen);
}
else
m_comment_state = 1;
}
else
m_comment_state = 1;
break;
case 4:
// Ignore nested comments while looking for our end tag
if (*pos == '!')
m_comment_state = 5;
else
m_comment_state = 1;
break;
case 5:
if (*pos == '-')
m_comment_state = 6;
else
m_comment_state = 1;
break;
case 6:
if (*pos == '-')
{
nCommentDepth++;
}
m_comment_state = 1;
break;
}
if(m_comment_state > 0)
{
switch(m_comment_get_arg)
{
case 1:
if(*pos != '"' && !isspace(*pos))
m_comment_get_arg = 0;
else if(*pos == '"')
m_comment_get_arg = 2;
break;
case 2:
if(*pos != '"')
if (m_comment_pos < 1023) m_comment_arg[m_comment_pos++] = *pos;
else
{
if (m_comment_pos < 1024) m_comment_arg[m_comment_pos] = 0;
m_comment_get_arg = 3;
}
break;
default:
break;
}
}
pos = (const char*)xmlStr.GetNextChar(uLen);
}
}
GetStringResult
XMLTagParser::GetString(const char*& ptr,
const char* end,
char*& val,
UINT32 type)
{
GetStringResult retval = GSInvalid;
CHXXMLEncode xmlStr(m_pEncoding, (BYTE*)ptr, end - ptr);
UINT16 uLen = 0;
ptr = (const char*)xmlStr.GetNextChar(uLen);
while(isspace(*ptr) && ptr < end)
{
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
if((const char*)ptr >= end)
{
return GSNoValue;
}
if(*ptr == '>')
{
ptr = (const char*)xmlStr.GetNextChar(uLen);
return GSNoValue;
}
if(*ptr == '/' && *(ptr + 1) == '>')
{
xmlStr += 2;
ptr = (const char*)xmlStr++;
return GSNoValue;
}
// temp buffer to copy string value
char* pVal = new char[end - ptr + 1];
char* pValPtr = pVal;
char* pValStartPtr = pVal;
switch(type)
{
case TagType:
{
// The main tag name, delimited by space
if(*ptr == '/')
{
retval = GSEndTag;
pValStartPtr++;
}
while(!isspace(*ptr) && *ptr != '>' && ptr < end)
{
*pValPtr++ = *ptr;
if(uLen == 2)
{
*pValPtr++ = *(ptr + 1);
}
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
break;
}
case AttributeName:
{
// Delimited by whitespace or =
while(!isspace(*ptr) && *ptr != '=' && *ptr != '>' && ptr < end)
{
*pValPtr++ = *ptr;
if(uLen == 2)
{
*pValPtr++ = *(ptr + 1);
}
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
HXBOOL foundequals = FALSE;
if(ptr < end)
{
// Set the ptr to past the =
while((isspace(*ptr) || *ptr == '=') && ptr < end)
{
if(*ptr == '=')
foundequals=TRUE;
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
}
if(!foundequals)
{
retval = GSValueOnly;
}
break;
}
case AttributeValue:
case AttributeValueNoQuote:
case AttributeValueDirective:
{
if(*ptr == '"')
{
ptr = (const char*)xmlStr.GetNextChar(uLen);
while(*ptr != '"' && ptr < end)
{
if(*ptr == '&')
{
*pValPtr = GetEscapeMacro(ptr, end);
pValPtr++;
xmlStr.SetCurrent((BYTE*)ptr);
}
else
{
*pValPtr++ = *ptr;
if(uLen == 2)
{
*pValPtr++ = *(ptr + 1);
}
}
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
if(*ptr != '"')
{
return GSMissingQuote;
}
/* Skip the quote */
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
else if(*ptr == '\'')
{
ptr = (const char*)xmlStr.GetNextChar(uLen);
while(*ptr != '\'' && ptr < end)
{
if(*ptr == '&')
{
*pValPtr = GetEscapeMacro(ptr, end);
pValPtr++;
xmlStr.SetCurrent((BYTE*)ptr);
}
else
{
*pValPtr++ = *ptr;
if(uLen == 2)
{
*pValPtr++ = *(ptr + 1);
}
}
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
if(*ptr != '\'')
{
delete [] pVal;
return GSMissingQuote;
}
/* Skip the quote */
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
else if(*ptr == '[' && type == AttributeValueDirective)
{
ptr = (const char*)xmlStr.GetNextChar(uLen);
while(*ptr != ']' && ptr < end)
{
*pValPtr++ = *ptr;
if(uLen == 2)
{
*pValPtr++ = *(ptr + 1);
}
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
if(*ptr != ']')
{
delete[] pVal;
return GSMissingQuote;
}
/* skip the ']' */
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
else
{
/* don't care!!! */
while(!isspace(*ptr) && *ptr != '>' && ptr < end)
{
*pValPtr++ = *ptr;
if(uLen == 2)
{
*pValPtr++ = *(ptr + 1);
}
ptr = (const char*)xmlStr.GetNextChar(uLen);
}
}
break;
}
}
*pValPtr = '\0';
val = new_string(pValStartPtr);
delete [] pVal;
if(retval == GSInvalid)
return GSFoundExpected;
else
return retval;
}
