taolistenerclient.cpp

基于sipfoundy 公司开发的sipx协议API

        terminalName.remove(0);
        if (cnt > 2)
        {
                terminalName = argList[2];
        }

        PtTerminalComponentEvent event(eventId, terminalName, mpClient);
        if (cnt > 2)
        {
                event.setIntData1(atoi(argList[0]));
                event.setIntData2(atoi(argList[1]));
                event.setStringData1(argList[3]);
        }

#ifdef WV_DEBUG
        fireUserEvent(eventId, 3);
        osPrintf("before TERMINAL_COMPONENT_%s\n", name);
#endif
        switch(eventId)
        {
                case PtEvent::PHONE_RINGER_VOLUME_CHANGED:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_RINGER_VOLUME_CHANGED:\n") ;
                        pListener->phoneRingerVolumeChanged((PtComponentIntChangeEvent&)event);
                        break;

                case PtEvent::PHONE_RINGER_PATTERN_CHANGED:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_RINGER_PATTERN_CHANGED:\n") ;
                        pListener->phoneRingerPatternChanged((PtComponentIntChangeEvent&)event);
                        break;
                case PtEvent::PHONE_RINGER_INFO_CHANGED:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_RINGER_INFO_CHANGED:\n") ;
                        pListener->phoneRingerInfoChanged((PtComponentStringChangeEvent&)event);
                        break;
                case PtEvent::PHONE_SPEAKER_VOLUME_CHANGED:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_SPEAKER_VOLUME_CHANGED:\n") ;
                        pListener->phoneSpeakerVolumeChanged((PtComponentIntChangeEvent&)event);
                        break;
                case PtEvent::PHONE_MICROPHONE_GAIN_CHANGED:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_MICROPHONE_GAIN_CHANGED:\n") ;
                        pListener->phoneMicrophoneGainChanged((PtComponentIntChangeEvent&)event);
                        break;
                case PtEvent::PHONE_LAMP_MODE_CHANGED:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_LAMP_MODE_CHANGED:\n") ;
                        pListener->phoneLampModeChanged((PtComponentIntChangeEvent&)event);
                        break;
                case PtEvent::PHONE_BUTTON_INFO_CHANGED:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_BUTTON_INFO_CHANGED:\n") ;
                        pListener->phoneButtonInfoChanged((PtComponentStringChangeEvent&)event);
                        break;
                case PtEvent::PHONE_DISPLAY_CHANGED:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_DISPLAY_CHANGED:\n") ;
                        pListener->phoneDisplayChanged(event);
                        break;
                case PtEvent::PHONE_BUTTON_DOWN:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_BUTTON_DOWN:\n") ;
                        pListener->phoneButtonDown(event);
                        break;
                case PtEvent::PHONE_BUTTON_UP:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_BUTTON_UP:\n") ;
                        pListener->phoneButtonUp(event);
                        break;
                case PtEvent::PHONE_BUTTON_REPEAT:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_BUTTON_REPEAT:\n") ;
                        pListener->phoneButtonRepeat(event);
                        break;
                case PtEvent::PHONE_HOOKSWITCH_OFFHOOK:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_HOOKSWITCH_OFFHOOK:\n") ;
                        pListener->phoneHookswitchOffhook(event);
                        break;
                case PtEvent::PHONE_HOOKSWITCH_ONHOOK:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_HOOKSWITCH_ONHOOK:\n") ;
                        pListener->phoneHookswitchOnhook(event);
                        break;

                case PtEvent::PHONE_EXTSPEAKER_CONNECTED:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_RINGER_VOLUME_CHANGED:\n") ;
                        pListener->phoneExtSpeakerConnected(event);
                        break;

                case PtEvent::PHONE_EXTSPEAKER_DISCONNECTED:
                        EVENT_TRACE("receiveTerminalComponentEvent::PHONE_RINGER_PATTERN_CHANGED:\n") ;
                        pListener->phoneExtSpeakerDisconnected(event);
                        break;
                default:
            bHandledMsg = FALSE ;
                        EVENT_TRACE("receiveTerminalComponentEvent::BOGUS EVENT:\n") ;
                        break;
        }

#ifdef WV_DEBUG
        fireUserEvent(eventId, 4);
        osPrintf("after TERMINAL_COMPONENT_%s\n", name);
#endif
        return bHandledMsg;
}


#ifdef TAO_TIME_DEBUG
UtlBoolean TaoListenerClientTask::receiveTerminalConnectionEvent(TaoMessage& rMsg,
                                                                                                PtTerminalConnectionListener* pListener,
                                                                                                OsTimeLog& timeLog)
#else
UtlBoolean TaoListenerClientTask::receiveTerminalConnectionEvent(TaoMessage& rMsg,
                                                                                                PtTerminalConnectionListener* pListener)
#endif
{
    UtlBoolean bHandledMsg = TRUE ;
#ifdef TAO_TIME_DEBUG
        char tmp[64];

        sprintf(tmp, "%d %d ", rMsg.getTaoObjHandle(), (int)pListener);
        UtlString stringData = UtlString("RECEIVE  TC  EVENT: ") + UtlString(tmp);
    timeLog.addEvent(stringData.data());
#endif

        int eventId;
        int addedToCall = 0;
        int remoteIsCallee = 0;
        if (!getTerminalConnectionEvent(rMsg,
                                                                        pListener,
                                                                        eventId,
                                                                        addedToCall,
                                                                        remoteIsCallee))
        {
                return FALSE;
        }

#ifdef WV_DEBUG
        fireUserEvent(eventId, 3);
        osPrintf("before TERMINAL_CONNECTION_%s\n", name);
#endif
        switch(eventId)
        {
                case PtEvent::TERMINAL_CONNECTION_CREATED:
                        EVENT_TRACE("receiveTerminalConnectionEvent::TERMINAL_CONNECTION_CREATED:\n") ;
                        pListener->terminalConnectionCreated((PtTerminalConnectionEvent&)(*mpTermConnEvent));
                        break;

                case PtEvent::TERMINAL_CONNECTION_RINGING:
                        if (addedToCall || !remoteIsCallee)
                        {
                                EVENT_TRACE("receiveTerminalConnectionEvent::TERMINAL_CONNECTION_RINGING:\n") ;
                                pListener->terminalConnectionRinging((PtTerminalConnectionEvent&)(*mpTermConnEvent));
                        }
                        break;

                case PtEvent::TERMINAL_CONNECTION_HELD:
                        EVENT_TRACE("receiveTerminalConnectionEvent::TERMINAL_CONNECTION_HELD:\n") ;
                        pListener->terminalConnectionHeld((PtTerminalConnectionEvent&)(*mpTermConnEvent));
                        break;

                case PtEvent::TERMINAL_CONNECTION_TALKING:
                        if (addedToCall || !remoteIsCallee)
                        {
                                EVENT_TRACE("receiveTerminalConnectionEvent::TERMINAL_CONNECTION_TALKING:\n") ;
                                pListener->terminalConnectionTalking((PtTerminalConnectionEvent&)(*mpTermConnEvent));
                        }
                        break;

                case PtEvent::TERMINAL_CONNECTION_DROPPED:
                        EVENT_TRACE("1 receiveTerminalConnectionEvent::TERMINAL_CONNECTION_DROPPED:\n") ;
                        pListener->terminalConnectionDropped((PtTerminalConnectionEvent&)(*mpTermConnEvent));
                        EVENT_TRACE("2 receiveTerminalConnectionEvent::TERMINAL_CONNECTION_DROPPED:\n") ;
                        break;

                case PtEvent::TERMINAL_CONNECTION_IDLE:
                        EVENT_TRACE("receiveTerminalConnectionEvent::TERMINAL_CONNECTION_IDLE:\n") ;
                        pListener->terminalConnectionIdle((PtTerminalConnectionEvent&)(*mpTermConnEvent));
                        break;

                case PtEvent::TERMINAL_CONNECTION_IN_USE:
                        EVENT_TRACE("receiveTerminalConnectionEvent::TERMINAL_CONNECTION_IN_USE:\n") ;
                        pListener->terminalConnectionInUse((PtTerminalConnectionEvent&)(*mpTermConnEvent));
                        break;

                case PtEvent::TERMINAL_CONNECTION_UNKNOWN:
                        EVENT_TRACE("receiveTerminalConnectionEvent::TERMINAL_CONNECTION_UNKNOWN:\n") ;
                        pListener->terminalConnectionUnknown((PtTerminalConnectionEvent&)(*mpTermConnEvent));
                        break;
                default:
            bHandledMsg = FALSE ;
                        EVENT_TRACE("receiveTerminalConnectionEvent::BOGUS STATE:\n") ;
                        break;
        }

#ifdef WV_DEBUG
        fireUserEvent(eventId, 4);
        osPrintf("after TERMINAL_CONNECTION_%s\n", name);
#endif
        return bHandledMsg;
}


void TaoListenerClientTask::addEventListener(PtEventListener* pListener, const char* callId)
{
        mListenerSem.acquire();
        int ptr = (int)pListener;
        if (mListenerCnt > 0)  // check if listener is already added.
        {
                for (int i = 0; i < mListenerCnt; i++)
                {
                        if (mpListeners[i] && mpListeners[i]->mpListenerPtr == ptr)
                        {
                                if (!callId || (callId && mpListeners[i]->mName.compareTo(callId) == 0))
                                {
                                        mpListeners[i]->mRef++;
                                        osPrintf("Listener already exists in TaoListenerClientTask: 0x%08x\n", (int)pListener);
                                        mListenerSem.release();
                                        return;
                                }
                        }
                }
        }

    if (mListenerCnt == mMaxNumListeners)
    {
        //make more of em.
        mMaxNumListeners += 20;
        mpListeners = (TaoListenerDb **)realloc(mpListeners,sizeof(TaoListenerDb *)*mMaxNumListeners);
        for (int loop = mListenerCnt;loop < mMaxNumListeners;loop++)
            mpListeners[loop] = 0 ;
    }

        TaoListenerDb *pListenerDb = new TaoListenerDb();
        if (pListenerDb)
        {
                pListenerDb->mRef++;
                pListenerDb->mpListenerPtr = ptr;
                if (callId)
                        pListenerDb->mName.append(callId);
                mpListeners[mListenerCnt++] = pListenerDb;
        }
        mListenerSem.release();
}

void TaoListenerClientTask::removeEventListener(PtEventListener& rListener)
{
        mListenerSem.acquire();
        int ptr = (int)&rListener;
        if (mListenerCnt > 0)  // check if listener is already added.
        {
                for (int i = 0; i < mListenerCnt; i++)
                {
                        if (mpListeners[i] && mpListeners[i]->mpListenerPtr == ptr)
                        {
                                mpListeners[i]->mRef--;
                                if (mpListeners[i]->mRef <= 0)
                                {
                                        delete mpListeners[i];
                                        for (int j = i; j < mListenerCnt; j++)
                                        {
                                                mpListeners[j] = mpListeners[j + 1];
                                        }
                                        mListenerCnt--;
                                        osPrintf("Remove listener in TaoListenerClientTask: 0x%08x\n", ptr);
                                        mListenerSem.release();
                                        return;
                                }
                        }
                }
        }

        mListenerSem.release();
}

UtlBoolean TaoListenerClientTask::getCallEvent(TaoMessage& rMsg,
                                                                                PtCallListener* pListener,
                                                                                int& evId)
{
        int cnt = rMsg.getArgCnt();

        if (cnt < 1)
                return FALSE;

        PtEvent::PtEventId      eventId = (PtEvent::PtEventId) rMsg.getTaoObjHandle();
        if (!PtEvent::isCallEvent(eventId))
                return FALSE;

        TaoString argList(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        UtlString callId = argList[0];

        int addedToCall = 0;
        int ptr = (int)pListener;
        for (int i = 0; i < mListenerCnt; i++)
        {
                if (mpListeners[i] && mpListeners[i]->mpListenerPtr == ptr)
                {
                        if (!callId.isNull() && !(mpListeners[i]->mName.isNull()) && callId != mpListeners[i]->mName)
                        {
                                return FALSE;
                        }
                        addedToCall = 1;
                }
        }

        int metaCode = (cnt >= 10) ? atoi(argList[10]) : PtEvent::META_EVENT_NONE;
        int numOldCalls = (cnt > 10) ? (cnt - 11) : 0;

        UtlString* oldCallIds = 0;
        if (numOldCalls > 0)
        {       oldCallIds = new UtlString[numOldCalls];
                for (int i = 0; i < numOldCalls; i++)
                        oldCallIds[i] = argList[i + 11]; // 1st is the new call
        }

        int sipResponseCode = atoi(argList[7]);

        mpCallEvent->setEventId(eventId);
        mpCallEvent->setMetaCode((PtEvent::PtMetaCode)metaCode);
        mpCallEvent->setEventCallId(callId.data());                     // call id
        mpCallEvent->setEventSipResponseCode(sipResponseCode);          // SIP response code
        mpCallEvent->setEventSipResponseText(argList[8]);               // SIP response text
        mpCallEvent->setEventNewCallId(argList[10]);            // new call id
        mpCallEvent->setEventOldCallIds(numOldCalls, oldCallIds);

        if (oldCallIds) delete[] oldCallIds;

        evId = eventId;
        return TRUE;
}

UtlBoolean TaoListenerClientTask::getConnectionEvent(TaoMessage& rMsg,
                                                                                PtConnectionListener* pListener,
                                                                                int& evId,