int TaoClientTask::sendRequest(TaoMessage& rMsg, OsMutex* pMutex, const OsTime& rTimeout)
{
if (mpTaoServerTask)
{
rMsg.setMsgQueueHandle((TaoObjHandle) this);
mpTaoServerTask->postMessage(rMsg);
return 1;
}
else
{
osPrintf("\n++++++ TaoClientTask::sendRequest mpTaoServerTask = 0x%p +++++\n", mpTaoServerTask);
osPrintf("\n++++++ %d %d +++++\n", rMsg.getMsgSubType(), rMsg.getCmd());
}
osPrintf("\n++++++ TaoClientTask::sendRequest %p %s : %d+++++\n", mpConnectionSocket, mRemoteHost.data(), mRemotePort);
if (!mpConnectionSocket)
{
mMutex.acquireWrite();
mpConnectionSocket = new OsConnectionSocket(mRemotePort, mRemoteHost);
if (mpAgent)
{
delete mpAgent;
}
mpAgent = new TaoTransportAgent(mpConnectionSocket, this);
mpAgent->start();
mMutex.releaseWrite();
}
int recvd = 0;
if (mpConnectionSocket && mpConnectionSocket->isOk())
{
unsigned int sent;
mMutex.acquireWrite();
UtlString buffer;
ssize_t bufferLen;
rMsg.getBytes(&buffer, &bufferLen);
size_t iSendSize = bufferLen + (sizeof(uint32_t)*2) ;
char* pBuf = new char[iSendSize] ;
uint32_t cookie = 0x1234ABCD ;
uint32_t length = bufferLen ;
memcpy(&pBuf[0], &cookie, sizeof(uint32_t)) ;
memcpy(&pBuf[sizeof(uint32_t)], &length, sizeof(uint32_t)) ;
memcpy(&pBuf[sizeof(uint32_t)*2], buffer.data(), bufferLen) ;
sent = mpConnectionSocket->write(pBuf, iSendSize) ;
delete pBuf ;
if (sent > sizeof(uint32_t)*2)
sent -= sizeof(uint32_t)*2 ;
mMutex.releaseWrite();
}
return recvd;
}
UtlBoolean TaoListenerManager::handleMessage(OsMsg& eventMessage)
{
int eventId = ((TaoListenerEventMessage&)eventMessage).getEventId();
OsReadLock lock(mListenerRWLock);
if (mListenerCnt > 0)
{
for (int i = 0; i < mListenerCnt; i++)
{
if (!mpListeners[i] || mpListeners[i]->mpListenerPtr == 0)
continue;
TaoEventListener* pListener = (TaoEventListener*)mpListeners[i]->mpListenerPtr;
if (pListener && pListener->isEventEnabled((PtEvent::PtEventId &)eventId))
{
UtlString rTerminalName;
char buf[128];
if (TAO_SUCCESS == pListener->getTerminalName(buf, 127))
{
TaoObjHandle hSocket;
rTerminalName.append(buf);
if (TAO_NOT_FOUND == mpAgents->findValue(rTerminalName.data(), hSocket))
{
// OsConnectionSocket* pConnectionSocket;
// pConnectionSocket = new OsConnectionSocket(DEF_TAO_EVENT_PORT, rTerminalName.data());
// mpConnectionSockets->insert((const char *)rTerminalName.data(), (TaoObjHandle)pConnectionSocket);
// TaoTransportAgent *pAgent = new TaoTransportAgent(pConnectionSocket, this);
// mpAgents->insert((const char *)rTerminalName.data(), (TaoObjHandle)pAgent);
// hSocket = (TaoObjHandle) pAgent;
return TRUE;
}
int msgType = eventMessage.getMsgType();
int msgSubType = eventMessage.getMsgSubType();
PtEvent::PtEventId eventId = PtEvent::EVENT_INVALID;
TaoMessage* pMsg = NULL;
UtlBoolean bValidEvent = TRUE;
switch(msgType)
{
case OsMsg::TAO_EVENT:
pMsg = new TaoMessage((TaoListenerEventMessage&) eventMessage, hSocket);
break;
case OsMsg::TAO_MSG:
pMsg = new TaoMessage((TaoMessage&)eventMessage);
pMsg->setSocket(hSocket);
break;
case OsMsg::TAO_LISTENER_EVENT_MSG:
{
TaoListenerEventMessage *pEventMsg = (TaoListenerEventMessage*) &eventMessage;
UtlString callId;
UtlString remoteAddress;
pEventMsg->getStringData1(callId);
pEventMsg->getStringData2(remoteAddress);
UtlString arg = callId + TAOMESSAGE_DELIMITER + remoteAddress;
char buf[MAXIMUM_INTEGER_STRING_LENGTH];
sprintf(buf, "%d", msgSubType); // actual event id
arg += TAOMESSAGE_DELIMITER + buf;
pMsg = new TaoMessage(TaoMessage::EVENT,
0,
0,
0,
hSocket,
3,
arg);
}
break;
case OsMsg::PS_MSG:
{
PsMsg msg = (PsMsg&)eventMessage;
int hookType = msg.getParam1();
int key = msg.getParam2();
UtlString param;
msg.getStringParam1(param);
switch(msgSubType)
{
case PsMsg::EXTSPEAKER_CONNECT:
eventId = PtEvent::PHONE_EXTSPEAKER_CONNECTED;
break;
case PsMsg::EXTSPEAKER_DISCONNECT:
eventId = PtEvent::PHONE_EXTSPEAKER_DISCONNECTED;
break;
case PsMsg::BUTTON_DOWN:
eventId = PtEvent::PHONE_BUTTON_DOWN;
break;
case PsMsg::BUTTON_UP:
eventId = PtEvent::PHONE_BUTTON_UP;
break;
case PsMsg::BUTTON_SET_INFO:
eventId = PtEvent::PHONE_BUTTON_INFO_CHANGED;
break;
case PsMsg::BUTTON_REPEAT:
eventId = PtEvent::PHONE_BUTTON_REPEAT;
break;
case PsMsg::HOOKSW_STATE:
case PsMsg::HOOKSW_SET_STATE:
if(hookType == PsHookswTask::OFF_HOOK)
{
eventId = PtEvent::PHONE_HOOKSWITCH_OFFHOOK;
}
else if( hookType == PsHookswTask::ON_HOOK)
{
eventId = PtEvent::PHONE_HOOKSWITCH_ONHOOK;
}
break;
case PsMsg::HANDSET_SET_VOLUME:
eventId = PtEvent::PHONE_HANDSET_VOLUME_CHANGED;
break;
case PsMsg::RINGER_SET_VOLUME:
eventId = PtEvent::PHONE_RINGER_VOLUME_CHANGED;
break;
case PsMsg::SPEAKER_SET_VOLUME:
eventId = PtEvent::PHONE_SPEAKER_VOLUME_CHANGED;
break;
default:
bValidEvent = FALSE;
break;
}
if (bValidEvent)
{
UtlString arg;
char buf[MAXIMUM_INTEGER_STRING_LENGTH];
sprintf(buf, "%d", hookType);
arg = buf + TAOMESSAGE_DELIMITER;
sprintf(buf, "%d", key);
arg += buf + TAOMESSAGE_DELIMITER;
arg += rTerminalName + TAOMESSAGE_DELIMITER + param;
pMsg = new TaoMessage(TaoMessage::EVENT,
0,
0,
eventId,
hSocket,
4,
arg);
}
}
break;
default:
bValidEvent = FALSE;
break;
}
if (bValidEvent)
{
pMsg->setMsgQueueHandle(mEventClient);
if (mEventClient)
((TaoListenerClientTask*) mEventClient)->postMessage((TaoMessage&)(*pMsg));
else
{
assert(FALSE);
mpSvrTransport->postMessage((TaoMessage&)(*pMsg));
}
delete pMsg;
}
}
rTerminalName.remove(0);
}
}
}
return(TRUE);
}