ptcomponentgroup.cpp

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

UtlBoolean PtComponentGroup::activate(void)
{
        EVENT_TRACE("Entering PtComponentGroup::activate\n") ;
        if (!mpClient)
        {
                return PT_NOT_FOUND;
        }

    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

    sprintf(buff, "%d", mGroupType);
        UtlString arg(buff);

        mpTransactionCnt->add();
        unsigned int transactionId = mpTransactionCnt->getRef();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_PHONECOMPONENT,
                                                                        TaoMessage::PHONEGROUP_ACTIVATE,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        1,
                                                                        arg);
        mpClient->sendRequest(msg);

        int rc;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
                EVENT_TRACE("Exiting PtComponentGroup::activate, TIME OUT\n") ;
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getEventData((int &)rc);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::PHONEGROUP_ACTIVATE);
#endif
        mpEventMgr->release(pe);
        mIsActivated = true;
        EVENT_TRACE("Exiting PtComponentGroup::activate\n") ;

        return true;
}

UtlBoolean PtComponentGroup::deactivate(void)
{
        EVENT_TRACE("Entering PtComponentGroup::deactivate\n") ;
        if (!mpClient)
        {
                return PT_NOT_FOUND;
        }

    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

    sprintf(buff, "%d", mGroupType);
        UtlString arg(buff);

        mpTransactionCnt->add();
        unsigned int transactionId = mpTransactionCnt->getRef();

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_PHONECOMPONENT,
                                                                        TaoMessage::PHONEGROUP_DEACTIVATE,
                                                                        transactionId,
                                                                        0,
                                                                        (TaoObjHandle)pe,
                                                                        1,
                                                                        arg);
        mpClient->sendRequest(msg);

        int rc;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
                EVENT_TRACE("Exiting PtComponentGroup::deactivate, TIME OUT\n") ;
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getEventData((int &)rc);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::PHONEGROUP_DEACTIVATE);
#endif
        mpEventMgr->release(pe);
        mIsActivated = false;

        EVENT_TRACE("Exiting PtComponentGroup::deactivate\n") ;
        return true;
}

/* ============================ ACCESSORS ================================= */
PtStatus PtComponentGroup::getComponents(PtComponent* pComponents[], int size,
                      int& nItems)
{
        EVENT_TRACE("Entering PtComponentGroup::getComponents\n") ;
        if (mpComponents && pComponents)
        {
                nItems = (size < mNumItems) ? size : mNumItems;

                for (int i = 0; i < nItems; i++)
                {
                        pComponents[i] = mpComponents[i];
                }
                return PT_SUCCESS;
        }

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

PtStatus PtComponentGroup::getDescription(char* pDescription, int maxLen)
{
        EVENT_TRACE("Entering PtComponentGroup::getDescription\n") ;
        if (pDescription && maxLen > 0)
        {
                if (!mDescription.isNull())
                {
                        int bytes = strlen(mDescription.data());
                        bytes = (bytes > maxLen) ? maxLen : bytes;

                        memset(pDescription, 0, maxLen);
                        strncpy (pDescription, mDescription.data(), bytes);
                        return PT_SUCCESS;
                }
        }

        EVENT_TRACE("Exiting PtComponentGroup::getDescription\n") ;
        return PT_RESOURCE_UNAVAILABLE;
}

PtStatus PtComponentGroup::getHandsetVolume(int& level)
{
        EVENT_TRACE("Entering PtComponentGroup::getHandsetVolume\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)->getVolume(level);
                                return PT_SUCCESS;
                        }
                }
        }

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

PtStatus PtComponentGroup::getSpeakerVolume(int& level)
{
        EVENT_TRACE("Entering PtComponentGroup::getSpeakerVolume\n") ;
        if (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)->getVolume(level);
                                return PT_SUCCESS;
                        }
                }
        }

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

PtStatus PtComponentGroup::getSpeakerNominalVolume(int& level)
{
        EVENT_TRACE("Entering PtComponentGroup::getSpeakerNominalVolume\n") ;
        if (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)->getNominalVolume(level);
                                return PT_SUCCESS;
                        }
                }
        }

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

PtStatus PtComponentGroup::getExtSpeakerVolume(int& level)
{
        EVENT_TRACE("Entering PtComponentGroup::getExtSpeakerVolume\n") ;
        if (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)->getVolume(level);
                                return PT_SUCCESS;
                        }
                }
        }

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

PtStatus PtComponentGroup::getExtSpeakerNominalVolume(int& level)
{
        EVENT_TRACE("Entering PtComponentGroup::getExtSpeakerNominalVolume\n") ;
        if (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)->getNominalVolume(level);
                                return PT_SUCCESS;
                        }
                }
        }

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

PtStatus PtComponentGroup::getRingerVolume(int& level)
{
        EVENT_TRACE("Entering PtComponentGroup::getRingerVolume\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)->getRingerVolume(level);
                                return PT_SUCCESS;
                        }
                }
        }

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


/* ============================ INQUIRY =================================== */

/* //////////////////////////// PROTECTED ///////////////////////////////// */
void PtComponentGroup::initialize()
{
        mpEventMgr = OsProtectEventMgr::getEventMgr();
        mTimeOut = OsTime(PT_CONST_EVENT_WAIT_TIMEOUT, 0);
    semInit.acquire() ;

        mRef++;

        if (!mpTransactionCnt)
                mpTransactionCnt = new TaoReference();

    semInit.release() ;
}

/* //////////////////////////// PRIVATE /////////////////////////////////// */

/* ============================ FUNCTIONS ================================= */