cpcall.cpp

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

                // Signal Event so that the caller knows the work is done
                OsProtectedEvent* ev = (OsProtectedEvent*) ((CpMultiStringMessage&)eventMessage).getInt1Data();
                if(OS_ALREADY_SIGNALED == ev->signal(0))
                {
                    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
                    eventMgr->release(ev);
                }
            }
            break;

        case CallManager::CP_DESTROY_PLAYER:
            {
                MpStreamPlayer* pPlayer ;

                addHistoryEvent(msgSubType, multiStringMessage);

                // Redispatch Request to flowgraph
                if(mpMediaInterface)
                {
                    pPlayer = (MpStreamPlayer*) ((CpMultiStringMessage&)eventMessage).getInt2Data();
                    mpMediaInterface->destroyPlayer(pPlayer) ;
                }

                // Signal Event so that the caller knows the work is done
                OsProtectedEvent* ev = (OsProtectedEvent*) ((CpMultiStringMessage&)eventMessage).getInt1Data();
                if(OS_ALREADY_SIGNALED == ev->signal(0))
                {
                    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
                    eventMgr->release(ev);
                }
            }
            break;

        case CallManager::CP_DESTROY_QUEUE_PLAYER:
            {
                MpStreamPlayer* pPlayer ;

                addHistoryEvent(msgSubType, multiStringMessage);

                // Redispatch Request to flowgraph
                if(mpMediaInterface)
                {
                    pPlayer = (MpStreamPlayer*) ((CpMultiStringMessage&)eventMessage).getInt2Data();
                    mpMediaInterface->destroyQueuePlayer((MpStreamQueuePlayer*)pPlayer) ;
                }

                // Signal Event so that the caller knows the work is done
                OsProtectedEvent* ev = (OsProtectedEvent*) ((CpMultiStringMessage&)eventMessage).getInt1Data();
                if(OS_ALREADY_SIGNALED == ev->signal(0))
                {
                    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
                    eventMgr->release(ev);
                }
            }
            break;

        case CallManager::CP_SET_PREMIUM_SOUND_CALL:
            addHistoryEvent(msgSubType, multiStringMessage);
            {
                UtlBoolean enabled = ((CpMultiStringMessage&)eventMessage).getInt1Data();
                mpMediaInterface->setPremiumSound(enabled);
            }
            break;

        case CallManager::CP_DROP:
            addHistoryEvent(msgSubType, multiStringMessage);
            {
                UtlString callId;
                int metaEventId = ((CpMultiStringMessage&)eventMessage).getInt1Data();
                ((CpMultiStringMessage&)eventMessage).getString1Data(callId);

                hangUp(callId, metaEventId);                                         
            }
            break;

        case CallManager::CP_ENABLE_DTMF_EVENT:
            addHistoryEvent(msgSubType, multiStringMessage);
            {
                OsWriteLock lock(mDtmfQMutex);
                int ev = ((CpMultiStringMessage&)eventMessage).getInt1Data();

                assert(mDtmfQLen < MAX_NUM_TONE_LISTENERS);

                int found = dtmfEventExists(ev);
                if (found == -1)
                {
                    mDtmfEvents[mDtmfQLen].event = ev;
                    mDtmfEvents[mDtmfQLen].interdigitSecs = ((CpMultiStringMessage&)eventMessage).getInt2Data();
                    mDtmfEvents[mDtmfQLen].ignoreKeyUp = ((CpMultiStringMessage&)eventMessage).getInt3Data();
                    mDtmfEvents[mDtmfQLen].enabled = TRUE;
                    mDtmfQLen++;
                }
                else
                {
                    mDtmfEvents[found].enabled = TRUE;
                }

            }
            break;
        case CallManager::CP_DISABLE_DTMF_EVENT:
            addHistoryEvent(msgSubType, multiStringMessage);
            {
                OsWriteLock lock(mDtmfQMutex);

                // Temporarily remove the event from list, do not delete it.
                // removeDtmfEvent will/has to/ be called to delete it.
                int ev = ((CpMultiStringMessage&)eventMessage).getInt1Data();
                int found = dtmfEventExists(ev);
                if (found >= 0)
                    mDtmfEvents[found].enabled = FALSE;
            }
            break;

        case CallManager::CP_REMOVE_DTMF_EVENT:
            addHistoryEvent(msgSubType, multiStringMessage);
            {
                OsWriteLock lock(mDtmfQMutex);

                int ev = ((CpMultiStringMessage&)eventMessage).getInt1Data();
                removeFromDtmfEventList(ev);

                // 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.
                OsQueuedEvent* pEvent = (OsQueuedEvent*) ev;
                delete pEvent;
            }
            break;

        case CallManager::CP_EZRECORD:
            addHistoryEvent(msgSubType, multiStringMessage);
            {
                UtlString fileName;
                ((CpMultiStringMessage&)eventMessage).getString2Data(fileName);
                OsProtectedEvent* ev = (OsProtectedEvent*) ((CpMultiStringMessage&)eventMessage).getInt1Data();
                int ms = ((CpMultiStringMessage&)eventMessage).getInt2Data();
                int silenceLength = ((CpMultiStringMessage&)eventMessage).getInt3Data();
                int dtmfterm = ((CpMultiStringMessage&)eventMessage).getInt4Data();

                double duration;
                if (mpMediaInterface)
                {
                    mpMediaInterface->ezRecord(ms, silenceLength, fileName.data(), duration, dtmfterm, ev);
                }

            }
            break;

        case CallManager::CP_STOPRECORD:
            {
                stopRecord();

                OsProtectedEvent* ev = (OsProtectedEvent*) ((CpMultiStringMessage&)eventMessage).getInt1Data();
                if(OS_ALREADY_SIGNALED == ev->signal(0))
                {
                    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
                    eventMgr->release(ev);
                }
            }
            break;
        default:
            processedMessage = handleCallMessage(eventMessage);
            break;
        }

        break;

    case OsMsg::OS_EVENT:
        {
            switch(msgSubType)
            {
            case OsEventMsg::NOTIFY:
                {
                    int eventData;
                    int pListener;
                    ((OsEventMsg&)eventMessage).getEventData(eventData);
                    ((OsEventMsg&)eventMessage).getUserData(pListener);
                    if (pListener)
                    {
                        char    buf[128];
                        UtlString arg;
                        int argCnt = 2;
                        int i;

                        getCallId(arg);
                        arg.append(TAOMESSAGE_DELIMITER);
                        sprintf(buf, "%d", eventData);
                        arg.append(buf);

                        for (i = 0; i < mToneListenerCnt; i++)
                        {
                            if (mpToneListeners[i] && (mpToneListeners[i]->mpListenerPtr == pListener))
                            {
                                arg.append(TAOMESSAGE_DELIMITER);
                                arg.append(mpToneListeners[i]->mName);
                                argCnt = 3;

                                // post the dtmf event
                                int eventId = TaoMessage::BUTTON_PRESS;

                                TaoMessage msg(TaoMessage::EVENT,
                                    0,
                                    0,
                                    eventId,
                                    0,
                                    argCnt,
                                    arg);

                                ((OsServerTask*)pListener)->postMessage((OsMsg&)msg);
                            }
                        }

                        // respond to the waitforDtmfTone event
                        {
                            OsWriteLock lock(mDtmfQMutex);

                            OsSysLog::add(FAC_CP, PRI_INFO, "CpCall %s - received dtmf event 0x%08x QLen=%d\n",
                                mCallId.data(), eventData, mDtmfQLen);

                            for (i = 0; i < mDtmfQLen; i++)
                            {
                                if (mDtmfEvents[i].enabled == FALSE)
                                {
                                    OsSysLog::add(FAC_CP, PRI_INFO, "CpCall %s - event %p is disabled\n",
                                        mCallId.data(), &mDtmfEvents[i]);
                                    continue;
                                }

                                if (mDtmfEvents[i].ignoreKeyUp && (eventData & 0x80000000))
                                {
                                    OsSysLog::add(FAC_CP, PRI_INFO, "CpCall %s - ignore KEYUP event 0x%08x\n",
                                        mCallId.data(), eventData);
                                    continue; // ignore keyup event
                                }

                                if ((eventData & 0x80000000) == 0 &&
                                    (eventData & 0x0000ffff))
                                {
                                    OsSysLog::add(FAC_CP, PRI_INFO, "CpCall %s - ignore KEYDOWN event 0x%08x\n",
                                        mCallId.data(), eventData);
                                    continue; // previous key still down, ignore long key event
                                }
                                OsQueuedEvent* dtmfEvent = (OsQueuedEvent*)(mDtmfEvents[i].event);
                                if (dtmfEvent)
                                {
                                    OsStatus res = dtmfEvent->signal((eventData & 0xfffffff0));
                                    // There could be a race condition in media server
                                    // where the receiving msgq can be processing an event from the
                                    // playerlistener and this event is signaled before the queue is reset,
                                    // so we'll try to send a few more times until success.
                                    int tries = 0;
                                    while ((tries++ < 10) && (res != OS_SUCCESS))
                                    {
                                        res = dtmfEvent->signal((eventData & 0xfffffff0));
                                        OsSysLog::add(FAC_CP, PRI_INFO, "CpCall %s - resend dtmfEvent event 0x%08x to %p, res=%d\n",
                                            mCallId.data(), eventData, dtmfEvent, res);
                                    }
                                    if (res != OS_SUCCESS && tries >= 10)
                                    {
                                        OsSysLog::add(FAC_CP, PRI_ERR, "CpCall %s - failed to notify DTMF event 0x%08x to %p, res=%d\n",
                                            mCallId.data(), eventData, dtmfEvent, res);
                                    }
                                }
                            }
                        }
                    }

                }
                break;

            default:
                processedMessage = FALSE;
                osPrintf("Unknown TYPE %d of Call message subtype: %d\n", msgType, msgSubType);
                break;
            }
        }
        break ;

    case OsMsg::STREAMING_MSG:
        if (mpMediaInterface)
        {
            mpMediaInterface->getMsgQ()->send(eventMessage) ;
        }
        break ;

    default:
        processedMessage = FALSE;
        osPrintf("Unknown TYPE %d of Call message subtype: %d\n", msgType, msgSubType);
        break;
    }

    //    osPrintf("exiting CpCall::handleMessage\n");
    return(processedMessage);
}

void CpCall::inFocus(int talking)
{

    mCallInFocus = TRUE;
    mLocalConnectionState = PtEvent::CONNECTION_ESTABLISHED;

    if (talking)
        mLocalTermConnectionState = PtTerminalConnection::TALKING;
    else
        mLocalTermConnectionState = PtTerminalConnection::IDLE;

    if(mpMediaInterface)
    {
        mpMediaInterface->giveFocus();
    }


}

void CpCall::outOfFocus()
{
    mCallInFocus = FALSE;
    //      mLocalConnectionState = PtEvent::CONNECTION_QUEUED;
    //      mLocalTermConnectionState = PtTerminalConnection::HELD;

    if(mpMediaInterface)
    {
        mpMediaInterface->defocus();
    }
}

void CpCall::localHold()
{
    if(!mLocalHeld)
    {
        mLocalHeld = TRUE;
        // Post a message to the callManager to change focus
        CpIntMessage localHoldMessage(CallManager::CP_YIELD_FOCUS,
            (int)this);
        mpManager->postMessage(localHoldMessage);

        mLocalTermConnectionState = PtTerminalConnection::HELD;
    }
}

void CpCall::hangUp(UtlString callId, int metaEventId)
{
#ifdef TEST_PRINT
    osPrintf("CpCall::hangUp\n");
#endif
    mDropping = TRUE;
    mLocalConnectionState = PtEvent::CONNECTION_DISCONNECTED;

    mLocalTermConnectionState = PtTerminalConnection::DROPPED;

    if (metaEventId > 0)
        setMetaEvent(metaEventId, PtEvent::META_CALL_ENDING, 0, 0);
    else
        startMetaEvent(mpManager->getNewMetaEventId(), PtEvent::META_CALL_ENDING, 0, 0);

    onHook();
}


OsStatus CpCall::addTaoListener(OsServerTask* pListener,
                                char* callId,
                                int connectId,
                                int mask,
                                int pEv)
{
    return addListener(pListener,
        mpListeners,
        mListenerCnt,
        callId,
        connectId,
        mask,
        pEv);

}

void CpCall::setLocalConnectionState(int newState)
{
    mLocalConnectionState = newState;
}

OsStatus CpCall::stopRecord()
{
#ifdef TEST_PRINT
    osPrintf("Calling mpMediaInterface->stopRecording()\n");
    OsSysLog::add(FAC_CP, PRI_DEBUG, "Calling mpMediaInterface->stopRecording()");
#endif
    return mpMediaInterface->stopRecording();
}

OsStatus CpCall::ezRecord(int ms, int silenceLength, const char* fileName, double& duration, int& dtmfterm)
{
    return mpMediaInterface->ezRecord(ms, silenceLength, fileName, duration, dtmfterm);
}

void CpCall::addToneListenerToFlowGraph(int pListener, Connection* connection)
{
    OsQueuedEvent *pEv;
    pEv = new OsQueuedEvent(mIncomingQ, pListener);

    UtlString remoteAddress;
    connection->getRemoteAddress(&remoteAddress);

    addListener((OsServerTask*) pListener,
        mpToneListeners,
        mToneListenerCnt,
        (char*)remoteAddress.data(),
        connection->getConnectionId(),
        0,
        (int)pEv);

    mpMediaInterface->addToneListener(pEv, connection->getConnectionId());
}


void CpCall::removeToneListenerFromFlowGraph(int pListener, Connection* connection)
{
    mpMediaInterface->removeToneListener(connection->getConnectionId()) ;
}



/* ============================ ACCESSORS ================================= */

int CpCall::getCallIndex()
{