cpcall.cpp

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

//
// Copyright (C) 2004, 2005 Pingtel Corp.
// 
//
// $$
////////////////////////////////////////////////////////////////////////
//////



// SYSTEM INCLUDES
#include <assert.h>
#include <stdlib.h>

// APPLICATION INCLUDES
#include <os/OsReadLock.h>
#include <os/OsWriteLock.h>
#include <os/OsQueuedEvent.h>
#include <os/OsEventMsg.h>
#include "os/OsSysLog.h"
#include <cp/CpCall.h>
#include <mi/CpMediaInterface.h>
#include <cp/CpMultiStringMessage.h>
#include <cp/Connection.h>
#include <cp/CpIntMessage.h>
#include "ptapi/PtConnection.h"
#include "ptapi/PtCall.h"
#include "ptapi/PtTerminalConnection.h"
#include "tao/TaoProviderAdaptor.h"
#include "tao/TaoListenerEventMessage.h"

// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
#define CALL_STACK_SIZE (32*1024)    // 32K stack for the call task
#       define LOCAL_ONLY 0
#       define LOCAL_AND_REMOTE 1
#define UI_TERMINAL_CONNECTION_STATE "TerminalConnectionState"
#define UI_CONNECTION_STATE "ConnectionState"

//#define debugNew(x)   osPrintf("new 0x%08x: %s/%d\n", (int)x, __FILE__, __LINE__);
//#define debugDelete(x)        osPrintf("delete 0x%08x: %s/%d\n", (int)x, __FILE__, __LINE__);

// STATIC VARIABLE INITIALIZATIONS
OsLockingList *CpCall::spCallTrackingList = NULL;

/* //////////////////////////// PUBLIC //////////////////////////////////// */

/* ============================ CREATORS ================================== */

// Constructor
CpCall::CpCall(CpCallManager* manager,
               CpMediaInterface* callMediaInterface,
               int callIndex,
               const char* callId,
               int holdType) :
OsServerTask("Call-%d", NULL, DEF_MAX_MSGS, DEF_PRIO, DEF_OPTIONS, CALL_STACK_SIZE),
mCallIdMutex(OsMutex::Q_FIFO),
mDtmfQMutex(OsMutex::Q_FIFO)
{
    // add the call task name to a list so we can track leaked calls.
    UtlString strCallTaskName = getName();
    addToCallTrackingList(strCallTaskName);

    mCallInFocus = FALSE;
    mRemoteDtmf = FALSE;
    mDtmfEnabled = FALSE;

    mpManager = manager;

    mDropping = FALSE;
    mLocalHeld = FALSE;

    mCallIndex = callIndex;
    if(callId && callId[0])
    {
        setCallId(callId);
    }
    mHoldType = holdType;
    if(mHoldType < CallManager::NEAR_END_HOLD ||
        mHoldType > CallManager::FAR_END_HOLD)
    {
        mHoldType = CallManager::NEAR_END_HOLD;
    }

    mDtmfQLen = 0;
    mListenerCnt = 0;
    mToneListenerCnt = 0;
    mMaxNumListeners = 20;
    mpListeners = (TaoListenerDb**) malloc(sizeof(TaoListenerDb *)*mMaxNumListeners);

    if (!mpListeners)
    {
        osPrintf("***** ERROR ALLOCATING LISTENERS IN CPCALL **** \n");
        return;
    }

    int i;

    for ( i = 0; i < mMaxNumListeners; i++)
        mpListeners[i] = 0;


    for (i = 0; i < MAX_NUM_TONE_LISTENERS; i++)
        mpToneListeners[i] = 0;

    // Create the media processing channel
    mpMediaInterface = callMediaInterface;

    mCallState = PtCall::IDLE;
    mLocalConnectionState = PtEvent::CONNECTION_IDLE;
    mLocalTermConnectionState = PtTerminalConnection::IDLE;

    // Meta event intitialization
    mMetaEventId = 0;
    mMetaEventType = PtEvent::META_EVENT_NONE;
    mNumMetaEventCalls = 0;
    mpMetaEventCallIds = NULL;
    mMessageEventCount = -1;

    UtlString name = getName();
#ifdef TEST_PRINT
    OsSysLog::add(FAC_CP, PRI_DEBUG, "%s Call constructed: %s\n", name.data(), mCallId.data());
    osPrintf("%s constructed: %s\n", name.data(), mCallId.data());
#endif
}

// Destructor
CpCall::~CpCall()
{
    if (isStarted())
    {
        waitUntilShutDown();
    }
    // remove the call task name from the list (for tracking leaked calls)
    UtlString strCallTaskName = getName();
    removeFromCallTrackingList(strCallTaskName);

    if(mpMediaInterface)
    {
        mpMediaInterface->release();
        mpMediaInterface = NULL;
    }

    if (mListenerCnt > 0)  // check if listener exists.
    {
        for (int i = 0; i < mListenerCnt; i++)
        {
            if (mpListeners[i])
            {
                delete mpListeners[i];
                mpListeners[i] = 0;
            }
        }
        
    }
    if (mpListeners)
    {
        free(mpListeners);
        mpListeners = NULL;
    }

    if (mToneListenerCnt > 0)  // check if listener exists.
    {
        for (int i = 0; i < mToneListenerCnt; i++)
        {
            if (mpToneListeners[i])
            {
                OsQueuedEvent *pEv = (OsQueuedEvent *) mpToneListeners[i]->mIntData;
                if (pEv)
                    delete pEv;
                delete mpToneListeners[i];
                mpToneListeners[i] = 0;
            }
        }
    }

    if(mpMetaEventCallIds)
    {
        //for(int i = 0; i < mNumMetaEventCalls; i++)
        //{
        //    if(mpMetaEventCallIds[i]) delete mpMetaEventCallIds[i];
        //    mpMetaEventCallIds[1] = NULL;
        //}
        delete[] mpMetaEventCallIds;
        mpMetaEventCallIds = NULL;
    }

    UtlString name = getName();
#ifdef TEST_PRINT
    OsSysLog::add(FAC_CP, PRI_DEBUG, "%s destructed: %s\n", name.data(), mCallId.data());
    osPrintf("%s destructed: %s\n", name.data(), mCallId.data());
#endif
    name.remove(0);
    mCallId.remove(0);
    mOriginalCallId.remove(0);
    mTargetCallId.remove(0);

}

/* ============================ MANIPULATORS ============================== */

void CpCall::setDropState(UtlBoolean state)
{
    mDropping = state;
}

void CpCall::setCallState(int responseCode, UtlString responseText, int state, int casue)
{
    if (state != mCallState)
    {
        switch(state)
        {
        case PtCall::INVALID:
            postTaoListenerMessage(responseCode, responseText, PtEvent::CALL_INVALID, CALL_STATE, casue);
            break;

        case PtCall::ACTIVE:
            postTaoListenerMessage(responseCode, responseText, PtEvent::CALL_ACTIVE, CALL_STATE, casue);
            break;

        default:
            break;
        }
    }

    mCallState = state;
}

UtlBoolean CpCall::handleMessage(OsMsg& eventMessage)
{
    int msgType = eventMessage.getMsgType();
    int msgSubType = eventMessage.getMsgSubType();
    //int key;
    //int hookState;
    CpMultiStringMessage* multiStringMessage = (CpMultiStringMessage*)&eventMessage;

    UtlBoolean processedMessage = TRUE;
    OsSysLog::add(FAC_CP, PRI_DEBUG, "CpCall::handleMessage message type: %d subtype %d\n", msgType, msgSubType);

    switch(msgType)
    {

    case OsMsg::PHONE_APP:

        switch(msgSubType)
        {
            // If these cases need to be overrided,  they should
            // be broken out into virutal methods
        case CallManager::CP_START_TONE_TERM_CONNECTION:
            addHistoryEvent(msgSubType, multiStringMessage);
            {
                int toneId = ((CpMultiStringMessage&)eventMessage).getInt1Data();
                UtlBoolean local = ((CpMultiStringMessage&)eventMessage).getInt2Data();
                UtlBoolean remote = ((CpMultiStringMessage&)eventMessage).getInt3Data();

                if(mpMediaInterface)
                {
                    mpMediaInterface->startTone(toneId,
                    local, remote);
                }
            }
            break;

        case CallManager::CP_STOP_TONE_TERM_CONNECTION:
            addHistoryEvent(msgSubType, multiStringMessage);
            if(mpMediaInterface)
            {
                mpMediaInterface->stopTone();
            }
            break;

        case CallManager::CP_PLAY_AUDIO_TERM_CONNECTION:
            addHistoryEvent(msgSubType, multiStringMessage);
            {
                int repeat = ((CpMultiStringMessage&)eventMessage).getInt1Data();
                UtlBoolean local = ((CpMultiStringMessage&)eventMessage).getInt2Data();
                UtlBoolean remote = ((CpMultiStringMessage&)eventMessage).getInt3Data();
                UtlString url;
                ((CpMultiStringMessage&)eventMessage).getString2Data(url);

                if(mpMediaInterface)
                {
                    mpMediaInterface->playAudio(url.data(), repeat,
                        local, remote);
                }
                url.remove(0);
            }
            break;

        case CallManager::CP_PLAY_BUFFER_TERM_CONNECTION:
            addHistoryEvent(msgSubType, multiStringMessage);
            {
                int repeat = ((CpMultiStringMessage&)eventMessage).getInt2Data();
                UtlBoolean local = ((CpMultiStringMessage&)eventMessage).getInt3Data();
                UtlBoolean remote = ((CpMultiStringMessage&)eventMessage).getInt4Data();
                int buffer = ((CpMultiStringMessage&)eventMessage).getInt5Data();
                int bufSize = ((CpMultiStringMessage&)eventMessage).getInt6Data();
                int type = ((CpMultiStringMessage&)eventMessage).getInt7Data();
                OsProtectedEvent* ev = (OsProtectedEvent*) ((CpMultiStringMessage&)eventMessage).getInt1Data();

                if(mpMediaInterface)
                {
                    mpMediaInterface->playBuffer((char*)buffer,
                    bufSize, type, repeat, local, remote, ev);
                }
            }
            break;

        case CallManager::CP_STOP_AUDIO_TERM_CONNECTION:
            addHistoryEvent(msgSubType, multiStringMessage);
            if(mpMediaInterface)
            {
                mpMediaInterface->stopAudio();
            }
            break;

        case CallManager::CP_CREATE_PLAYLIST_PLAYER:
            {
                UtlString callId;

                MpStreamPlaylistPlayer** ppPlayer = (MpStreamPlaylistPlayer **) ((CpMultiStringMessage&)eventMessage).getInt2Data();
                assert(ppPlayer != NULL);

                OsProtectedEvent* ev = (OsProtectedEvent*) ((CpMultiStringMessage&)eventMessage).getInt1Data();
#ifdef TEST_PRINT
                OsSysLog::add(FAC_CP, PRI_DEBUG,
                    "CpCall::handle creating MpStreamPlaylistPlayer ppPlayer 0x%08x ev 0x%08x",
                    (int)ppPlayer, (int)ev);
#endif

                addHistoryEvent(msgSubType, multiStringMessage);

                getCallId(callId);

                if (mpMediaInterface)
                {
                    mpMediaInterface->createPlaylistPlayer(ppPlayer, mpManager->getMessageQueue(), callId.data()) ;
                }

                if(OS_ALREADY_SIGNALED == ev->signal(0))
                {
                    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
                    eventMgr->release(ev);
                }
            }
            break;

        case CallManager::CP_CREATE_PLAYER:
            {
                UtlString callId;
                UtlString streamId ;

                MpStreamPlayer** ppPlayer = (MpStreamPlayer **) ((CpMultiStringMessage&)eventMessage).getInt2Data();

                assert(ppPlayer != NULL);

                OsProtectedEvent* ev = (OsProtectedEvent*) ((CpMultiStringMessage&)eventMessage).getInt1Data();
                int flags = ((CpMultiStringMessage&)eventMessage).getInt3Data();
#ifdef TEST_PRINT
                OsSysLog::add(FAC_CP, PRI_DEBUG,
                    "CpCall::handle creating MpStreamPlayer ppPlayer 0x%08x ev 0x%08x flags %d",
                    (int)ppPlayer, (int)ev, flags);
#endif

                addHistoryEvent(msgSubType, multiStringMessage);

                ((CpMultiStringMessage&)eventMessage).getString2Data(streamId);
                getCallId(callId);

                if (mpMediaInterface)
                {
                    mpMediaInterface->createPlayer((MpStreamPlayer**)ppPlayer, streamId, flags, mpManager->getMessageQueue(), callId.data()) ;
                }
                if(OS_ALREADY_SIGNALED == ev->signal(0))
                {
                    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
                    eventMgr->release(ev);
                }
            }
            break;

        case CallManager::CP_CREATE_QUEUE_PLAYER:
            {
                UtlString callId;

                MpStreamPlayer** ppPlayer = (MpStreamPlayer **) ((CpMultiStringMessage&)eventMessage).getInt2Data();

                assert(ppPlayer != NULL);

                OsProtectedEvent* ev = (OsProtectedEvent*) ((CpMultiStringMessage&)eventMessage).getInt1Data();
#ifdef TEST_PRINT
                OsSysLog::add(FAC_CP, PRI_DEBUG,
                    "CpCall::handle creating MpStreamQueuePlayer ppPlayer 0x%08x ev 0x%08x",
                    (int)ppPlayer, (int)ev);
#endif

                addHistoryEvent(msgSubType, multiStringMessage);

                getCallId(callId);

                if (mpMediaInterface)
                {
                    mpMediaInterface->createQueuePlayer((MpStreamQueuePlayer**)ppPlayer, mpManager->getMessageQueue(), callId.data()) ;
                }

                if(OS_ALREADY_SIGNALED == ev->signal(0))
                {
                    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
                    eventMgr->release(ev);
                }
            }
            break;

        case CallManager::CP_DESTROY_PLAYLIST_PLAYER:
            {
                MpStreamPlaylistPlayer* pPlayer ;

                addHistoryEvent(msgSubType, multiStringMessage);

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