psphonetask.cpp

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

// Set the speaker volume to a level between 0 (low) and 100 (high)
OsStatus PsPhoneTask::setVolume(int level)
{
    if (mSpkrMode & HANDSET_ENABLED ||
    mSpkrMode & SPEAKERPHONE_ENABLED ||
    mSpkrMode & RINGER_ENABLED ||
    mSpkrMode & SOUND_ENABLED ||
    mSpkrMode & HEADSET_ENABLED)
    {
        osPrintf("< PsPhoneTask::setVolume: %d mode: %d>\n", level, mSpkrMode);
        assert(false);
    }

    return OS_SUCCESS;
}

void PsPhoneTask::extSpeakerConnect(UtlBoolean connected)
{
        int state = PsMsg::EXTSPEAKER_DISCONNECT;
        if (connected)
                state = PsMsg::EXTSPEAKER_CONNECT;

        PsMsg    msg(state, 0, 0, 0);

        postListenerMessage(msg);
}

/* ============================ ACCESSORS ================================= */

// Return the current microphone gain setting (a value from 0..100)
int PsPhoneTask::getGain(void) const
{
        OsStatus rc = OS_UNSPECIFIED;

        int level1 = 0;
        int level = 0;

#ifdef _VXWORKS
   level1 = MpCodec_getGain();
#endif

   switch(mSpkrMode)
   {
   case HANDSET_ENABLED:
                if (mpHandSetGroup)
                        rc = mpHandSetGroup->getMicGain(PsTaoComponentGroup::HAND_SET, level);
           break;
   case SPEAKERPHONE_ENABLED:
           if (mpSpeakerPhoneGroup)
                        rc = mpSpeakerPhoneGroup->getMicGain(PsTaoComponentGroup::SPEAKER_PHONE, level);
           break;
   case RINGER_ENABLED:
           if (mpPhoneSetGroup)
                        rc = mpPhoneSetGroup->getMicGain(PsTaoComponentGroup::PHONE_SET, level);
           break;
   case SOUND_ENABLED:
           if (mpPhoneSetGroup)
                        rc = mpPhoneSetGroup->getMicGain(PsTaoComponentGroup::PHONE_SET, level);
           break;
   case HEADSET_ENABLED:
           if (mpHeadSetGroup)
                        rc = mpHeadSetGroup->getMicGain(PsTaoComponentGroup::HEAD_SET, level);
           break;
   default:
//      assert(FALSE);
      break;
   }

   // :BUG: [XCL-15] This expression is almost certainly wrong, as it
   // returns level only when level == 0.  Bob A. says that getGain is
   // not used these days, so there is no point fixing this code, which is
   // VxWorks-specific anyway.
   return (level ? level1 : level);
}

// Returns the speaker mode for the phone (which speakers are enabled).
int PsPhoneTask::getSpeakerMode(void)
{
   return mSpkrMode;
}

void PsPhoneTask::taoGetNominalVolume(int& volume, int type)
{
        int isNominal = 1;

        switch (type)
        {
        case PtComponentGroup::HEAD_SET:
           if (mpHeadSetGroup)
           {
                        mpHeadSetGroup->getHeadsetVolume(volume, isNominal);
           }
                break;
        case PtComponentGroup::HAND_SET:
           if (mpHandSetGroup)
           {
                        mpHandSetGroup->getHandsetVolume(volume, isNominal);
           }
                break;
        case PtComponentGroup::SPEAKER_PHONE:
           if (mpSpeakerPhoneGroup)
           {
                        mpSpeakerPhoneGroup->getSpeakerVolume(volume, isNominal);
           }
                break;
        case PtComponentGroup::EXTERNAL_SPEAKER:
           if (mpExtSpeakerGroup)
           {
                        mpExtSpeakerGroup->getExtSpeakerVolume(volume, isNominal);
           }
                break;
        case PtComponentGroup::PHONE_SET:
           if (mpPhoneSetGroup)
           {
                        mpPhoneSetGroup->getRingerVolume(volume, isNominal);
           }
                break;
        case PtComponentGroup::RINGER:
        default:
           if (mpPhoneSetGroup)
           {
                        mpPhoneSetGroup->getRingerVolume(volume, isNominal);
           }
                break;
        }
}

void PsPhoneTask::taoGetVolume(int& volume, int type)
{
        switch (type)
        {
        case PtComponentGroup::HEAD_SET:
           if (mpHeadSetGroup)
           {
                        mpHeadSetGroup->getHeadsetVolume(volume);
           }
                break;
        case PtComponentGroup::HAND_SET:
           if (mpHandSetGroup)
           {
                        mpHandSetGroup->getHandsetVolume(volume);
           }
                break;
        case PtComponentGroup::SPEAKER_PHONE:
           if (mpSpeakerPhoneGroup)
           {
                        mpSpeakerPhoneGroup->getSpeakerVolume(volume);
           }
                break;
        case PtComponentGroup::EXTERNAL_SPEAKER:
           if (mpExtSpeakerGroup)
           {
                        mpExtSpeakerGroup->getExtSpeakerVolume(volume);
           }
                break;
        case PtComponentGroup::PHONE_SET:
           if (mpPhoneSetGroup)
           {
                        mpPhoneSetGroup->getRingerVolume(volume);
           }
                break;
        case PtComponentGroup::RINGER:
        default:
           if (mpPhoneSetGroup)
           {
                        mpPhoneSetGroup->getRingerVolume(volume);
           }
                break;
        }
}

void PsPhoneTask::taoSetVolume(int volume, int type)
{
        volume = (volume <= 0) ? 0 : volume;

    osPrintf("PsPhoneTask::taoSetVolume  volume = %d  grouptype = %d  \n",volume,type);

        switch (type)
        {
        case PtComponentGroup::HEAD_SET:
                if (mpHeadSetGroup)
                {
                        mpHeadSetGroup->setHeadsetVolume(volume);
                }
                break;
        case PtComponentGroup::HAND_SET:
                if (mpHandSetGroup)
                {
                        mpHandSetGroup->setHandsetVolume(volume);
                }
                break;
        case PtComponentGroup::SPEAKER_PHONE:
                if (mpSpeakerPhoneGroup)
                {
                        mpSpeakerPhoneGroup->setSpeakerVolume(volume);
                }
                break;
        case PtComponentGroup::EXTERNAL_SPEAKER:
                if (mpExtSpeakerGroup)
                {
                        mpExtSpeakerGroup->setExtSpeakerVolume(volume);
                }
                break;
        case PtComponentGroup::PHONE_SET:
                if (mpPhoneSetGroup)
                {
                        mpPhoneSetGroup->setRingerVolume(volume);
                }
                break;
        case PtComponentGroup::RINGER:
                if (mpPhoneSetGroup)
                {
                        mpPhoneSetGroup->setRingerVolume(volume);
                }
                break;
        default:
                break;
        }

    //if the group type is correct for the given mSpkMode then it's ok to REALLY change the value.

    if ((type == PtComponentGroup::HEAD_SET && (mSpkrMode & HEADSET_ENABLED)) ||
        (type == PtComponentGroup::HAND_SET && (mSpkrMode & HANDSET_ENABLED)) ||
        (type == PtComponentGroup::SPEAKER_PHONE && (mSpkrMode & SPEAKERPHONE_ENABLED)) ||
        (type == PtComponentGroup::PHONE_SET && (mSpkrMode & RINGER_ENABLED)) ||
        (type == PtComponentGroup::RINGER && (mSpkrMode & RINGER_ENABLED)) ||
        (type == PtComponentGroup::EXTERNAL_SPEAKER && (mSpkrMode & SPEAKERPHONE_ENABLED)))
    {
        setVolume(volume);
            osPrintf("<-- taoSetVolume %d -->\n", volume);
    }
}

// Return the current speaker volume setting (a value from 0..100)
int PsPhoneTask::getVolume()
{
        int level = 0;

   switch(mSpkrMode)
   {
   case HANDSET_ENABLED:
           if (mpHandSetGroup)
           {
                        mpHandSetGroup->getHandsetVolume(level);
                        osPrintf("->>PsPhoneTask::getVolume: HANDSET_ENABLED: %d<<-\n", level);
           }
           break;
   case SPEAKERPHONE_ENABLED:
           if (mpSpeakerPhoneGroup)
           {
                        mpSpeakerPhoneGroup->getSpeakerVolume(level);
                        osPrintf("->>PsPhoneTask::getVolume: SPEAKERPHONE_ENABLED: %d<<-\n", level);
           }
           break;
   case EXTSPEAKER_ENABLED:
           if (mpExtSpeakerGroup)
           {
                        mpExtSpeakerGroup->getExtSpeakerVolume(level);
                        osPrintf("->>PsPhoneTask::getVolume: EXTSPEAKER_ENABLED: %d<<-\n", level);
           }
           break;
   case SOUND_ENABLED:
           if (mpPhoneSetGroup)
           {
                        mpPhoneSetGroup->getSpeakerVolume(level);
                        osPrintf("->>PsPhoneTask::getVolume: SOUND_ENABLED: %d<<-\n", level);
           }
           break;
   case RINGER_ENABLED:
   default:
           if (mpPhoneSetGroup)
           {
                        mpPhoneSetGroup->getRingerVolume(level);
                        osPrintf("->>PsPhoneTask::getVolume: RINGER_ENABLED: %d<<-\n", level);
           }
           break;
   }

        return level;
}


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

/* //////////////////////////// PROTECTED ///////////////////////////////// */

// Default constructor (called only indirectly via getPhoneTask())
PsPhoneTask::PsPhoneTask()
:  OsServerTask("PsPhone"),
   mMutex(OsRWMutex::Q_PRIORITY),  // create mutex for protecting data
   mpButtonTask(NULL),
   mpHookswTask(NULL),
   mpLampTask(NULL),
   mSpkrMode(0),

   mpListeners(NULL),
   mpListenerCnt(NULL),
   mpActiveListeners(NULL),

   mpTaoHooksw(NULL),
   mpTaoButton(NULL),
   mpTaoLamp(NULL),
   mpTaoRinger(NULL),
   mpTaoDisplay(NULL),

   mpHeadSetGroup(NULL),
   mpTaoHeadsetMic(NULL),
   mpTaoHeadsetSpeaker(NULL),

   mpHandSetGroup(NULL),
   mpTaoHandsetMic(NULL),
   mpTaoHandsetSpeaker(NULL),

   mpExtSpeakerGroup(NULL),
   mpSpeakerPhoneGroup(NULL),
   mpPhoneSetGroup(NULL),
   mpTaoBaseMic(NULL),
   mpTaoBaseSpeaker(NULL),
   mpTaoExtSpeaker(NULL),

   mpOtherGroup(NULL),
   mStepSize(10),
   mHigh(100),
   mLow(0),
   mNominal(5),
   mSplash(4)
{
   mpHookswTask = PsHookswTask::getHookswTask();  // hook switch handling

   mpButtonTask = PsButtonTask::getButtonTask();  // keypad handling

   mpLampTask = PsLampTask::getLampTask();        // lamp handling

   // initialize platform-specific settings
   initPlatformButtonSettings(mpButtonTask);
   initComponentGroups();
}

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

// Handle an incoming message.
// Return TRUE if the message was handled, otherwise FALSE.
UtlBoolean PsPhoneTask::handleMessage(OsMsg& rMsg)
{
   UtlBoolean   processed;
   OsWriteLock lock(mMutex);            // acquire a write lock

   switch (rMsg.getMsgType())
   {
   case OsMsg::PS_MSG:
      processed = handlePhoneMessage((PsMsg&) rMsg);
      break;
   default:
      assert(FALSE);
      processed = FALSE;                // unexpected message type
      break;
   }

   return processed;
}

// Handle an incoming phone message (class PsMsg or descendants).
// Return TRUE if the message was handled, otherwise FALSE.
// A write lock should be acquired before calling this method.
UtlBoolean PsPhoneTask::handlePhoneMessage(const PsMsg& rMsg)
{
   UtlBoolean processed;

   void* msgSrc;
   int   msgType;
   int   param1;
   int   param2;

   processed = TRUE;

   msgType = rMsg.getMsg();
   msgSrc  = rMsg.getMsgSource();
   param1  = rMsg.getParam1();
   param2  = rMsg.getParam2();
   TaoMessage *pMsg = (TaoMessage *) &rMsg;

   switch (msgType)
   {
   case PsMsg::BUTTON_DOWN:
   case PsMsg::BUTTON_REPEAT:
   case PsMsg::BUTTON_UP:
   case PsMsg::KEY_DOWN:
   case PsMsg::KEY_UP:


      if (mpListeners != NULL)
      {
         postListenerMessage(rMsg);
      }
      else