taocalladaptor.cpp

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

                                                                        rTerminal,
                                                                        clientSocket,
                                                                        1,
                                                                        "102");

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

        return TAO_FAILURE;
}

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

        if (argCnt != 2)
                return TAO_FAILURE;

        UtlString argList = rMsg.getArgList();
        TaoString arg(argList, TAOMESSAGE_DELIMITER);
        int     numConnections   = atoi(arg[0]);
        UtlString callId = arg[1];
        UtlString *addresses;

        if (numConnections > 0 && (addresses = new UtlString[numConnections]))
        {
                int maxConnections = numConnections;
                mpCallMgrTask->getConnections(callId.data(), maxConnections, numConnections, addresses);

                if (numConnections > maxConnections)
                        numConnections = maxConnections;

                for (int i = 0; i< numConnections; i++)
                {
                        argList += TAOMESSAGE_DELIMITER + addresses[i];
                }

                rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);
                rMsg.setArgCnt(numConnections + 2);
                rMsg.setArgList(argList);

                delete[] addresses;

                if (mpSvrTransport->postMessage(rMsg))
                        return TAO_SUCCESS;
        }


        return TAO_FAILURE;
}

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

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        rMsg.getTaoObjHandle();

        TaoObjHandle rTerminal = 0x00000099;    // fake

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::GET_LAST_REDIRECTED_ADDRESS,
                                                                        rMsg.getMsgID(),
                                                                        rTerminal,
                                                                        clientSocket,
                                                                        1,
                                                                        "9991010");

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

        return TAO_FAILURE;
}

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

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        rMsg.getTaoObjHandle();

        TaoObjHandle rTerminal = 0x00000099;    // fake

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::GET_PROVIDER,
                                                                        rMsg.getMsgID(),
                                                                        rTerminal,
                                                                        clientSocket,
                                                                        1,
                                                                        "9");

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

        return TAO_FAILURE;
}

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

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        UtlString arg = rMsg.getArgList();              // callId

        int state;
        if (mpCallMgrTask->getCallState(arg.data(), state))
        {
                char buff[MAXIMUM_INTEGER_STRING_LENGTH];

                sprintf(buff, "%d", state);
                argCnt = 1;
                arg = buff;
        }
        else
        {
                argCnt = 0;
        }


        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::GET_STATE,
                                                                        rMsg.getMsgID(),
                                                                        0,
                                                                        clientSocket,
                                                                        argCnt,
                                                                        arg);

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

        return TAO_FAILURE;
}

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

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        rMsg.getTaoObjHandle();

        TaoObjHandle rTerminal = 0x00000099;    // fake

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::GET_TRANSFER_CONTROLLER,
                                                                        rMsg.getMsgID(),
                                                                        rTerminal,
                                                                        clientSocket,
                                                                        1,
                                                                        "901");

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

        return TAO_FAILURE;
}

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

        if (argCnt != 1)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        rMsg.getTaoObjHandle();

        TaoObjHandle rTerminal = 0x00000099;    // fake
        UtlString arg = "1" ;
   arg.append(TAOMESSAGE_DELIMITER);
   arg.append("101");

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_CALL,
                                                                        TaoMessage::NUM_CALL_LISTENERS,
                                                                        rMsg.getMsgID(),
                                                                        rTerminal,
                                                                        clientSocket,
                                                                        2,
                                                                        arg);

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

        return TAO_FAILURE;
}

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

        if (argCnt != 1)
                return TAO_FAILURE;

        UtlString callId = rMsg.getArgList();

        int numConnections = 0;
        mpCallMgrTask->getNumConnections(callId.data(), numConnections);

   char buff[MAXIMUM_INTEGER_STRING_LENGTH];

   sprintf(buff, "%d", numConnections);
        callId.append(TAOMESSAGE_DELIMITER);
   callId.append(buff);

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);
        rMsg.setArgCnt(2);
        rMsg.setArgList(callId);

        if (mpSvrTransport->postMessage(rMsg))
        {
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;

}

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

        if (argCnt != 2)
                return TAO_FAILURE;

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

        TaoMessage*     pMsg = (TaoMessage*) &rMsg;

        pMsg->setMsgSubType(TaoMessage::RESPONSE_CALL);
        pMsg->setArgCnt(argCnt);
        pMsg->setArgList(arg);

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

        return TAO_FAILURE;
}

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

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        rMsg.getTaoObjHandle();
        UtlString arg = rMsg.getArgList();

        TaoObjHandle rTerminal = 0x00000099;    // fake

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

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

        return TAO_FAILURE;
}

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

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        rMsg.getTaoObjHandle();
        UtlString arg = rMsg.getArgList();

        TaoObjHandle rTerminal = 0x00000099;    // fake

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

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

        return TAO_FAILURE;
}

// Trasfer this call to another address
TaoStatus TaoCallAdaptor::callTransferCon(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 4)
                return TAO_FAILURE;

        TaoString arg(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        UtlString destination = arg[1];
        UtlString callId = arg[2];
        int transferType = atoi(arg[3]);

        UtlString targetConnectionCallId;
        UtlString targetConnectionAddress;

        mpCallMgrTask->setTransferType(transferType);
        int ret = mpCallMgrTask->transfer_blind(callId.data(),
                                                                        destination.data(),
                                                                        &targetConnectionCallId,
                                                                        &targetConnectionAddress);

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

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);
        TaoMessage*     pMsg = (TaoMessage*) &rMsg;

        callId = targetConnectionCallId + TAOMESSAGE_DELIMITER + targetConnectionAddress+
                         TAOMESSAGE_DELIMITER + buf;

        pMsg->setMsgSubType(TaoMessage::RESPONSE_CALL);
        pMsg->setArgCnt(3);
        pMsg->setArgList(callId);

        if (mpSvrTransport->postMessage(rMsg))
                return TAO_SUCCESS;

        return TAO_FAILURE;
}

// trasfer all participants in call (with callId) to this call (with selfCallId)
TaoStatus TaoCallAdaptor::callTransferSel(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoString arg(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        UtlString selfCallId = arg[0];
        UtlString callId = arg[1];

        mpCallMgrTask->transfer(selfCallId.data(), callId.data());

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);

        if (mpSvrTransport->postMessage(rMsg))
                return TAO_SUCCESS;
        return TAO_FAILURE;
}


// places a call on hold
TaoStatus TaoCallAdaptor::callHold(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoString arg(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
        UtlBoolean bBridgeParticipants = atoi(arg[1]);

   if (bBridgeParticipants)
   {
      mpCallMgrTask->holdLocalTerminalConnection(arg[0]);
   }
   else
   {
      mpCallMgrTask->holdAllTerminalConnections(arg[0]);
   }

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);
        if (mpSvrTransport->postMessage(rMsg))
                return TAO_SUCCESS;
        return TAO_FAILURE;
}



// releases a call from hold
TaoStatus TaoCallAdaptor::callUnhold(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

        TaoString arg(rMsg.getArgList(), TAOMESSAGE_DELIMITER);
   UtlBoolean bRemoteParticipants = atoi(arg[1]);

   if (bRemoteParticipants)
   {
      mpCallMgrTask->unholdAllTerminalConnections(arg[0]) ;
   }
   else
   {
      mpCallMgrTask->unholdLocalTerminalConnection(arg[0]) ;
   }

        rMsg.setMsgSubType(TaoMessage::RESPONSE_CALL);
        if (mpSvrTransport->postMessage(rMsg))
                return TAO_SUCCESS;
        return TAO_FAILURE;
}