taocalladaptor.cpp

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

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


#ifdef TEST
#include "utl/UtlMemCheck.h"
#endif //TEST

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

#include "tao/TaoCallAdaptor.h"
#include "tao/TaoTransportTask.h"
#include "tao/TaoString.h"
#include "ptapi/PtAddress.h"
#include "ptapi/PtCall.h"
#include "cp/CpCallManager.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

TaoCallAdaptor::TaoCallAdaptor(TaoTransportTask*& rpSvrTransport,
                                CpCallManager *pCallMgr,
                                TaoMessage& rMsg,
                                const UtlString& name,
                                const int maxRequestQMsgs)
        : TaoAdaptor("TaoCallAdaptor-%d", maxRequestQMsgs),
        mpCallMgrTask(pCallMgr)
{
        mpSvrTransport = rpSvrTransport;
        parseMessage(rMsg);

        if (!isStarted())
        {
                start();
        }
}

TaoCallAdaptor::TaoCallAdaptor(TaoTransportTask*& rpSvrTransport,
                                CpCallManager *pCallMgr,
                                const UtlString& name,
                                const int maxRequestQMsgs)
        : TaoAdaptor("TaoCallAdaptor-%d", maxRequestQMsgs),
        mpCallMgrTask(pCallMgr)
{
        mpSvrTransport = rpSvrTransport;
        if (!isStarted())
        {
                start();
        }
}

TaoCallAdaptor::~TaoCallAdaptor()
{

}

UtlBoolean TaoCallAdaptor::handleMessage(OsMsg& rMsg)
{
        UtlBoolean handled = FALSE;

        switch (((TaoMessage&)rMsg).getCmd())
        {
        case TaoMessage::ADD_CALL_LISTENER:
                if (TAO_SUCCESS == callAddCallListener((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::ADD_PARTY:
                if (TAO_SUCCESS == callAddParty((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::CONFERENCE:
                if (TAO_SUCCESS == callConference((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::CONNECT:
                if (TAO_SUCCESS == callConnect((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::CONSULT:
                if (TAO_SUCCESS == callConsult((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::DROP:
                if (TAO_SUCCESS == callDrop((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_CALL_LISTENERS:
                if (TAO_SUCCESS == callGetCallListeners((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_CALLED_ADDRESS:
                if (TAO_SUCCESS == callGetCalledAddress((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_CALLING_ADDRESS:
                if (TAO_SUCCESS == callGetCallingAddress((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_CALLING_TERMINAL:
                if (TAO_SUCCESS == callGetCallingTerminal((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_CONF_CONTROLLER:
                if (TAO_SUCCESS == callGetConfController((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_CONNECTIONS:
                if (TAO_SUCCESS == callGetConnections((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_LAST_REDIRECTED_ADDRESS:
                if (TAO_SUCCESS == callGetLastRedirectedAddress((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_STATE:
                if (TAO_SUCCESS == callGetState((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_TRANSFER_CONTROLLER:
                if (TAO_SUCCESS == callGetTransferController((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::GET_PROVIDER:
                if (TAO_SUCCESS == callGetProvider((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::NUM_CALL_LISTENERS:
                if (TAO_SUCCESS == callNumCallListeners((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::NUM_CONNECTIONS:
                if (TAO_SUCCESS == callNumConnections((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::REMOVE_CALL_LISTENER:
                if (TAO_SUCCESS == callRemoveCallListener((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::SET_CONF_CONTROLLER:
                if (TAO_SUCCESS == callSetConfController((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::SET_TRANSFER_CONTROLLER:
                if (TAO_SUCCESS == callSetTransferController((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::TRANSFER_CON:
                if (TAO_SUCCESS == callTransferCon((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::TRANSFER_SEL:
                if (TAO_SUCCESS == callTransferSel((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::CALL_HOLD:
                if (TAO_SUCCESS == callHold((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::CALL_UNHOLD:
                if (TAO_SUCCESS == callUnhold((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;

        case TaoMessage::CODEC_RENEGOTIATE:
                if (TAO_SUCCESS == callCodecRenegotiate((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;

        case TaoMessage::GET_CODEC_CPU_COST:
                if (TAO_SUCCESS == callGetCodecCPUCost((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;

        case TaoMessage::GET_CODEC_CPU_LIMIT:
                if (TAO_SUCCESS == callGetCodecCPULimit((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;

        case TaoMessage::SET_CODEC_CPU_LIMIT:
                if (TAO_SUCCESS == callSetCodecCPULimit((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;

        case TaoMessage::CONNECT_RESULT:
                if (TAO_SUCCESS == getConnect((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        case TaoMessage::DROP_RESULT:
                if (TAO_SUCCESS == getDrop((TaoMessage&)rMsg))
                {
                        handled = TRUE;
                }
                break;
        default:
          break;
        }

        if (!handled)
        {
                TaoMessage*     pMsg = (TaoMessage*) &rMsg;

                pMsg->setArgCnt(1);
                pMsg->setArgList("-1");

                if (mpSvrTransport->postMessage(*pMsg))
                        handled = TRUE;
        }

        return handled;
}

/* ----------------------------- CALL ------------------------------------ */
TaoStatus TaoCallAdaptor::callAddCallListener(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        UtlString arg = "0";
        if (mpListenerMgr)
        {
                argCnt = 0;
                mpListenerMgr->addCallListener(rMsg);
        }
        else
        {
                argCnt = 1;
                arg = "-1";     // indicating dailure
        }


        TaoObjHandle clientSocket = rMsg.getSocket();
        TaoObjHandle msgId = rMsg.getMsgID();
        TaoObjHandle objId = rMsg.getTaoObjHandle();

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::ADD_CALL_LISTENER,
                                                                        msgId,
                                                                        objId,
                                                                        clientSocket,
                                                                        argCnt,
                                                                        arg);

        if (mpSvrTransport->postMessage(*pMsg))
        {
                delete pMsg;
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoCallAdaptor::callAddParty(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 3)
                return TAO_FAILURE;

        TaoObjHandle    clientSocket = rMsg.getSocket();
        TaoString               args(rMsg.getArgList(), TAOMESSAGE_DELIMITER);

        UtlString               destinationURL;
        UtlString               callId;

        destinationURL = args[0];
        callId = args[2];

        int ret = mpCallMgrTask->connect(callId.data(), destinationURL.data());

        char buf[20];
        sprintf(buf, "%d", ret);

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::ADD_PARTY,
                                                                        rMsg.getMsgID(),
                                                                        0,
                                                                        clientSocket,
                                                                        1,
                                                                        buf);

        if (mpSvrTransport->postMessage(*pMsg))
        {
                delete pMsg;
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoCallAdaptor::callConference(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        TaoString       args(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        UtlString       otherCallId = args[0];
        UtlString       thisCallId = args[1];

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::CONFERENCE,
                                                                        rMsg.getMsgID(),
                                                                        0,
                                                                        clientSocket,
                                                                        0,
                                                                        "");

        if (mpSvrTransport->postMessage(*pMsg))
        {
                delete pMsg;
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoCallAdaptor::callConnect(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 5)
                return TAO_FAILURE;

        TaoObjHandle    clientSocket = rMsg.getSocket();
        TaoObjHandle    objId = rMsg.getTaoObjHandle();
        TaoString               args(rMsg.getArgList(), TAOMESSAGE_DELIMITER);

        PtTerminal              *pTerminal;
        PtAddress               *pAddress;
        UtlString               destinationURL;
        PtSessionDesc   *pSession;
        UtlString               callId;

        pTerminal = (PtTerminal *) atoi(args[0]);
        pAddress =  (PtAddress *) atoi(args[1]);
        destinationURL = args[2];
        pSession = (PtSessionDesc *) atoi(args[3]);
        callId = args[4];

        int ret = mpCallMgrTask->connect(callId.data(), destinationURL.data());

        char buf[20];
        sprintf(buf, "%d", ret);

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::CREATE_CALL,
                                                                        rMsg.getMsgID(),
                                                                        objId,
                                                                        clientSocket,
                                                                        1,
                                                                        buf);

        if (mpSvrTransport->postMessage(*pMsg))
        {
                delete pMsg;
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoCallAdaptor::getConnect(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle  clientSocket = rMsg.getSocket();
        UtlString callId;
        int connection = rMsg.getTaoObjHandle();

//      mpCallDb->insert(mpCallCnt->add(), objId);
        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::CONNECT,
                                                                        rMsg.getMsgID(),
                                                                        connection,
                                                                        clientSocket,
                                                                        0,
                                                                        "");

        if (mpSvrTransport->postMessage(*pMsg))
        {
                delete pMsg;