taolistenerclient.cpp

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

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


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

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

#include <assert.h>
#include "tao/TaoListenerClient.h"
#include "tao/TaoString.h"
#include "tao/TaoClientTask.h"
#include "ptapi/PtTerminalConnectionEvent.h"
#include "ptapi/PtTerminalConnectionListener.h"
#include "ptapi/PtTerminalComponentListener.h"
#include "ptapi/PtTerminalComponentEvent.h"
#include "ptapi/PtConnectionEvent.h"

#ifdef WV_DEBUG
#ifdef _VXWORKS
#include <vxworks.h>
#include "wvLib.h"
#endif

typedef struct
{
    unsigned long id;
    char name[16];
} USER_EVENT;

char name[16];
#endif

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

TaoListenerClientTask::TaoListenerClientTask(TaoClientTask *pClient,
                                                        const UtlString& name,
                                                        const int maxRequestQMsgs)
: OsServerTask(name, NULL, maxRequestQMsgs),
  mListenerSem(OsBSem::Q_PRIORITY, OsBSem::FULL)
{
        mpClient = pClient;
        initInstance();
        if (!isStarted())
        {
                start();
        }
}

// Constructor
TaoListenerClientTask::TaoListenerClientTask(const int priority,
                const UtlString& name,
                void* pArg,
                const int maxRequestQMsgs,
                const int options,
                const int stackSize)
: OsServerTask(name, pArg, maxRequestQMsgs, priority, options, stackSize),
  mListenerSem(OsBSem::Q_PRIORITY, OsBSem::FULL)

{
        mpClient = NULL;
        initInstance();
        if (!isStarted())
        {
                start();
        }
}

TaoListenerClientTask::TaoListenerClientTask(const int maxIncomingQMsgs)
: OsServerTask("TaoListenerClient-%d", NULL, maxIncomingQMsgs),
  mListenerSem(OsBSem::Q_PRIORITY, OsBSem::FULL)
{
        mpClient = NULL;
        initInstance();
        if (!isStarted())
        {
                start();
        }
}

// Destructor
TaoListenerClientTask::~TaoListenerClientTask()
{
        if (mListenerCnt > 0)
        {
                for (int i = 0; i < mListenerCnt; i++)
                {
                        if (mpListeners[i])
                        {
                                delete mpListeners[i];
                                mpListeners[i] = 0;
                        }
                }
        free(mpListeners);

        }

        if (mpCallEvent)
        {
                delete mpCallEvent;
                mpCallEvent = 0;
        }
        if (mpConnEvent)
        {
                delete mpConnEvent;
                mpConnEvent = 0;
        }

        if (mpTermConnEvent)
        {
                delete mpTermConnEvent;
                mpTermConnEvent = 0;
        }
}

//////////////////////////////////////////////////////////////////////
// MANIPULATORS
//////////////////////////////////////////////////////////////////////

// Initialization, called by constructor
TaoStatus TaoListenerClientTask::initInstance()
{
        mListenerCnt = 0;
    mMaxNumListeners = 20;

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

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

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

        mpCallEvent = new PtCallEvent(mpClient);
        mpConnEvent = new PtConnectionEvent(mpClient);
        mpTermConnEvent = new PtTerminalConnectionEvent(mpClient);

        return TAO_SUCCESS;
}


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

        switch (rMsg.getMsgSubType())
        {
        case TaoMessage::EVENT:
                handled = receiveEvent((TaoMessage&) rMsg);
                break;
        case TaoMessage::UNSPECIFIED:
        default:
//              handled = FALSE;
//              assert(FALSE);
                break;
        }

        return handled;
}

UtlBoolean TaoListenerClientTask::receiveEvent(TaoMessage& rMsg)
{
    UtlBoolean bHandled ;
#ifdef TAO_TIME_DEBUG
        int     eventId = rMsg.getTaoObjHandle();
        OsTimeLog timeLog;
        char tmp[64];

        sprintf(tmp, "%d ", eventId);
        UtlString stringData = UtlString("RECEIVE EVENT: ") + UtlString(tmp);
    timeLog.addEvent(stringData.data());
#else
        rMsg.getTaoObjHandle();
#endif
        {
                mListenerSem.acquire();
                int *pHandles = (int*) mpListeners;
                int num = mListenerCnt;

#ifdef _VXWORKS
                char buf[128];
#endif
                if (num < 1)
                {
                        mListenerSem.release();
                        return TRUE;
                }

                if (num >= mMaxNumListeners)
                {
            //make more of em.
            mMaxNumListeners += 20;
            mpListeners = (TaoListenerDb **)realloc(mpListeners,sizeof(TaoListenerDb *)*mMaxNumListeners);
            for (int loop = mListenerCnt;loop < mMaxNumListeners;loop++)
                mpListeners[loop] = 0 ;

                        pHandles = (int*) new TaoListenerDb[num+1];

                        if (num > 0)  // check if listener is already added.
                        {
                                for (int i = 0; i < num; i++)
                                {
                                        if (mpListeners[i])
                                        {
                                                pHandles[i] = (int)mpListeners[i];
                                        }
                                }
                        }
                }
                mListenerSem.release();

                if (num > 0)
                {
                        TaoObjHandle listener;
                        for (int i = 0; i < num; i++)
                        {
                                if (pHandles[i])
                                        listener = ((TaoListenerDb*)pHandles[i])->mpListenerPtr;
                                else
                                        listener = 0;
                                if (listener)
                                {
                                        PtEventListener *pListener = (PtEventListener *)listener;

                                        // Note: the following if (w/o else)statements let the event
                                        // be sent to all parent classes of pListener.

                                        if ((pListener->isClass("PtTerminalConnectionListener")) ||
                                                (pListener->isClass("PtTerminalConnectionListenerWrap")))
                                        {
#ifdef TAO_TIME_DEBUG
                                                bHandled = receiveTerminalConnectionEvent(rMsg, (PtTerminalConnectionListener*) pListener, timeLog);
#else
                                                bHandled = receiveTerminalConnectionEvent(rMsg, (PtTerminalConnectionListener*) pListener);
#endif
                        if (bHandled)
                            continue;
                                        }

                                        if ((pListener->isClass("PtConnectionListener")) ||
                                                (pListener->isClass("PtConnectionListenerWrap")) ||
                                                (pListener->isClass("PtTerminalConnectionListenerWrap")))
                                        {
#ifdef TAO_TIME_DEBUG
                                                bHandled = receiveConnectionEvent(rMsg, (PtConnectionListener*) pListener, timeLog);
#else
                                                bHandled = receiveConnectionEvent(rMsg, (PtConnectionListener*) pListener);
#endif
                        if (bHandled)
                            continue;
                    }

                                        if ((pListener->isClass("PtCallListener")) ||
                                                (pListener->isClass("PtCallListenerWrap")) ||
                                                (pListener->isClass("PtConnectionListenerWrap")) ||
                                                (pListener->isClass("PtTerminalConnectionListenerWrap")))
                                        {
#ifdef TAO_TIME_DEBUG
                                                bHandled = receiveCallEvent(rMsg, (PtCallListener*) pListener, timeLog);
#else
                                                bHandled = receiveCallEvent(rMsg, (PtCallListener*) pListener);
#endif
                        if (bHandled)
                            continue;
                    }

                                        if ((pListener->isClass("PtTerminalComponentListener")) ||
                                                (pListener->isClass("PtTerminalComponentListenerContainer")))
                                        {
#ifdef TAO_TIME_DEBUG
                                                bHandled = receiveTerminalComponentEvent(rMsg, (PtTerminalComponentListener*) pListener, timeLog);
#else
                                                bHandled = receiveTerminalComponentEvent(rMsg, (PtTerminalComponentListener*) pListener);
#endif
                        if (bHandled)
                            continue;                                   }

                                        if ((pListener->isClass("PtTerminalListener")) ||
                                                (pListener->isClass("PtTerminalComponentListenerContainer")))
                                        {
#ifdef TAO_TIME_DEBUG
                                                bHandled = receiveTerminalEvent(rMsg, (PtTerminalListener*) pListener, timeLog);
#else
                                                bHandled = receiveTerminalEvent(rMsg, (PtTerminalListener*) pListener);
#endif
                        if (bHandled)
                            continue;
                                        }
                                }
                        }
                }

                if (num >= mMaxNumListeners)
                        delete[] pHandles;
        }

#ifdef TAO_TIME_DEBUG
        sprintf(tmp, "%d ", eventId);
        stringData = UtlString("LEAVING EVENT: ") + UtlString(tmp);
    timeLog.addEvent(stringData.data());
    timeLog.dumpLog();
#endif
        return TRUE;
}

#ifdef TAO_TIME_DEBUG
UtlBoolean TaoListenerClientTask::receiveCallEvent(TaoMessage& rMsg,
                                                                                PtCallListener* pListener,
                                                                                OsTimeLog& timeLog)
#else