callmanager.cpp

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

        {
            status = PT_SUCCESS  ;
        } 
    }
    else
    {
        OsSysLog::add(FAC_CP, PRI_ERR, "CallManager::split TIMED OUT\n");
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == splitSuccess->signal(0))
        {
            eventMgr->release(splitSuccess);
        }
    }

    return status ;
}


// Blind transfer?
PtStatus CallManager::transfer_blind(const char* callId, const char* transferToUrl,
                                     UtlString* targetConnectionCallId,
                                     UtlString* targetConnectionAddress,
                                     bool       remoteHoldBeforeTransfer
                                     )
{
    UtlString transferTargetUrl(transferToUrl ? transferToUrl : "");

    PtStatus returnCode = validateAddress(transferTargetUrl);

    if(returnCode == PT_SUCCESS)
    {
        if(targetConnectionAddress)
            *targetConnectionAddress = transferToUrl;
        UtlString targetCallId;
        getNewCallId(&targetCallId);
        if(targetConnectionCallId)
            *targetConnectionCallId = targetCallId;

#ifdef TEST_PRINT
        OsSysLog::add(FAC_CP, PRI_DEBUG, "CallManager::transfer type: %d transferUrl: \"%s\"\n",
            mTransferType, transferTargetUrl.data());
#endif

        // CP_BLIND_TRANSFER (i.e. two call blind transfer)
        CpMultiStringMessage transferMessage(CP_BLIND_TRANSFER,
                                             callId,
                                             transferTargetUrl,
                                             targetCallId.data(),
                                             NULL,
                                             NULL,
                                             /* int1 */ getNewMetaEventId(),
                                             /* int2 */ remoteHoldBeforeTransfer);

        postMessage(transferMessage);
    }
    return(returnCode);
}

void CallManager::toneStart(const char* callId, int toneId, UtlBoolean local, UtlBoolean remote)
{
    CpMultiStringMessage startToneMessage(CP_START_TONE_TERM_CONNECTION,
        callId, NULL, NULL, NULL, NULL,
        toneId, local, remote);

    postMessage(startToneMessage);
}

void CallManager::toneStop(const char* callId)
{
    CpMultiStringMessage stopToneMessage(CP_STOP_TONE_TERM_CONNECTION, callId);
    postMessage(stopToneMessage);
}

void CallManager::audioPlay(const char* callId, const char* audioUrl, UtlBoolean repeat, UtlBoolean local, UtlBoolean remote)
{
    CpMultiStringMessage startToneMessage(CP_PLAY_AUDIO_TERM_CONNECTION,
        callId, audioUrl, NULL, NULL, NULL,
        repeat, local, remote);

    postMessage(startToneMessage);
}

void CallManager::bufferPlay(const char* callId, int audioBuf, int bufSize, int type, UtlBoolean repeat, UtlBoolean local, UtlBoolean remote)
{
    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
     OsProtectedEvent* ev = eventMgr->alloc();
    int sTimeout = bufSize / 8000;
    if (sTimeout < CP_MAX_EVENT_WAIT_SECONDS)
      sTimeout = CP_MAX_EVENT_WAIT_SECONDS;

    OsTime maxEventTime(sTimeout, 0);

    CpMultiStringMessage startToneMessage(CP_PLAY_BUFFER_TERM_CONNECTION,
       callId, NULL, NULL, NULL, NULL,
       (int)ev, repeat, local, remote, audioBuf, bufSize, type);

    postMessage(startToneMessage);
}

void CallManager::audioStop(const char* callId)
{
    CpMultiStringMessage stopAudioMessage(CP_STOP_AUDIO_TERM_CONNECTION, callId);
    postMessage(stopAudioMessage);
}

void CallManager::stopPremiumSound(const char* callId)
{
    CpMultiStringMessage premiumSoundMessage(CP_SET_PREMIUM_SOUND_CALL,
        callId, NULL, NULL, NULL, NULL, // strings
        FALSE); // Disabled
    postMessage(premiumSoundMessage);
}

OsStatus CallManager::setCallMediaProperty(const char* callId,
                                           const char* propertyName,
                                           const char* propertyValue)
{
    CpMultiStringMessage mediaPropertyMessage(CP_SET_MEDIA_PROPERTY,
        callId,
        NULL, // no remote address as this is to the general CpMediaInterface
        propertyName,
        propertyValue);
    postMessage(mediaPropertyMessage);
    return(OS_SUCCESS);  // For now now error checking
}

#ifndef EXCLUDE_STREAMING
void CallManager::createPlayer(const char* callId,
                               MpStreamPlaylistPlayer** ppPlayer)
{
    // TO_BE_REMOVED
    OsSysLog::add(FAC_CP, PRI_DEBUG, "CallManager::createPlayer(MpStreamPlaylistPlayer) for call %s",
                  callId);
    int msgtype = CP_CREATE_PLAYLIST_PLAYER;;

    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
    OsProtectedEvent* ev = eventMgr->alloc();
    OsTime maxEventTime(CP_MAX_EVENT_WAIT_SECONDS, 0);

    CpMultiStringMessage msg(msgtype,
        callId, NULL, NULL, NULL, NULL, // strings
        (int)ev, (int) ppPlayer, 0); // ints

    postMessage(msg);

    // Wait until the player is created by CpCall
    if(ev->wait(0, maxEventTime) != OS_SUCCESS)
    {
        OsSysLog::add(FAC_CP, PRI_ERR, "CallManager::createPlayer(MpStreamPlaylistPlayer) TIMED OUT\n");

        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == ev->signal(0))
        {
            eventMgr->release(ev);
        }
    }
    else
    {
        eventMgr->release(ev);
    }
    
    //assert(false);
}

void CallManager::createPlayer(int type,
                               const char* callId,
                               const char* szStream,
                               int flags,
                               MpStreamPlayer** ppPlayer)
{
    // TO_BE_REMOVED
    int msgtype;

    switch (type)
    {
    case MpPlayer::STREAM_QUEUE_PLAYER:
        msgtype = CP_CREATE_QUEUE_PLAYER;
        break;

    case MpPlayer::STREAM_PLAYER:
    default:
        msgtype = CP_CREATE_PLAYER;
        break;
    }

    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
    OsProtectedEvent* ev = eventMgr->alloc();
    OsTime maxEventTime(CP_MAX_EVENT_WAIT_SECONDS, 0);
    CpMultiStringMessage msg(msgtype,
        callId, szStream, NULL, NULL, NULL, // strings
        (int)ev, (int) ppPlayer, flags);   // ints

    postMessage(msg);

    // Wait until the player is created by CpCall
    if(ev->wait(0, maxEventTime) != OS_SUCCESS)
    {
        OsSysLog::add(FAC_CP, PRI_ERR, "CallManager::createPlayer TIMED OUT\n");

        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == ev->signal(0))
        {
            eventMgr->release(ev);
        }
    }
    else
    {
        eventMgr->release(ev);
    }
    
    //assert(false);
}


void CallManager::destroyPlayer(const char* callId, MpStreamPlaylistPlayer* pPlayer)
{
    // TO_BE_REMOVED
    OsSysLog::add(FAC_CP, PRI_DEBUG, "CallManager::destroyPlayer(MpStreamPlaylistPlayer) for call %s",
                  callId);
    int msgtype = CP_DESTROY_PLAYLIST_PLAYER;

    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
    OsProtectedEvent* ev = eventMgr->alloc();
    OsTime maxEventTime(CP_MAX_EVENT_WAIT_SECONDS, 0);

    CpMultiStringMessage msg(msgtype,
        callId, NULL, NULL, NULL, NULL, // strings
        (int) ev, (int) pPlayer);   // ints

    postMessage(msg);

    // Wait until the player is created by CpCall
    if(ev->wait(0, maxEventTime) != OS_SUCCESS)
    {
        OsSysLog::add(FAC_CP, PRI_ERR, "CallManager::destroyPlayer(MpStreamPlaylistPlayer) TIMED OUT\n");

        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == ev->signal(0))
        {
            eventMgr->release(ev);
        }
    }
    else
    {
        eventMgr->release(ev);
    }

    // Delete the object
    delete pPlayer;
    
    //assert(false);
}


void CallManager::destroyPlayer(int type, const char* callId, MpStreamPlayer* pPlayer)
{
    // TO_BE_REMOVED
    int msgtype;
    switch (type)
    {
    case MpPlayer::STREAM_QUEUE_PLAYER:
        msgtype = CP_DESTROY_QUEUE_PLAYER;
        break;

    case MpPlayer::STREAM_PLAYER:
    default:
        msgtype = CP_DESTROY_PLAYER;
        break;
    }

    OsProtectEventMgr* eventMgr = OsProtectEventMgr::getEventMgr();
    OsProtectedEvent* ev = eventMgr->alloc();
    OsTime maxEventTime(CP_MAX_EVENT_WAIT_SECONDS, 0);

    CpMultiStringMessage msg(msgtype,
        callId, NULL, NULL, NULL, NULL, // strings
        (int) ev, (int) pPlayer);   // ints

    postMessage(msg);

    // Wait until the player is created by CpCall
    if(ev->wait(0, maxEventTime) != OS_SUCCESS)
    {
        OsSysLog::add(FAC_CP, PRI_ERR, "CallManager::destroyPlayer TIMED OUT\n");

        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == ev->signal(0))
        {
            eventMgr->release(ev);
        }
    }
    else
    {
        eventMgr->release(ev);
    }

    // Delete the object
    switch (type)
    {
    case MpPlayer::STREAM_QUEUE_PLAYER:
        delete (MpStreamQueuePlayer*) pPlayer ;
        break;
    case MpPlayer::STREAM_PLAYER:
    default:
        pPlayer->waitForDestruction() ;
        delete pPlayer ;
        break;
    }
    
    //assert(false);
}
#endif

void CallManager::setOutboundLineForCall(const char* callId, const char* address, CONTACT_TYPE eType)
{
    CpMultiStringMessage outboundLineMessage(CP_SET_OUTBOUND_LINE, callId, 
            address, NULL, NULL, NULL, (int) eType);

    postMessage(outboundLineMessage);
}

void CallManager::acceptConnection(const char* callId,
                                   const char* address, 
                                   CONTACT_TYPE contactType,
                                   const void* hWnd)
{
    CpMultiStringMessage acceptMessage(CP_ACCEPT_CONNECTION, callId, address, NULL, NULL, NULL, (int) contactType, (int) hWnd);
    postMessage(acceptMessage);
}



void CallManager::rejectConnection(const char* callId, const char* address)
{
    CpMultiStringMessage acceptMessage(CP_REJECT_CONNECTION, callId, address);
    postMessage(acceptMessage);
}

PtStatus CallManager::redirectConnection(const char* callId, const char* address,
                                         const char* forwardAddress)
{
    UtlString forwardAddressUrl(forwardAddress ? forwardAddress : "");
    PtStatus returnCode = validateAddress(forwardAddressUrl);

    if(returnCode == PT_SUCCESS)
    {
        CpMultiStringMessage acceptMessage(CP_REDIRECT_CONNECTION, callId, address,
            forwardAddressUrl.data());
        postMessage(acceptMessage);
    }
    return(returnCode);
}

void CallManager::dropConnection(const char* callId, const char* address)
{
    CpMultiStringMessage acceptMessage(CP_DROP_CONNECTION, callId, address);
    postMessage(acceptMessage);
}

void CallManager::getNumConnections(const char* callId, int& numConnections)
{
    OsProt