taolistenerclient.cpp

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

UtlBoolean TaoListenerClientTask::receiveCallEvent(TaoMessage& rMsg,
                                                                                PtCallListener* pListener)
#endif
{
    UtlBoolean bHandledMsg = TRUE ;
#ifdef TAO_TIME_DEBUG
        char tmp[64];

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

        int eventId;
        if (!getCallEvent(rMsg, pListener, eventId))
                return FALSE;

#ifdef WV_DEBUG
        fireUserEvent(eventId, 3);
        osPrintf("after CALL_%s\n", name);
#endif
        switch(eventId)
        {
                case PtEvent::CALL_EVENT_TRANSMISSION_ENDED:
                        EVENT_TRACE("receiveCallEvent::CALL_EVENT_TRANSMISSION_ENDED:\n") ;
                        pListener->callEventTransmissionEnded((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::CALL_ACTIVE:
                        EVENT_TRACE("receiveCallEvent::CALL_ACTIVE:\n") ;
                        pListener->callActive((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::CALL_INVALID:
                        EVENT_TRACE("receiveCallEvent::CALL_INVALID:\n") ;
                        pListener->callInvalid((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::CALL_META_CALL_STARTING_STARTED:
                        EVENT_TRACE("receiveCallEvent::CALL_META_CALL_STARTING_STARTED:\n") ;
                        pListener->callMetaCallStartStarted((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::CALL_META_CALL_STARTING_ENDED:
                        EVENT_TRACE("receiveCallEvent::CALL_META_CALL_STARTING_ENDED:\n") ;
                        pListener->callMetaCallStartEnded((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::CALL_META_CALL_ENDING_STARTED:
                        EVENT_TRACE("receiveCallEvent::CALL_META_CALL_ENDING_STARTED:\n") ;
                        pListener->callMetaCallEndStarted((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::CALL_META_CALL_ENDING_ENDED:
                        EVENT_TRACE("receiveCallEvent::CALL_META_CALL_ENDING_ENDED:\n") ;
                        pListener->callMetaCallEndEnded((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::SINGLECALL_META_PROGRESS_STARTED:
                        EVENT_TRACE("receiveCallEvent::SINGLECALL_META_PROGRESS_STARTED:\n") ;
                        pListener->callMetaProgressStarted((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::SINGLECALL_META_PROGRESS_ENDED:
                        EVENT_TRACE("receiveCallEvent::SINGLECALL_META_PROGRESS_ENDED:\n") ;
                        pListener->callMetaProgressEnded((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::SINGLECALL_META_SNAPSHOT_STARTED:
                        EVENT_TRACE("receiveCallEvent::SINGLECALL_META_SNAPSHOT_STARTED:\n") ;
                        pListener->callMetaSnapshotStarted((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::SINGLECALL_META_SNAPSHOT_ENDED:
                        EVENT_TRACE("receiveCallEvent::SINGLECALL_META_SNAPSHOT_ENDED:\n") ;
                        pListener->callMetaSnapshotEnded((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::CALL_META_ADD_PARTY_STARTED:
                        EVENT_TRACE("receiveCallEvent::CALL_META_ADD_PARTY_STARTED:\n") ;
                        pListener->callMetaAddPartyStarted((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::CALL_META_ADD_PARTY_ENDED:
                        EVENT_TRACE("receiveCallEvent::CALL_META_ADD_PARTY_ENDED:\n") ;
                        pListener->callMetaAddPartyEnded((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::CALL_META_REMOVE_PARTY_STARTED:
                        EVENT_TRACE("receiveCallEvent::CALL_META_REMOVE_PARTY_STARTED:\n") ;
                        pListener->callMetaRemovePartyStarted((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::CALL_META_REMOVE_PARTY_ENDED:
                        EVENT_TRACE("receiveCallEvent::CALL_META_REMOVE_PARTY_ENDED:\n") ;
                        pListener->callMetaRemovePartyEnded((PtCallEvent&)(*mpCallEvent));
                        break;

                case PtEvent::MULTICALL_META_MERGE_STARTED:
                        EVENT_TRACE("receiveCallEvent::MULTICALL_META_MERGE_STARTED:\n") ;
                        pListener->multicallMetaMergeStarted((PtMultiCallMetaEvent &)*mpCallEvent);
                        break;

                case PtEvent::MULTICALL_META_MERGE_ENDED:
                        EVENT_TRACE("receiveCallEvent::MULTICALL_META_MERGE_ENDED:\n") ;
                        pListener->multicallMetaMergeEnded((PtMultiCallMetaEvent &)*mpCallEvent);
                        break;

                case PtEvent::MULTICALL_META_TRANSFER_STARTED:
                        EVENT_TRACE("receiveCallEvent::MULTICALL_META_TRANSFER_STARTED:\n") ;
                        pListener->multicallMetaTransferStarted((PtMultiCallMetaEvent &)*mpCallEvent);
                        break;

                case PtEvent::MULTICALL_META_TRANSFER_ENDED:
                        EVENT_TRACE("receiveCallEvent::MULTICALL_META_TRANSFER_ENDED:\n") ;
                        pListener->multicallMetaTransferEnded((PtMultiCallMetaEvent &)*mpCallEvent);
                        break;

                default:
            bHandledMsg = FALSE ;
                        EVENT_TRACE("receiveCallEvent::BOGUS EVENT:\n") ;
                        break;
        }

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


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

        sprintf(tmp, "%d %d ", rMsg.getTaoObjHandle(), (int)pListener);
        UtlString stringData = UtlString("RECEIVE CONN EVENT: ") + UtlString(tmp);
    timeLog.addEvent(stringData.data());
#endif
        int addedToCall = 0;
        int remoteIsCallee = 0;
        int     eventId;
        if (!getConnectionEvent(rMsg,
                                                        pListener,
                                                        eventId,
                                                        addedToCall,
                                                        remoteIsCallee))
        {
                return FALSE;
        }
#ifdef WV_DEBUG
        fireUserEvent(eventId, 3);
        osPrintf("before CONNECTION_%s\n", name);
#endif
        switch(eventId)
        {
                case PtEvent::CONNECTION_CREATED:
                        EVENT_TRACE("receiveConnectionEvent::CONNECTION_CREATED:\n") ;
                        pListener->connectionCreated((PtConnectionEvent&)(*mpConnEvent));
                        break;

                case PtEvent::CONNECTION_ALERTING:
                        if (addedToCall || !remoteIsCallee)
                        {
                                EVENT_TRACE("receiveConnectionEvent::CONNECTION_ALERTING:\n") ;
                                pListener->connectionAlerting((PtConnectionEvent&)(*mpConnEvent));
                        }
                        break;

                case PtEvent::CONNECTION_DIALING:
                        EVENT_TRACE("receiveConnectionEvent::CONNECTION_DIALING:\n") ;
                        pListener->connectionDialing((PtConnectionEvent&)(*mpConnEvent));
                        break;

                case PtEvent::CONNECTION_ESTABLISHED:
                        EVENT_TRACE("receiveConnectionEvent::CONNECTION_ESTABLISHED:\n") ;
                        pListener->connectionEstablished((PtConnectionEvent&)(*mpConnEvent));
                        break;

                case PtEvent::CONNECTION_INITIATED:
                        EVENT_TRACE("receiveConnectionEvent::CONNECTION_INITIATED:\n") ;
                        pListener->connectionCreated((PtConnectionEvent&)(*mpConnEvent));
                        break;

                case PtEvent::CONNECTION_DISCONNECTED:
                        EVENT_TRACE("1 receiveConnectionEvent::CONNECTION_DISCONNECTED:\n") ;
                        pListener->connectionDisconnected((PtConnectionEvent&)(*mpConnEvent));
                        EVENT_TRACE("2 receiveConnectionEvent::CONNECTION_DISCONNECTED:\n") ;
                        break;

                case PtEvent::CONNECTION_FAILED:
                        if (addedToCall || !remoteIsCallee)
                        {
                                EVENT_TRACE("receiveConnectionEvent::CONNECTION_FAILED:\n") ;
                                pListener->connectionFailed((PtConnectionEvent&)(*mpConnEvent));
                        }
                        break;

                case PtEvent::CONNECTION_NETWORK_ALERTING:
                        EVENT_TRACE("receiveConnectionEvent::CONNECTION_NETWORK_ALERTING:\n") ;
                        pListener->connectionNetworkAlerting((PtConnectionEvent&)(*mpConnEvent));
                        break;

                case PtEvent::CONNECTION_NETWORK_REACHED:
                        EVENT_TRACE("receiveConnectionEvent::CONNECTION_NETWORK_REACHED:\n") ;
                        pListener->connectionNetworkReached((PtConnectionEvent&)(*mpConnEvent));
                        break;

                case PtEvent::CONNECTION_OFFERED:
                        if (addedToCall || !remoteIsCallee)
                        {
#ifdef TEST_PRINT
            TaoString argList(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
            UtlString localAddr, remoteAddr;
            localAddr  = argList[1];
            remoteAddr = argList[2];
            osPrintf("\nTAO client sending OFFERED event to listener:\n\tlocal address %s\n\tremote address %s\n\n",
                     localAddr.data(), remoteAddr.data());
#endif
                                EVENT_TRACE("receiveConnectionEvent::CONNECTION_OFFERED:\n") ;
                                pListener->connectionOffered((PtConnectionEvent&)(*mpConnEvent));
                        }
                        break;

                case PtEvent::CONNECTION_QUEUED:
                        EVENT_TRACE("receiveConnectionEvent::CONNECTION_QUEUED:\n") ;
                        pListener->connectionQueued((PtConnectionEvent&)(*mpConnEvent));
                        break;

                case PtEvent::CONNECTION_UNKNOWN:
                        EVENT_TRACE("receiveConnectionEvent::CONNECTION_UNKNOWN:\n") ;
                        pListener->connectionUnknown((PtConnectionEvent&)(*mpConnEvent));
                        break;

                default:
            bHandledMsg = FALSE ;
                        EVENT_TRACE("receiveConnectionEvent::BOGUS EVENT:\n") ;
                        break;
        }

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


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

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

        PtEvent::PtEventId      eventId = (PtEvent::PtEventId) rMsg.getTaoObjHandle();
        PtTerminalEvent event(eventId);

        switch(eventId)
        {
                case PtEvent::TERMINAL_EVENT_TRANSMISSION_ENDED:
                        EVENT_TRACE("receiveTerminalEvent::TERMINAL_EVENT_TRANSMISSION_ENDED:\n") ;
                        pListener->terminalEventTransmissionEnded(event);
                        break;

                default:
            bHandledMsg = FALSE ;
                        EVENT_TRACE("receiveTerminalEvent::BOGUS EVENT:\n") ;
                        break;
        }

        return bHandledMsg;
}


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

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

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

        TaoString        argList(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        int cnt = rMsg.getArgCnt();

        UtlString terminalName;