ptcall.cpp

来自「基于sipfoundy 公司开发的sipx协议API」· C++ 代码 · 共 1,686 行 · 第 1/4 页

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


// SYSTEM INCLUDES
#include <assert.h>

#ifdef __pingtel_on_posix__
#include <stdlib.h>
#endif

// APPLICATION INCLUDES
#include "cp/CpGatewayManager.h"
#include "ptapi/PtTerminalConnection.h"
#include "ptapi/PtAddress.h"
#include "ptapi/PtCall.h"
#include "ptapi/PtTerminal.h"
#include "ptapi/PtProvider.h"
#include "ptapi/PtCallListener.h"
#include "ptapi/PtConnection.h"
#include "tao/TaoClientTask.h"
#include "tao/TaoServerTask.h"
#include "tao/TaoEvent.h"
#include "tao/TaoString.h"
#include "tao/TaoReference.h"


// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
//#define EVENT_TRACE(x) osPrintf(x)
// STATIC VARIABLE INITIALIZATIONS
OsBSem               PtCall::semInit(OsBSem::Q_PRIORITY, OsBSem::FULL) ;
TaoReference            *PtCall::mpTransactionCnt = 0;
int                                      PtCall::mRef = 0;

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

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

// Constructor
PtCall::PtCall()
{
        mpClient = 0 ;
    mState = IDLE;
        mpConfController = 0;

        initialize() ;

}

// Copy constructor
PtCall::PtCall(const PtCall& rPtCall)
{
        mCallId = rPtCall.mCallId;
        mpClient = rPtCall.mpClient;
        mState = rPtCall.mState;
        mpConfController = rPtCall.mpConfController;

        initialize();
}

PtCall::PtCall(TaoClientTask *pClient, const char* callId)
{
        mpClient   = pClient;

        mCallId.remove(0);
        if (callId)
                mCallId = callId;

        initialize();

        if (mpClient && !(mpClient->isStarted()))
        {
                mpClient->start();
        }
    mState = ACTIVE;
        mpConfController = 0;

}

PtCall::~PtCall()
{
        semInit.acquire() ;
        mRef--;
        if (mRef < 1)
        {
                if(mpTransactionCnt)
                {
                        delete mpTransactionCnt;
                        mpTransactionCnt = 0;
                }
        }

    semInit.release() ;

}

void PtCall::initialize()
{
        mpEventMgr = OsProtectEventMgr::getEventMgr();
        mTimeOut = OsTime(PT_CONST_EVENT_WAIT_TIMEOUT, 0);
    semInit.acquire() ;
        mRef++;

        if (!mpTransactionCnt)
                mpTransactionCnt = new TaoReference();

    semInit.release() ;

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

// Assignment operator
PtCall&
PtCall::operator=(const PtCall& rhs)
{
   if (this == &rhs)            // handle the assignment to self case
      return *this;

        mCallId.remove(0);
        mCallId = rhs.mCallId;
        mpClient = rhs.mpClient;
        mState = rhs.mState;
        mpConfController = rhs.mpConfController;
        mTimeOut = rhs.mTimeOut;

        return *this;
}

PtStatus PtCall::addCallListener(PtCallListener& rCallListener)
{
        EVENT_TRACE("Entering PtCall::addCallListener:\n") ;

        if (!mpClient)
        {
                return PT_NOT_FOUND;
        }

        TaoObjHandle handle = (TaoObjHandle) &rCallListener;
        UtlString name;
        UtlString arg;

        if (PT_SUCCESS == rCallListener.getLocation(&name)) // must have the terminal name
        {
                arg = name.data() + TAOMESSAGE_DELIMITER + mCallId;
        }
        else
                return PT_INVALID_ARGUMENT;

        mpTransactionCnt->add();
        unsigned int transactionId = mpTransactionCnt->getRef();

        OsProtectedEvent *pe = mpEventMgr->alloc();

        if (pe == 0)
                return PT_RESOURCE_UNAVAILABLE;

        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::ADD_CALL_LISTENER,
                                                                        transactionId,
                                                                        (TaoObjHandle)handle,
                                                                        (TaoObjHandle)pe,
                                                                        2,
                                                                        arg);
        mpClient->sendRequest(msg);

        int rc;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getEventData((int &)rc);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::ADD_CALL_LISTENER);
#endif
        mpEventMgr->release(pe);

        mpClient->addEventListener(&rCallListener, mCallId.data());

        EVENT_TRACE("Exiting PtCall::addCallListener:\n") ;
        return PT_SUCCESS;
}

PtStatus PtCall::addParty(const char* newPartyURL,
                     PtSessionDesc* pSessionDesc,
                     PtConnection& rConnection)
{
        EVENT_TRACE("Entering PtCall::addParty:\n") ;
        if (!newPartyURL)
                return PT_INVALID_ARGUMENT;

    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

    sprintf(buff, "%d", (int)pSessionDesc);
        UtlString arg;
        arg = newPartyURL + TAOMESSAGE_DELIMITER + buff
                        + TAOMESSAGE_DELIMITER + mCallId;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::ADD_PARTY,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        3,
                                                                        arg);
        mpClient->sendRequest(msg);

        int rc;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        UtlString retCode;
        pe->getEventData((int &)rc);
        pe->getStringData(retCode);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::ADD_PARTY);
#endif
        mpEventMgr->release(pe);

        rConnection = PtConnection(mpClient, newPartyURL, mCallId.data());

        EVENT_TRACE("Exiting PtCall::addParty:\n") ;
        return (PtStatus) atoi(retCode);
}

PtStatus PtCall::conference(PtCall& rOtherCall)
{
        EVENT_TRACE("Entering PtCall::conference:\n") ;
    char buff[128];
        rOtherCall.getCallId(buff, 127);

        UtlString arg(buff);

        // not the same call
        if (arg.isNull() || arg != mCallId)
                return PT_INVALID_PARTY;


        arg += TAOMESSAGE_DELIMITER + mCallId;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::CONFERENCE,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        2,
                                                                        arg);
        mpClient->sendRequest(msg);

        int rc;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getEventData((int &)rc);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::CONFERENCE);
#endif
        mpEventMgr->release(pe);

        EVENT_TRACE("Exiting PtCall::conference:\n") ;
        return PT_SUCCESS;
}

PtStatus PtCall::connect(PtTerminal& rTerminal,
                                                        PtAddress& rAddress,
                                                        const char* destinationURL,
                                                        PtSessionDesc* pSessionDesc)
{
        EVENT_TRACE("Entering PtCall::connect:\n") ;
    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

    sprintf(buff, "%d", (int)&rTerminal);
        UtlString arg(buff);

    sprintf(buff, "%d", (int)&rAddress);
        arg += TAOMESSAGE_DELIMITER + buff;

        arg += TAOMESSAGE_DELIMITER + destinationURL;

    sprintf(buff, "%d", (int)pSessionDesc);
        arg += TAOMESSAGE_DELIMITER + buff;

        arg += TAOMESSAGE_DELIMITER + mCallId;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::CONNECT,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        5,
                                                                        arg);
        mpClient->sendRequest(msg);

        int rc;
        UtlString retCode;

        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getEventData((int &)rc);
        pe->getStringData(retCode);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::CONNECT);
#endif
        mpEventMgr->release(pe);

    mState = ACTIVE;

        EVENT_TRACE("Exiting PtCall::connect:\n") ;
        return (PtStatus) atoi(retCode);
}

PtStatus PtCall::consult(PtTerminalConnection& rTerminalConnection,
                    const char* destinationURL,
                    PtSessionDesc* pSessionDesc,
                    PtConnection& rSrcConnection,
                    PtConnection& rDstConnection)
{
        EVENT_TRACE("Entering PtCall::consult:\n") ;

        UtlString arg;
        UtlString str;

        rTerminalConnection.getTerminalName(str);
        arg.append(str);

        rTerminalConnection.getAddressName(str);
        arg += TAOMESSAGE_DELIMITER + str;

        rTerminalConnection.getCallId(str);
        arg += TAOMESSAGE_DELIMITER + str;

        arg += TAOMESSAGE_DELIMITER + mCallId;

        arg += TAOMESSAGE_DELIMITER + destinationURL;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::CONSULT,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        5,
                                                                        arg);
        mpClient->sendRequest(msg);

        PtStatus rc;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getEventData((int &)rc);
        pe->getStringData((UtlString &)arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::CONSULT);
#endif
        mpEventMgr->release(pe);