Example #1
0
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);
}