ptterminal.cpp

来自「基于sipfoundy 公司开发的sipx协议API」· C++ 代码 · 共 1,679 行 · 第 1/5 页

        {
                return PT_NOT_FOUND;
        }

    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

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

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

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_TERMINAL,
                                                                        TaoMessage::GET_CALL_LISTENERS,
                                                                        transactionId,
                                                                        0, //NULL
                                                                        (TaoObjHandle)pe,
                                                                        1,
                                                                        arg);
        mpClient->sendRequest(msg);

        int rc;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // 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::GET_CALL_LISTENERS);
#endif
        mpEventMgr->release(pe);
        return PT_SUCCESS;
}

PtStatus PtTerminal::getComponent(const char* componentName, PtComponent& rComponent)
{
        if (!mpClient)
        {
                return PT_NOT_FOUND;
        }

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

        if (!componentName)
                return PT_RESOURCE_UNAVAILABLE;

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_TERMINAL,
                                                                        TaoMessage::GET_COMPONENT,
                                                                        transactionId,
                                                                        0, //NULL
                                                                        (TaoObjHandle)pe,
                                                                        1,
                                                                        componentName);
        mpClient->sendRequest(msg);

        UtlString arg;
        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getStringData((UtlString &)arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_COMPONENT);
#endif
        mpEventMgr->release(pe);

        TaoString list(arg, TAOMESSAGE_DELIMITER);

        int nItems = atoi(list[0]);
        if (nItems == 1)
        {
                int type = atoi(list[1]);

                switch (type)
                {
                case PtComponent::BUTTON:
                        rComponent = PtPhoneButton(mpClient);
                        break;
                case PtComponent::DISPLAY:
                        rComponent = PtPhoneDisplay(mpClient);
                        break;
                case PtComponent::GRAPHIC_DISPLAY:
                        rComponent = PtPhoneGraphicDisplay(mpClient);
                        break;
                case PtComponent::HOOKSWITCH:
                        rComponent = PtPhoneHookswitch(mpClient);
                        break;
                case PtComponent::LAMP:
                        rComponent = PtPhoneLamp(mpClient);
                        break;
                case PtComponent::MICROPHONE:
                        rComponent = PtPhoneMicrophone(mpClient);
                        break;
                case PtComponent::RINGER:
                        rComponent = PtPhoneRinger(mpClient);
                        break;
                case PtComponent::SPEAKER:
                        rComponent = PtPhoneSpeaker(mpClient);
                        break;
                case PtComponent::EXTERNAL_SPEAKER:
                        rComponent = PtPhoneExtSpeaker(mpClient);
                        break;
                default:
                        break;
                }
        }

        return PT_SUCCESS;
}

PtStatus PtTerminal::getComponentGroups(PtComponentGroup componentGroup[],
                                                                                         int size,
                                                                                         int& nItems)
{
        if (!mpClient)
        {
                return PT_NOT_FOUND;
        }

        if (mpComponentGroups)
        {
                int num = mpComponentGroups->numEntries();
                if (num > 0)
                {
                        TaoObjHandle *objs;
                        objs = new TaoObjHandle[num];

                        mpComponentGroups->getActiveObjects(objs, num);
                        osPrintf("PtTerminal::getComponentGroups found %d component groups.\n", num);
                        if (num > size)
                                num = size;
                        nItems = num;
                        for (int i = 0; i < num; i++)
                        {
                                componentGroup[i] = *((PtComponentGroup *) objs[i]);
                        }
                        delete[] objs;

                        return PT_SUCCESS;
                }
        }

    char buff[MAXIMUM_INTEGER_STRING_LENGTH];

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

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

        OsProtectedEvent *pe = mpEventMgr->alloc();
        TaoMessage      msg(TaoMessage::REQUEST_TERMINAL,
                                                                        TaoMessage::GET_COMPONENTGROUPS,
                                                                        transactionId,
                                                                        0, //NULL
                                                                        (TaoObjHandle)pe,
                                                                        1,
                                                                        arg);

        mpClient->sendRequest(msg);

        if (OS_SUCCESS != pe->wait(msg.getCmd(), mTimeOut))
        {
                mpClient->resetConnectionSocket(msg.getMsgID());
        // If the event has already been signalled, clean up
        if(OS_ALREADY_SIGNALED == pe->signal(0))
        {
            mpEventMgr->release(pe);
        }
                return PT_BUSY;
        }

        pe->getStringData((UtlString &)arg);
#ifdef PTAPI_TEST
        int cmd;
        pe->getIntData2(cmd);
        assert(cmd == TaoMessage::GET_COMPONENTGROUPS);
#endif
        mpEventMgr->release(pe);

        TaoString types(arg, TAOMESSAGE_DELIMITER);

        nItems = atoi(types[0]);
        if (nItems > 0)
        {
                PtComponent* components[9];

                int max = (size < nItems) ? size : nItems;
                for (int i = 0; i < max; i++)
                {
                        int type = atoi(types[i + 1]);
                        TaoObjHandle objValue;

                        switch (type)
                        {
                        case PsTaoComponentGroup::HEAD_SET:
                                if (TAO_NOT_FOUND == mpComponentGroups->findValue(HEAD_SET, objValue))
                                {
                                        PtPhoneMicrophone* pMicrophone = new PtPhoneMicrophone(mpClient);
                                        PtPhoneSpeaker* pSpeaker = new PtPhoneSpeaker(mpClient);
                                        pMicrophone->setGroupType(PtComponentGroup::HEAD_SET);
                                        pSpeaker->setGroupType(PtComponentGroup::HEAD_SET);
                                        components[0] = pMicrophone;
                                        components[1] = pSpeaker;

                                        PtComponentGroup *pGroup = new PtComponentGroup(PtComponentGroup::HEAD_SET,
                                                                                                        "HEAD_SET",
                                                                                                        components,
                                                                                                        2);
                                        pGroup->setTaoClient(mpClient);
                                        componentGroup[i] = *pGroup;
                                        mpComponentGroups->insert(HEAD_SET, (TaoObjHandle)pGroup);
                                }
                                else
                                {
                                        PtComponentGroup *pComponent = (PtComponentGroup *) objValue;
                                        componentGroup[i] = *pComponent;
                                }
                                break;
                        case PsTaoComponentGroup::HAND_SET:
                                if (TAO_NOT_FOUND == mpComponentGroups->findValue(HAND_SET, objValue))
                                {
                                        PtPhoneMicrophone* pMicrophone = new PtPhoneMicrophone(mpClient);
                                        PtPhoneSpeaker* pSpeaker = new PtPhoneSpeaker(mpClient);
                                        pMicrophone->setGroupType(PtComponentGroup::HAND_SET);
                                        pSpeaker->setGroupType(PtComponentGroup::HAND_SET);
                                        components[0] = pMicrophone;
                                        components[1] = pSpeaker;
                                        PtComponentGroup *pGroup = new PtComponentGroup(PtComponentGroup::HAND_SET,
                                                                                                        "HAND_SET",
                                                                                                        components,
                                                                                                        2);
                                        pGroup->setTaoClient(mpClient);
                                        componentGroup[i] = *pGroup;
                                        mpComponentGroups->insert(HAND_SET, (TaoObjHandle)pGroup);
                                }
                                else
                                {
                                        PtComponentGroup *pComponent = (PtComponentGroup *) objValue;
                                        componentGroup[i] = *pComponent;
                                }
                                break;
                        case PsTaoComponentGroup::SPEAKER_PHONE:
                                if (TAO_NOT_FOUND == mpComponentGroups->findValue(SPEAKER_PHONE, objValue))
                                {
                                        PtPhoneMicrophone* pMicrophone = new PtPhoneMicrophone(mpClient);
                                        PtPhoneSpeaker* pSpeaker = new PtPhoneSpeaker(mpClient);
                                        pMicrophone->setGroupType(PtComponentGroup::SPEAKER_PHONE);
                                        pSpeaker->setGroupType(PtComponentGroup::SPEAKER_PHONE);
                                        components[0] = pMicrophone;
                                        components[1] = pSpeaker;
                                        PtComponentGroup *pGroup = new PtComponentGroup(PtComponentGroup::SPEAKER_PHONE,
                                                                                                        "SPEAKER_PHONE",
                                                                                                        components,
                                                                                                        2);
                                        pGroup->setTaoClient(mpClient);
                                        componentGroup[i] = *pGroup;
                                        mpComponentGroups->insert(SPEAKER_PHONE, (TaoObjHandle)pGroup);
                                }
                                else
                                {
                                        PtComponentGroup *pComponent = (PtComponentGroup *) objValue;
                                        componentGroup[i] = *pComponent;
                                }
                                break;
                        case PsTaoComponentGroup::EXTERNAL_SPEAKER:
                                if (TAO_NOT_FOUND == mpComponentGroups->findValue(EXTERNAL_SPEAKER, objValue))
                                {
                                        PtPhoneExtSpeaker* pSpeaker = new PtPhoneExtSpeaker(mpClient);
                                        pSpeaker->setGroupType(PtComponentGroup::EXTERNAL_SPEAKER);
                                        components[0] = pSpeaker;
                                        PtComponentGroup *pGroup = new PtComponentGroup(PtComponentGroup::SPEAKER_PHONE,
                                                                                                        "SPEAKER_PHONE",
                                                                                                        components,
                                                                                                        1);
                                        pGroup->setTaoClient(mpClient);
                                        componentGroup[i] = *pGroup;
                                        mpComponentGroups->insert(EXTERNAL_SPEAKER, (TaoObjHandle)pGroup);
                                }
                                else
                                {
                                        PtComponentGroup *pComponent = (PtComponentGroup *) objValue;
                                        componentGroup[i] = *pComponent;
                                }
                                break;
                        case PsTaoComponentGroup::PHONE_SET:
                                if (TAO_NOT_FOUND == mpComponentGroups->findValue(PHONE_SET, objValue))
                                {
                                        PtPhoneMicrophone* pMicrophone = new PtPhoneMicrophone(mpClient);
                                        PtPhoneSpeaker* pSpeaker = new PtPhoneSpeaker(mpClient);
                                        PtPhoneButton* pButton = new PtPhoneButton(mpClient);
                                        PtPhoneDisplay* pDisplay = new PtPhoneDisplay(mpClient);
                                        PtPhoneHookswitch* pHookswitch = new PtPhoneHookswitch(mpClient);
                                        PtPhoneLamp* pLamp = new PtPhoneLamp(mpClient);
                                        PtPhoneRinger* pRinger = new PtPhoneRinger(mpClient);

                                        pMicrophone->setGroupType(PtComponentGroup::PHONE_SET);
                                        pSpeaker->setGroupType(PtComponentGroup::PHONE_SET);
                                        pButton->setGroupType(PtComponentGroup::PHONE_SET);
                                        pDisplay->setGroupType(PtComponentGroup::PHONE_SET);
                                        pHookswitch->setGroupType(PtComponentGroup::PHONE_SET);
                                        pLamp->setGroupType(PtComponentGroup::PHONE_SET);
                                        pRinger->setGroupType(PtComponentGroup::PHONE_SET);

                                        components[0] = pMicrophone;
                                        components[1] = pSpeaker;
                                        components[2] = pButton;
                                        components[3] = pDisplay;
                                        components[4] = pHookswitch;
                                        components[5] = pLamp;
                                        components[6] = pRinger;
                                        PtComponentGroup *pGroup = new PtComponentGroup(PtComponentGroup::PHONE_SET,
                                                                                                        "PHONE_SET",
                                                                                                        components,
                                                                                                        7);