ptcall.cpp

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

                     PtSessionDesc* pSessionDesc,
                     PtConnection& rNewConnection,
                                         int transferType)
{
        EVENT_TRACE("Entering PtCall::transfer:\n") ;
    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

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

        arg += TAOMESSAGE_DELIMITER + destinationURL;

        arg += TAOMESSAGE_DELIMITER + mCallId;

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

        unsigned int transactionId = mpTransactionCnt->add();

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

        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;
        }

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

        PtStatus ret = PT_SUCCESS;
        if (argCnt > 1)
        {
                TaoString argList(arg, TAOMESSAGE_DELIMITER);
                UtlString callId = argList[0];
                UtlString address = argList[1];

                ret = (PtStatus) atoi(argList[2]);

                if (!callId.isNull())
                        rNewConnection = PtConnection(mpClient, address.data(), callId.data());
        }
        else
        {
                ret = PT_RESOURCE_UNAVAILABLE;
        }

        EVENT_TRACE("Exiting PtCall::transfer\n") ;
        return ret;
}

PtStatus PtCall::transfer(PtCall& rOtherCall)
{
        EVENT_TRACE("Entering PtCall::transfer:\n") ;
        UtlString arg;

        arg = mCallId;

        char callId[128];

        rOtherCall.getCallId(callId, 127);

        if (callId[0])
        {
                arg += TAOMESSAGE_DELIMITER + callId;
        }
        else
        {
                return PT_INVALID_ARGUMENT;
        }

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::TRANSFER_SEL,
                                                                        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::TRANSFER_SEL);
#endif
        mpEventMgr->release(pe);

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


PtStatus PtCall::hold(UtlBoolean bBridgeParticipants /*= FALSE*/)
{
   EVENT_TRACE("Entering PtCall::hold:\n") ;

   char buff[MAXIMUM_INTEGER_STRING_LENGTH];
        UtlString arg(mCallId) ;
        sprintf(buff, "%d", bBridgeParticipants) ;
   arg += TAOMESSAGE_DELIMITER + buff ;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::CALL_HOLD,
                                                                        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::HOLD);
#endif
        mpEventMgr->release(pe);

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


PtStatus PtCall::unhold(UtlBoolean bRemoteParticipants /*= TRUE*/)
{
   EVENT_TRACE("Entering PtCall::unhold:\n") ;

   char buff[MAXIMUM_INTEGER_STRING_LENGTH];
        UtlString arg(mCallId) ;
        sprintf(buff, "%d", bRemoteParticipants) ;
   arg += TAOMESSAGE_DELIMITER + buff ;

   unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::CALL_UNHOLD,
                                                                        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::HOLD);
#endif
        mpEventMgr->release(pe);

   EVENT_TRACE("Exiting PtCall::unhold\n") ;

   return PT_SUCCESS;
}


PtStatus PtCall::getState(int& rState)
{
        EVENT_TRACE("Entering PtCall::getState:\n") ;

        unsigned int transactionId = mpTransactionCnt->add();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_CALL,
                                                                        TaoMessage::GET_STATE,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        1,
                                                                        mCallId);
        mpClient->sendRequest(msg);

        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
                EVENT_TRACE("Exiting PtCall::getState: time out\n") ;
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

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

        PtStatus ret = PT_SUCCESS;

        if (argCnt == 1)
        {
                mState = rState = atoi(arg.data());
        }
        else
        {
                mState = rState = INVALID;
                ret = PT_NOT_FOUND;
        }

        EVENT_TRACE("Exiting PtCall::getState\n") ;
        return ret;
}

PtStatus PtCall::getCallId(char* callId, int len)
{
        if (!mCallId.isNull())
        {
                int bytes = mCallId.length();

                bytes = (bytes > len) ? len : bytes;

                strncpy(callId, mCallId.data(), bytes);
                callId[bytes] = 0;
                return PT_SUCCESS;
        }

        return PT_RESOURCE_UNAVAILABLE;
}


// Gets the current CPU cost given the negotiated codecs.
PtStatus PtCall::getCodecCPUCost(int& cost)
{
   EVENT_TRACE("Entering PtCall::getCodecCPUCost:\n") ;

        UtlString arg(mCallId) ;
   unsigned int transactionId = mpTransactionCnt->add();

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

        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;
        }

        int argCnt = 0;
        UtlString argResponse;
        pe->getIntData(argCnt);
        pe->getStringData(argResponse);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_CODEC_CPU_COST);
#endif
   mpEventMgr->release(pe);
   if (argCnt == 1)
   {
      cost = atoi(argResponse.data()) ;
   }
   else
   {
      return PT_NOT_FOUND;
   }

   EVENT_TRACE("Exiting PtCall::getCodecCPUCost\n") ;

   return PT_SUCCESS;
}


// Gets the current CPU cost limit given the negotiated codecs.
PtStatus PtCall::getCodecCPULimit(int& cost)
{
   EVENT_TRACE("Entering PtCall::getCodecCPULimit:\n") ;

        UtlString arg(mCallId) ;
   unsigned int transactionId = mpTransactionCnt->add();

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

        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;
        }

        int argCnt = 0;
        UtlString argResponse;
        pe->getIntData(argCnt);
        pe->getStringData(argResponse);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_CODEC_CPU_LIMIT);
#endif
   mpEventMgr->release(pe);
   if (argCnt == 1)
   {
      cost = atoi(argResponse.data()) ;
   }
   else
   {
      return PT_NOT_FOUND;
   }

   EVENT_TRACE("Exiting PtCall::getCodecCPULimit\n") ;

   return PT_SUCCESS;
}
/* ============================ INQUIRY =================================== */

/* //////////////////////////// PROTECTED ///////////////////////////////// */
PtCall::PtCall(const char* callId)
{
        if (callId)
                mCallId = callId;

    mState = IDLE;
        mpConfController = 0;
}
/* //////////////////////////// PRIVATE /////////////////////////////////// */

/* ============================ TESTING =================================== */

/* ============================ FUNCTIONS ================================= */