callmanager.cpp

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

                UtlString metaCallId3;

                ((CpMultiStringMessage&)eventMessage).getString1Data(callId);
                ((CpMultiStringMessage&)eventMessage).getString2Data(metaCallId0);
                ((CpMultiStringMessage&)eventMessage).getString3Data(metaCallId1);
                ((CpMultiStringMessage&)eventMessage).getString4Data(metaCallId2);
                ((CpMultiStringMessage&)eventMessage).getString5Data(metaCallId3);

                OsSysLog::add(FAC_CP, PRI_DEBUG, "CallManager:: create call %s\n", callId.data());

                metaEventCallIds[0] = metaCallId0.data();
                metaEventCallIds[1] = metaCallId1.data();
                metaEventCallIds[2] = metaCallId2.data();
                metaEventCallIds[3] = metaCallId3.data();
                doCreateCall(callId.data(), metaEventId, metaEventType,
                    numCalls, metaEventCallIds, assumeFocusIfNoInfocusCall);

                messageProcessed = TRUE;
                break;
            }

        case CP_GET_CALLS:
            {
                int numCalls = 0;
                UtlString callId;
                UtlSList* callList;
                UtlInt* callCollectable;
                OsProtectedEvent* getCallsEvent = (OsProtectedEvent*) ((CpMultiStringMessage&)eventMessage).getInt1Data();
                getCallsEvent->getIntData((int&)callList);

                if(getCallsEvent)
                {
                    OsReadLock lock(mCallListMutex);
                    // Get the callId for the infocus call
                    if(infocusCall)
                    {
                        infocusCall->getCallId(callId);
                        callList->append(new UtlString(callId));
                        numCalls++;
                    }

                    // Get the callId for the calls in the stack
                    CpCall* call = NULL;

                    UtlSListIterator iterator(callStack);
                    callCollectable = (UtlInt*) iterator();
                    while(callCollectable)
                    {
                        call = (CpCall*) callCollectable->getValue();
                        if(call)
                        {
                            call->getCallId(callId);
                            callList->append(new UtlString(callId));
                            numCalls++;
                        }
                        callCollectable = (UtlInt*) iterator();
                    }

                    // Signal the caller that we are done.
                    // If the event has already been signalled, clean up
                    if(OS_ALREADY_SIGNALED == getCallsEvent->signal(numCalls))
                    {
                        // The other end must have timed out on the wait
                        callList->destroyAll();
                        delete callList;
                        OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
                        eventMgr->release(getCallsEvent);
                    }
                }
                messageConsumed = TRUE;
                messageProcessed = TRUE;
                break;
            }

        case CP_CONNECT:
            {
                UtlString callId;
                UtlString addressUrl;
                UtlString desiredConnectionCallId ;
                CONTACT_ID contactId;
                ((CpMultiStringMessage&)eventMessage).getString1Data(callId);
                ((CpMultiStringMessage&)eventMessage).getString2Data(addressUrl);
                ((CpMultiStringMessage&)eventMessage).getString4Data(desiredConnectionCallId);
                contactId = (CONTACT_ID) ((CpMultiStringMessage&)eventMessage).getInt1Data();
                void* pDisplay = (void*) ((CpMultiStringMessage&)eventMessage).getInt2Data();


                doConnect(callId.data(), addressUrl.data(), desiredConnectionCallId.data(), contactId, pDisplay) ;
                messageProcessed = TRUE;
                break;
            }

        case CP_OUTGOING_INFO:
            {
                CpMultiStringMessage& infoMessage = (CpMultiStringMessage&)eventMessage;
                UtlString callId;
                UtlString contentType;
                UtlString sContent;

                infoMessage.getString1Data(callId);
                infoMessage.getString2Data(contentType);
                infoMessage.getString3Data(sContent);
                doSendInfo(callId, contentType, sContent);
                break;
            }

        case CP_SET_INBOUND_CODEC_CPU_LIMIT:
            {
                int iLevel = ((CpMultiStringMessage&)eventMessage).getInt1Data();
                mpCodecFactory->setCodecCPULimit(iLevel) ;
                messageConsumed = TRUE;
                messageProcessed = TRUE;
                break ;
            }
        case CP_ENABLE_STUN:
            {
                UtlString stunServer ;
                int iRefreshPeriod ;
                int iStunOptions ;
                OsNotification* pNotification ;


                CpMultiStringMessage& enableStunMessage = (CpMultiStringMessage&)eventMessage;
                enableStunMessage.getString1Data(stunServer) ;
                iRefreshPeriod = enableStunMessage.getInt1Data() ;
                iStunOptions = enableStunMessage.getInt2Data() ;
                pNotification = (OsNotification*) enableStunMessage.getInt3Data() ;

                doEnableStun(stunServer, iRefreshPeriod, iStunOptions, pNotification) ;
            }
        case CP_ANSWER_CONNECTION:
        case CP_DROP:
        case CP_BLIND_TRANSFER:
        case CP_CONSULT_TRANSFER:
        case CP_CONSULT_TRANSFER_ADDRESS:
        case CP_TRANSFER_CONNECTION:
        case CP_TRANSFER_CONNECTION_STATUS:
        case CP_TRANSFEREE_CONNECTION:
        case CP_TRANSFEREE_CONNECTION_STATUS:
        case CP_HOLD_TERM_CONNECTION:
        case CP_HOLD_ALL_TERM_CONNECTIONS:
        case CP_UNHOLD_ALL_TERM_CONNECTIONS:
        case CP_UNHOLD_TERM_CONNECTION:
        case CP_RENEGOTIATE_CODECS_CONNECTION:
        case CP_RENEGOTIATE_CODECS_ALL_CONNECTIONS:
        case CP_SET_CODEC_CPU_LIMIT:
        case CP_GET_CODEC_CPU_LIMIT:
        case CP_GET_CODEC_CPU_COST:
        case CP_UNHOLD_LOCAL_TERM_CONNECTION:
        case CP_HOLD_LOCAL_TERM_CONNECTION:
        case CP_START_TONE_TERM_CONNECTION:
        case CP_STOP_TONE_TERM_CONNECTION:
        case CP_PLAY_AUDIO_TERM_CONNECTION:
        case CP_PLAY_BUFFER_TERM_CONNECTION:
        case CP_STOP_AUDIO_TERM_CONNECTION:
        case CP_CREATE_PLAYER:
        case CP_DESTROY_PLAYER:
        case CP_CREATE_PLAYLIST_PLAYER:
        case CP_DESTROY_PLAYLIST_PLAYER:
        case CP_DESTROY_QUEUE_PLAYER:
        case CP_CREATE_QUEUE_PLAYER:
        case CP_SET_PREMIUM_SOUND_CALL:
        case CP_GET_NUM_CONNECTIONS:
        case CP_GET_CONNECTIONS:
        case CP_GET_CALLED_ADDRESSES:
        case CP_GET_CALLING_ADDRESSES:
        case CP_GET_NUM_TERM_CONNECTIONS:
        case CP_GET_TERM_CONNECTIONS:
        case CP_IS_LOCAL_TERM_CONNECTION:
        case CP_ACCEPT_CONNECTION:
        case CP_REJECT_CONNECTION:
        case CP_REDIRECT_CONNECTION:
        case CP_DROP_CONNECTION:
        case CP_FORCE_DROP_CONNECTION:
        case CP_OFFERING_EXPIRED:
        case CP_RINGING_EXPIRED:
        case CP_GET_CALLSTATE:
        case CP_GET_CONNECTIONSTATE:
        case CP_GET_TERMINALCONNECTIONSTATE:
        case CP_GET_SESSION:
        case CP_GET_INVITE:
        case CP_CANCEL_TIMER:
        case CP_GET_NEXT_CSEQ:
        case CP_ADD_TONE_LISTENER:
        case CP_REMOVE_TONE_LISTENER:
        case CP_ENABLE_DTMF_EVENT:
        case CP_DISABLE_DTMF_EVENT:
        case CP_REMOVE_DTMF_EVENT:
        case CP_EZRECORD:
        case CP_SET_OUTBOUND_LINE:
        case CP_STOPRECORD:
        case CP_GET_LOCAL_CONTACTS:
        case CP_GET_MEDIA_CONNECTION_ID:
        case CP_GET_CAN_ADD_PARTY:
        case CP_SPLIT_CONNECTION:
        case CP_JOIN_CONNECTION:
        case CP_SEND_SIP_REQUEST:
        case CP_NEW_PASSERTED_ID:
        case CP_SET_MEDIA_PROPERTY:
            // Forward the message to the call
            {
                UtlString callId;
                ((CpMultiStringMessage&)eventMessage).getString1Data(callId);
                OsReadLock lock(mCallListMutex);
                CpCall* call = findHandlingCall(callId);
                if(!call)
                {
                    // The call might have been terminated by asynchronous events.
                    // But output a debugging message, so the programmer can check
                    // to see that the CallId was valid in the past.
                    OsSysLog::add(FAC_CP, PRI_DEBUG, "Cannot find CallId: %s to post message: %d\n",
                        callId.data(), msgSubType);
                    if(   msgSubType == CP_GET_NUM_CONNECTIONS ||
                        msgSubType == CP_GET_CONNECTIONS ||
                        msgSubType == CP_GET_CALLED_ADDRESSES ||
                        msgSubType == CP_GET_CALLING_ADDRESSES ||
                        msgSubType == CP_GET_NUM_TERM_CONNECTIONS ||
                        msgSubType == CP_GET_TERM_CONNECTIONS ||
                        msgSubType == CP_IS_LOCAL_TERM_CONNECTION ||
                        msgSubType == CP_GET_CALLSTATE ||
                        msgSubType == CP_GET_CONNECTIONSTATE ||
                        msgSubType == CP_GET_TERMINALCONNECTIONSTATE ||
                        msgSubType == CP_GET_NEXT_CSEQ ||
                        msgSubType == CP_GET_SESSION ||
                        msgSubType == CP_GET_INVITE ||
                        msgSubType == CP_GET_CODEC_CPU_COST ||
                        msgSubType == CP_GET_CODEC_CPU_LIMIT ||
                        msgSubType == CP_CREATE_PLAYER ||
                        msgSubType == CP_CREATE_PLAYLIST_PLAYER ||
                        msgSubType == CP_CREATE_QUEUE_PLAYER ||
                        msgSubType == CP_DESTROY_PLAYER ||
                        msgSubType == CP_DESTROY_PLAYLIST_PLAYER ||
                        msgSubType == CP_DESTROY_QUEUE_PLAYER ||
                        msgSubType == CP_STOPRECORD ||
                        msgSubType == CP_EZRECORD ||
                        msgSubType == CP_PLAY_BUFFER_TERM_CONNECTION ||
                        msgSubType == CP_GET_LOCAL_CONTACTS || 
                        msgSubType == CP_GET_MEDIA_CONNECTION_ID ||
                        msgSubType == CP_GET_CAN_ADD_PARTY ||
                        msgSubType == CP_SEND_SIP_REQUEST)
                    {
                        // Get the OsProtectedEvent and signal it to go away
                        OsProtectedEvent* eventWithoutCall = (OsProtectedEvent*)
                            ((CpMultiStringMessage&)eventMessage).getInt1Data();
                        if (eventWithoutCall)
                        {
                            OsSysLog::add(FAC_CP, PRI_ERR, "CallManager::handleMessage Received a message subtype %d request on invalid callId '%s'; signaled event in message\n",
                                msgSubType, callId.data());

                            // Test if already signaled here and
                            // releasing the event if it is.
                            if(OS_ALREADY_SIGNALED == eventWithoutCall->signal(0))
                            {
                                OsProtectEventMgr* eventMgr =
                                    OsProtectEventMgr::getEventMgr();
                                eventMgr->release(eventWithoutCall);
                                eventWithoutCall = NULL;
                            }
                        }
                        else
                        {
                            OsSysLog::add(FAC_CP, PRI_ERR, "CallManager::handleMessage Received a message subtype %d request on invalid callId '%s'; no event to signal\n",
                                msgSubType, callId.data());
                        }
                    }
                    else if (msgSubType == CP_REMOVE_DTMF_EVENT)
                    {
                        // 08/19/03 (rschaaf):
                        // The entity requesting the CP_REMOVE_DTMF_EVENT can't delete
                        // the event because it might still be in use.  Instead,
                        // the recipient of the CP_REMOVE_DTMF_EVENT message must take
                        // responsibility for deleting the event.  If the recipient no
                        // longer exists, the CallManager must do the deed.
                        OsQueuedEvent* pEvent = (OsQueuedEvent*)
                            ((CpMultiStringMessage&)eventMessage).getInt1Data();
                        delete pEvent;
                    }
                }
                else
                {
                    call->postMessage(eventMessage);
                }
                messageProcessed = TRUE;
                break;
            }

        default:
            {
                OsSysLog::add(FAC_CP, PRI_ERR, "Unknown PHONE_APP CallManager message subtype: %d\n", msgSubType);
                messageProcessed = TRUE;
                break;
            }
        }
        break;

        // Timer event expired
    case OsMsg::OS_EVENT:
        // Pull out the OsMsg from the user data and post it
        if(msgSubType == OsEventMsg::NOTIFY)
        {
            OsMsg* timerMsg;
            OsTimer* timer;

            ((OsEventMsg&)eventMessage).getUserData((int&)timerMsg);
            ((OsEventMsg&)eventMessage).getEventData((int&)timer);

            if(timer)
            {
#ifdef TEST_PRINT
                int eventMessageType = timerMsg->getMsgType();
                int eventMessageSubType = timerMsg->getMsgSubType();
                OsSysLog::add(FAC_CP, PRI_DEBUG, "CallManager::handleMessage deleting timer for message type: %d %d\n",
                    eventMessageType, eventMessageSubType);
#endif
                timer->stop();
                delete timer;
                timer = NULL;
            }
            if(timerMsg)
            {
                postMessage(*timerMsg);
                delete timerMsg;
                timerMsg = NULL;
            }
        }
        messageProcessed = TRUE;
        break;
#ifndef EXCLUDE_STREAMING
    case OsMsg::STREAMING_MSG:
        {
            // TO_BE_REMOVED
            MpStreamMsg* pMsg = (MpStreamMsg*) &eventMessage ;
            UtlString callId = pMsg->getTarget() ;

            OsReadLock lock(mCallListMutex);
            CpCall* call = findHandlingCall(callId);
            if(!call)
            {
                // If we cannot find the call, then we must clean up
                // and unblock the caller.
                if (  (msgSubType == MpStreamMsg::STREAM_REALIZE_URL) ||
                    (msgSubType == MpStreamMsg::STREAM_REALIZE_BUFFER))
                {
                    OsNotification* pNotifyHandle = (OsNotification*) pMsg->getPtr1() ;
                    Url* pUrl = (Url*) pMsg->getInt2() ;
                    delete pUrl ;
                    pNotifyHandle->signal(0) ;
                }

            }
            else
            {
                call->postMessage(eventMessage);
            }
            
            //assert(false);
            break;
        }
#endif 

    default:
        {
            OsSysLog::add(FAC_CP, PRI_ERR, "Unknown TYPE %d of CallManager message subtype: %d\n", msgType, msgSubType);
            messageProcessed = TRUE;
            break;