taoterminaladaptor.cpp

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

   UtlString argList;

   int iAvailableAddresses = 0 ;
   int actual = 0;

   int iMaxAddressesRequested = mpCallMgrTask->getNumLines();
   if( iMaxAddressesRequested == 0)
      return TAO_FAILURE;

   UtlString** arrayAddresses = new UtlString*[iMaxAddressesRequested];
   for (int j=0; j<iMaxAddressesRequested; j++)
   {
      arrayAddresses[j] = new UtlString("");
   }

   mpCallMgrTask->getOutboundAddresses(iMaxAddressesRequested, iAvailableAddresses, arrayAddresses);

   actual = ((iMaxAddressesRequested < iAvailableAddresses) ? iMaxAddressesRequested : iAvailableAddresses);


   if (actual > 0)
   {

                for (int i = 0; i < actual; i++)
                {
                         UtlString strIdentity = *arrayAddresses[i];
          argList += strIdentity ;

                        if (i < (actual - 1))
                        {
                                argList += TAOMESSAGE_DELIMITER;
                        }
                }
        }
        else
        {
                UtlString rNextValue;
      iAvailableAddresses = actual = 1;
                if (thisTerminal.isNull())
                        argList = UtlString("sip:");
                else
                        argList = UtlString("sip:") + thisTerminal + UtlString("@");
                UtlString strHostIP;
      OsSocket::getHostIp(&strHostIP);
                argList += strHostIP;

        }

   if( arrayAddresses != NULL )
   {
      for (int i=0; i<iMaxAddressesRequested; i++)
      {
         delete arrayAddresses[i] ;
         arrayAddresses[i] = NULL ;
      }
      delete[] arrayAddresses ;
   }


        TaoObjHandle clientSocket = rMsg.getSocket();
        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_TERMINAL,
                                                                        TaoMessage::GET_ADDRESSES,
                                                                        rMsg.getMsgID(),
                                                                        iAvailableAddresses,
                                                                        clientSocket,
                                                                        actual,
                                                                        argList);

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

        return TAO_FAILURE;
}

void TaoTerminalAdaptor::initConfigFile(const char* configFileName)
{
    OsConfigDb  configDb;

        if (configDb.loadFromFile((char *)configFileName) == OS_SUCCESS)
        {
      osPrintf("Found config file %s.\n", configFileName);
          configDb.getSubHash("PINGTEL_ADDRESS.", mAddresses);
    }
        else
        {
      osPrintf("Config file %s not found.\n", configFileName);
        }
}

TaoStatus TaoTerminalAdaptor::terminalGetCallListeners(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

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

        int      size =  atoi(rMsg.getArgList());
//      int      nItems;
//      PtCallListener  *rpCallListeners;

//      rpCallListeners = new PtCallListener[size];

        if (TAO_NOT_FOUND != mpObjectDb->findValue(objId, pTerminal))
        {
                if (pTerminal)
                {
//                      ((PtTerminal *) pTerminal)->getCallListeners(rpCallListeners, size, nItems);
                }
        }

        UtlString argList;
    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

//      int actual = ((size < nItems) ? size : nItems);

        for (int i = 0; i < size; i++)
        {
                unsigned int objId = mpObjectCnt->add();
//              mpObjectDb->insert((TaoObjHandle)objId, (TaoObjHandle)&rpCallListeners[i]);

                sprintf(buff, "%d", objId);
                argList += (UtlString) buff;

                if (i < (size - 1))
                {
                        argList += TAOMESSAGE_DELIMITER;
                }
        }

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_TERMINAL,
                                                                        TaoMessage::GET_CALL_LISTENERS,
                                                                        rMsg.getMsgID(),
                                                                        size,
                                                                        clientSocket,
                                                                        size,
                                                                        argList);

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

        return TAO_FAILURE;
}

TaoStatus TaoTerminalAdaptor::terminalGetComponent(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        rMsg.setMsgSubType(TaoMessage::RESPONSE_TERMINAL);
        rMsg.setCmd(TaoMessage::GET_COMPONENT);
        rMsg.setObjHandle((TaoObjHandle) this);

        // assert
        (mpPhoneTask->getComponent((PsMsg&) rMsg));

        return TAO_SUCCESS;
}

TaoStatus TaoTerminalAdaptor::terminalGetComponents(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        rMsg.setMsgSubType(TaoMessage::RESPONSE_TERMINAL);
        rMsg.setCmd(TaoMessage::GET_COMPONENTS);

    // assert
        (mpPhoneTask->getComponents((PsMsg&) rMsg));
        if (mpSvrTransport->postMessage(rMsg))
        {
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoTerminalAdaptor::terminalGetComponentGroups(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

        rMsg.setMsgSubType(TaoMessage::RESPONSE_TERMINAL);
        rMsg.setCmd(TaoMessage::GET_COMPONENTGROUPS);

    // assert
        (mpPhoneTask->getComponentGroups((PsMsg&) rMsg));
        if (mpSvrTransport->postMessage(rMsg))
        {
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoTerminalAdaptor::returnResult(TaoMessage& rMsg)
{
        if (mpSvrTransport->postMessage(rMsg))
        {
                return TAO_SUCCESS;
        }

        return TAO_FAILURE;
}

TaoStatus TaoTerminalAdaptor:: terminalGetConfig(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 0)
                return TAO_FAILURE;

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

        TaoObjHandle rTerminal = 0x00000099;    // fake

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_TERMINAL,
                                                                        TaoMessage::GET_CONFIG,
                                                                        rMsg.getMsgID(),
                                                                        rTerminal,
                                                                        clientSocket,
                                                                        1,
                                                                        "302");

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

        return TAO_FAILURE;
}

TaoStatus TaoTerminalAdaptor::terminalGetDoNotDisturb(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 0)
                return TAO_FAILURE;

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

        TaoObjHandle rTerminal = 0x00000099;    // fake

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_TERMINAL,
                                                                        TaoMessage::GET_DONOT_DISTURB,
                                                                        rMsg.getMsgID(),
                                                                        rTerminal,
                                                                        clientSocket,
                                                                        1,
                                                                        "0");

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

        return TAO_FAILURE;
}

TaoStatus TaoTerminalAdaptor::terminalGetName(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 0)
                return TAO_FAILURE;

        TaoObjHandle clientSocket = rMsg.getSocket();
        TaoObjHandle objId = rMsg.getTaoObjHandle();
        TaoObjHandle pTerminal;
        UtlString        name;

        if (TAO_NOT_FOUND != mpObjectDb->findValue(objId, pTerminal))
        {
                if (pTerminal)
                {
                        // ((PtTerminal *) pTerminal)->getName((const char *&)name);
                }
        }

        TaoMessage*     pMsg = new TaoMessage(TaoMessage::RESPONSE_TERMINAL,
                                                                        TaoMessage::GET_NAME,
                                                                        rMsg.getMsgID(),
                                                                        objId,
                                                                        clientSocket,
                                                                        1,
                                                                        name);

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

        return TAO_FAILURE;
}

TaoStatus TaoTerminalAdaptor::terminalGetTermConnections(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 2)
                return TAO_FAILURE;

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

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

        UtlString *terminalNames;
        terminalNames = new UtlString[numConnections];

        if (terminalNames)
        {
                int maxConnections = numConnections;
                mpCallMgrTask->getTerminalConnections(callId.data(),
                                                                                        address.data(),
                                                                                        maxConnections,
                                                                                        numConnections,
                                                                                        terminalNames);

                if (numConnections > maxConnections)
                        numConnections = maxConnections;

                callId += TAOMESSAGE_DELIMITER + address;
                for (int i = 0; i< numConnections; i++)
                {
                        callId += TAOMESSAGE_DELIMITER + terminalNames[i];
                        int isLocal = mpCallMgrTask->isTerminalConnectionLocal(callId.data(),
                                                                                        address.data(),
                                                                                        terminalNames[i].data());
                        char buff[128];
                        sprintf(buff, "%d", isLocal);
                        callId += TAOMESSAGE_DELIMITER + UtlString(buff);       // isLocal
                }

                rMsg.setMsgSubType(TaoMessage::RESPONSE_CONNECTION);
                rMsg.setArgCnt(2 * numConnections + 2);
                rMsg.setArgList(callId);

                delete[] terminalNames;

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

        return TAO_FAILURE;
}

TaoStatus TaoTerminalAdaptor::terminalGetTermListeners(TaoMessage& rMsg)
{
        int     argCnt = rMsg.getArgCnt();

        if (argCnt != 1)
                return TAO_FAILURE;

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

        int      size =  atoi(rMsg.getArgList());
//      int      nItems;

        if (TAO_NOT_FOUND != mpObjectDb->findValue(objId, pTerminal))