taolistenermanager.cpp

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

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

// SYSTEM INCLUDES
#include <assert.h>
#include <stdlib.h>

// APPLICATION INCLUDES
#include "tao/TaoListenerManager.h"
#include <os/OsWriteLock.h>
#include <os/OsReadLock.h>
#include <os/OsConnectionSocket.h>
#include "cp/CpCallManager.h"
#include "ps/PsPhoneTask.h"
#include "ps/PsHookswTask.h"
#include "tao/TaoEventListener.h"
#include "tao/TaoListenerEventMessage.h"
#include "tao/TaoObjectMap.h"
#include "tao/TaoTransportTask.h"
#include "tao/TaoTransportAgent.h"
#include "tao/TaoMessage.h"
#include "tao/TaoString.h"
#include "tao/TaoListenerClient.h"

// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STATIC VARIABLE INITIALIZATIONS

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

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

// Constructor
TaoListenerManager::TaoListenerManager(CpCallManager *pCallMgr,
                PsPhoneTask *pPhoneTask,
                TaoTransportTask*& rpSvrTransport) :
OsServerTask("TaoLstnrMgr-%d"),
mListenerRWLock(OsRWMutex::Q_FIFO)
{
        mpCallMgr = pCallMgr;
        mpPhoneTask = pPhoneTask;
        mpHookswTask = PsHookswTask::getHookswTask();
        mpSvrTransport = rpSvrTransport;
        mListenerAdded = FALSE;
        mEventClient = 0;

        mpAgents                        = new TaoObjectMap();
        mpConnectionSockets = new TaoObjectMap();

        mListenerCnt = 0;
    mMaxNumListeners = 20;

    mpListeners = (TaoListenerDb**) malloc(sizeof(TaoListenerDb *)*mMaxNumListeners);

    if (!mpListeners)
    {
        osPrintf("***** ERROR ALLOCATING LISTENERS IN TAOLISTENERMANAGER **** \n");
        return;
    }

        for (int i = 0; i < mMaxNumListeners; i++)
                mpListeners[i] = 0;

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

// Copy constructor
TaoListenerManager::TaoListenerManager(const TaoListenerManager& rTaoListenerManager) :
OsServerTask("TaoLstnrMgr-%d"),
mListenerRWLock(OsRWMutex::Q_FIFO)
{
        mpCallMgr = rTaoListenerManager.mpCallMgr;
        mpPhoneTask = rTaoListenerManager.mpPhoneTask;
        mpHookswTask = PsHookswTask::getHookswTask();
        mpSvrTransport = rTaoListenerManager.mpSvrTransport;
        mListenerAdded = rTaoListenerManager.mListenerAdded;
        mEventClient = rTaoListenerManager.mEventClient;

        mListenerCnt = rTaoListenerManager.mListenerCnt;
        for (int i = 0; i < mMaxNumListeners; i++)
                mpListeners[i] = rTaoListenerManager.mpListeners[i];

}

// Destructor
TaoListenerManager::~TaoListenerManager()
{
        if (mpAgents)
        {
                delete mpAgents;
                mpAgents = 0;
        }
        if (mpConnectionSockets)
        {
                int num = mpConnectionSockets->numEntries();

                if (num > 0)
                {
                        TaoObjHandle *pHandles;

                        pHandles = new TaoObjHandle[num+1];

                        if (pHandles)
                        {
                                if (mpConnectionSockets->getActiveObjects(pHandles, num))
                                {
                                        for (int i = 0; i < num; i++)
                                        {
                                                OsConnectionSocket* pSock = (OsConnectionSocket*)pHandles[i];
                                                delete pSock;
                                        }
                                }
                                delete[] pHandles;
                        }
                }
                delete mpConnectionSockets;
                mpConnectionSockets = 0;
        }

        if (mListenerCnt > 0)  // check if listener exists.
        {
                for (int i = 0; i < mListenerCnt; i++)
                {
                        if (mpListeners[i])
                        {
                                delete mpListeners[i];
                                mpListeners[i] = 0;
                        }
                }
        free(mpListeners);

        }
}

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

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

        mpCallMgr = rhs.mpCallMgr;
        mpPhoneTask = rhs.mpPhoneTask;
        mpHookswTask = PsHookswTask::getHookswTask();
        mpSvrTransport = rhs.mpSvrTransport;
        mListenerAdded = rhs.mListenerAdded;
        mEventClient = rhs.mEventClient;

   return *this;
}

UtlBoolean TaoListenerManager::handleMessage(OsMsg& eventMessage)
{
        int eventId = ((TaoListenerEventMessage&)eventMessage).getEventId();

        OsReadLock lock(mListenerRWLock);

        if (mListenerCnt > 0)
        {
                for (int i = 0; i < mListenerCnt; i++)
                {
                        if (!mpListeners[i] || mpListeners[i]->mpListenerPtr == 0)
                                continue;
                        TaoEventListener* pListener = (TaoEventListener*)mpListeners[i]->mpListenerPtr;

                        if (pListener && pListener->isEventEnabled((PtEvent::PtEventId &)eventId))
                        {
                                UtlString rTerminalName;
                                char buf[128];

                                if (TAO_SUCCESS == pListener->getTerminalName(buf, 127))
                                {
                                        TaoObjHandle hSocket;

                                        rTerminalName.append(buf);
                                        if (TAO_NOT_FOUND == mpAgents->findValue(rTerminalName.data(), hSocket))
                                        {
                                                // OsConnectionSocket* pConnectionSocket;
                                                // pConnectionSocket = new OsConnectionSocket(DEF_TAO_EVENT_PORT, rTerminalName.data());

                                                // mpConnectionSockets->insert((const char *)rTerminalName.data(), (TaoObjHandle)pConnectionSocket);
                                                // TaoTransportAgent *pAgent = new TaoTransportAgent(pConnectionSocket, this);
                                                // mpAgents->insert((const char *)rTerminalName.data(), (TaoObjHandle)pAgent);

                                                // hSocket = (TaoObjHandle) pAgent;
                        return TRUE;
                                        }

                                        int msgType = eventMessage.getMsgType();
                                        int msgSubType = eventMessage.getMsgSubType();
                                        PtEvent::PtEventId eventId = PtEvent::EVENT_INVALID;
                                        TaoMessage*     pMsg = NULL;
                                        UtlBoolean      bValidEvent = TRUE;

                                        switch(msgType)
                                        {

                                        case OsMsg::TAO_EVENT:
                                                pMsg = new TaoMessage((TaoListenerEventMessage&) eventMessage, hSocket);
                                                break;
                                        case OsMsg::TAO_MSG:
                                                pMsg = new TaoMessage((TaoMessage&)eventMessage);
                                                pMsg->setSocket(hSocket);
                                                break;
                                        case OsMsg::TAO_LISTENER_EVENT_MSG:
                                                {
                                                        TaoListenerEventMessage *pEventMsg = (TaoListenerEventMessage*) &eventMessage;

                                                        UtlString callId;
                                                        UtlString remoteAddress;
                                                        pEventMsg->getStringData1(callId);
                                                        pEventMsg->getStringData2(remoteAddress);

                                                        UtlString arg = callId + TAOMESSAGE_DELIMITER + remoteAddress;

                                                        char buf[MAXIMUM_INTEGER_STRING_LENGTH];

                                                        sprintf(buf, "%d", msgSubType); // actual event id
                                                        arg +=  TAOMESSAGE_DELIMITER + buf;

                                                        pMsg = new TaoMessage(TaoMessage::EVENT,
                                                                                                0,
                                                                                                0,
                                                                                                0,
                                                                                                hSocket,
                                                                                                3,
                                                                                                arg);
                                                }

                                                break;
                                        case OsMsg::PS_MSG:
                                                {
                                                        PsMsg msg = (PsMsg&)eventMessage;
                                                        int hookType = msg.getParam1();
                                                        int key = msg.getParam2();
                                                        UtlString param;
                                                        msg.getStringParam1(param);

                                                        switch(msgSubType)
                                                        {
                                                        case PsMsg::EXTSPEAKER_CONNECT:
                                                                eventId = PtEvent::PHONE_EXTSPEAKER_CONNECTED;
                                                                break;
                                                        case PsMsg::EXTSPEAKER_DISCONNECT:
                                                                eventId = PtEvent::PHONE_EXTSPEAKER_DISCONNECTED;
                                                                break;
                                                        case PsMsg::BUTTON_DOWN:
                                                                eventId = PtEvent::PHONE_BUTTON_DOWN;
                                                                break;
                                                        case PsMsg::BUTTON_UP:
                                                                eventId = PtEvent::PHONE_BUTTON_UP;
                                                                break;
                                                        case PsMsg::BUTTON_SET_INFO:
                                                                eventId = PtEvent::PHONE_BUTTON_INFO_CHANGED;
                                                                break;
                                                        case PsMsg::BUTTON_REPEAT: