ptcomponentgroup.cpp

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

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


// SYSTEM INCLUDES
#include <assert.h>

// APPLICATION INCLUDES
#include "ptapi/PtComponentGroup.h"
#include "ptapi/PtComponent.h"
#include "ptapi/PtPhoneSpeaker.h"
#include "ptapi/PtPhoneExtSpeaker.h"
#include "ptapi/PtPhoneRinger.h"
#include "tao/TaoEvent.h"
#include "tao/TaoString.h"

// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STATIC VARIABLE INITIALIZATIONS
OsBSem               PtComponentGroup::semInit(OsBSem::Q_PRIORITY, OsBSem::FULL) ;
TaoReference            *PtComponentGroup::mpTransactionCnt = 0;
int                                     PtComponentGroup::mRef = 0;

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

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

// Constructor
PtComponentGroup::PtComponentGroup() :
mpComponents(0),
mGroupType(0),
mIsActivated(0),
mNumItems(0),
mpClient(0),
mComponentRef(0)
{
        initialize();
        mDescription.append("UNKNOWN");
}

PtComponentGroup::PtComponentGroup(int groupType, const UtlString& rDescription,
                                                                                 PtComponent* pComponents[], int nItems) :
mpComponents(0),
mGroupType(groupType),
mIsActivated(0),
mNumItems(nItems),
mpClient(0),
mComponentRef(0)
{

        initialize();

        mDescription.remove(0);

        switch (groupType)
        {
        case HEAD_SET:
                mDescription.append("HEAD_SET");
                break;
        case HAND_SET:
                mDescription.append("HAND_SET");
                break;
        case SPEAKER_PHONE:
                mDescription.append("SPEAKER_PHONE");
                break;
        case PHONE_SET:
                mDescription.append("PHONE_SET");
                break;
        case EXTERNAL_SPEAKER:
                mDescription.append("EXTERNAL_SPEAKER");
                break;
        case OTHER:
                mDescription.append("OTHER");
                break;
        default:
                mDescription.append("UNKNOWN");
                break;
        }

        if (pComponents && nItems > 0)
        {
                mComponentRef++;
                mpComponents = new PtComponent*[nItems];
                if (mpComponents)
                {
                        mNumItems = nItems;
                        for (int i = 0; i < nItems; i++)
                        {
                                mpComponents[i] = pComponents[i];

                        }
                }
        }
}

void PtComponentGroup::setTaoClient(TaoClientTask *pClient)
{
        mpClient = pClient;
        if (mpClient && !(mpClient->isStarted()))
        {
                mpClient->start();
        }
};

// Copy constructor
PtComponentGroup::PtComponentGroup(const PtComponentGroup& rPtComponentGroup) :
mGroupType(rPtComponentGroup.mGroupType),
mIsActivated(rPtComponentGroup.mIsActivated),
mNumItems(rPtComponentGroup.mNumItems),
mpClient(rPtComponentGroup.mpClient),
mComponentRef(rPtComponentGroup.mComponentRef)
{
        initialize();

        mDescription = rPtComponentGroup.mDescription;

        if (rPtComponentGroup.mpComponents)
        {
                mNumItems = rPtComponentGroup.mNumItems;

                if (mNumItems > 0)
                {
                        mpComponents = new PtComponent*[mNumItems + 1];
                        if (mpComponents)
                        {
                                for (int i = 0; i < mNumItems; i++)
                                {
                                        mpComponents[i] = rPtComponentGroup.mpComponents[i];
                                }
                        }
                }
        }
        else
        {
                mpComponents = 0;
                mNumItems = 0;
        }

}

// Destructor
PtComponentGroup::~PtComponentGroup()
{

        if (mpComponents)
        {
                delete[] mpComponents;
                mpComponents = 0;
        }

    semInit.acquire() ;
        mRef--;

        if (mRef < 1)
        {
                if (mpTransactionCnt)
                {
                        delete mpTransactionCnt;
                        mpTransactionCnt = 0;
                }
        }
    semInit.release() ;
}

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

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

        mComponentRef = rhs.mComponentRef;
        if (rhs.mpComponents)
        {
                mNumItems = rhs.mNumItems;
                if (mNumItems > 0)
                {
                        if (mpComponents)
                                delete[] mpComponents;

                        mpComponents = new PtComponent*[mNumItems + 1];
                        if (mpComponents)
                        {
                                for (int i = 0; i < mNumItems; i++)
                                {
                                        mpComponents[i] = rhs.mpComponents[i];
                                }
                        }
                }
        }
        else
        {
                mpComponents = 0;
                mNumItems = 0;
        }

        mDescription = rhs.mDescription;
        mGroupType = rhs.mGroupType;
        mIsActivated = rhs.mIsActivated;
        mNumItems = rhs.mNumItems;
        mpClient = rhs.mpClient;
        mTimeOut = rhs.mTimeOut;

        return *this;
}

PtStatus PtComponentGroup::setHandsetVolume(int level)
{
        EVENT_TRACE("Entering PtComponentGroup::setHandsetVolume\n") ;
        if (mGroupType == HAND_SET && mpComponents && mNumItems > 0)
        {
                PtComponent *pComponent;

                for (int i = 0; i < mNumItems; i++)
                {
                        pComponent = mpComponents[i];
                        int type;
                        if (PT_SUCCESS == pComponent->getType(type) && PtComponent::SPEAKER == type)
                        {
                                ((PtPhoneSpeaker *)pComponent)->setVolume(level);
                                return PT_SUCCESS;
                        }
                }
        }
        EVENT_TRACE("Exiting PtComponentGroup::setHandsetVolume\n") ;

        return PT_INVALID_ARGUMENT;
}

PtStatus PtComponentGroup::setSpeakerVolume(int level)
{
        EVENT_TRACE("Entering PtComponentGroup::setSpeakerVolume\n") ;
        if ((mGroupType == PHONE_SET || mGroupType == SPEAKER_PHONE) && mpComponents && mNumItems > 0)
        {
                PtComponent *pComponent;

                for (int i = 0; i < mNumItems; i++)
                {
                        pComponent = mpComponents[i];
                        int type;
                        if (PT_SUCCESS == pComponent->getType(type) && PtComponent::SPEAKER == type)
                        {
                                ((PtPhoneSpeaker *)pComponent)->setVolume(level);
                                return PT_SUCCESS;
                        }
                }
        }

        EVENT_TRACE("Exiting PtComponentGroup::setSpeakerVolume\n") ;
        return PT_INVALID_ARGUMENT;
}

PtStatus PtComponentGroup::setExtSpeakerVolume(int level)
{
        EVENT_TRACE("Entering PtComponentGroup::setExtSpeakerVolume\n") ;
        if (mGroupType == EXTERNAL_SPEAKER && mpComponents && mNumItems > 0)
        {
                PtComponent *pComponent;

                for (int i = 0; i < mNumItems; i++)
                {
                        pComponent = mpComponents[i];
                        int type;
                        if (PT_SUCCESS == pComponent->getType(type) && PtComponent::EXTERNAL_SPEAKER == type)
                        {
                                ((PtPhoneExtSpeaker *)pComponent)->setVolume(level);
                                return PT_SUCCESS;
                        }
                }
        }

        EVENT_TRACE("Exiting PtComponentGroup::setExtSpeakerVolume\n") ;
        return PT_INVALID_ARGUMENT;
}

PtStatus PtComponentGroup::setRingerVolume(int level)
{
        EVENT_TRACE("Entering PtComponentGroup::setRingerVolume\n") ;
        if ((mGroupType == PHONE_SET || mGroupType == SPEAKER_PHONE) && mpComponents && mNumItems > 0)
        {
                PtComponent *pComponent;

                for (int i = 0; i < mNumItems; i++)
                {
                        pComponent = mpComponents[i];
                        int type;
                        if (PT_SUCCESS == pComponent->getType(type) && PtComponent::RINGER == type)
                        {
                                ((PtPhoneRinger *)pComponent)->setRingerVolume(level);
                                return PT_SUCCESS;
                        }
                }
        }

        EVENT_TRACE("Exiting PtComponentGroup::setRingerVolume\n") ;
        return PT_INVALID_ARGUMENT;
}