phoneapp/phoneuiqtviewadapter/src/phoneuicommandcontroller.cpp
changeset 46 bc5a64e5bc3c
parent 45 6b911d05207e
child 50 377c906a8701
child 51 f39ed5e045e0
equal deleted inserted replaced
45:6b911d05207e 46:bc5a64e5bc3c
   312             pluginInd = i;
   312             pluginInd = i;
   313             break;
   313             break;
   314         }
   314         }
   315     }
   315     }
   316     
   316     
   317     if ( -1 == pluginInd )
   317     if ( -1 == pluginInd ) {
   318         {
       
   319         wrapper = new PhoneCommandExtensionWrapper( pluginUid.iUid );
   318         wrapper = new PhoneCommandExtensionWrapper( pluginUid.iUid );
   320         if (wrapper)
   319         if (wrapper) {
   321             m_commandExtensions.append( wrapper );
   320             m_commandExtensions.append( wrapper );
   322         }
   321         }
   323     else
   322     } else {
   324         {
       
   325         wrapper = m_commandExtensions[pluginInd];
   323         wrapper = m_commandExtensions[pluginInd];
   326         }
   324     }
   327     
   325     
   328     m_lastCommandExtension = wrapper;
   326     m_lastCommandExtension = wrapper;
   329     return wrapper;
   327     return wrapper;
   330 }
   328 }
   331 
   329 
   462     
   460     
   463     case EPEStateDialing:
   461     case EPEStateDialing:
   464     case EPEStateConnecting: {
   462     case EPEStateConnecting: {
   465         if (!emergencyCall) {
   463         if (!emergencyCall) {
   466             if (PhoneResourceAdapter::Instance()->buttonsController()->
   464             if (PhoneResourceAdapter::Instance()->buttonsController()->
   467                     getButtonFlags(PhoneUIQtButtonsController::Mute)) {
   465                    getButtonFlags(
   468                 ret.append(PhoneInCallCmdUnmute);
   466                            PhoneUIQtButtonsController::IhfAsPushButton)) {
       
   467                 if (PhoneResourceAdapter::Instance()->buttonsController()->getButtonFlags(
       
   468                         PhoneUIQtButtonsController::BluetoothAvailable)) {
       
   469                     if (PhoneResourceAdapter::Instance()->buttonsController()->getButtonFlags(
       
   470                             PhoneUIQtButtonsController::Btaa)) {
       
   471                         ret.append(PhoneInCallCmdHandset);
       
   472                     } else {
       
   473                         ret.append(PhoneInCallCmdBtHandsfree);
       
   474                     } 
       
   475                 } else {
       
   476                     if (!PhoneResourceAdapter::Instance()->buttonsController()->
       
   477                             getButtonFlags(PhoneUIQtButtonsController::Ihf)) {
       
   478                         ret.append(PhoneInCallCmdActivateIhf);
       
   479                     } else {
       
   480                         ret.append(PhoneInCallCmdDeactivateIhf);
       
   481                     }           
       
   482                 }
   469             } else {
   483             } else {
   470                 ret.append(PhoneInCallCmdMute);
   484                 if (PhoneResourceAdapter::Instance()->buttonsController()->
       
   485                         getButtonFlags(PhoneUIQtButtonsController::Mute)) {
       
   486                     ret.append(PhoneInCallCmdUnmute);
       
   487                 } else {
       
   488                     ret.append(PhoneInCallCmdMute);
       
   489                 }
   471             }
   490             }
   472         }
   491         }
       
   492         
   473         ret.append(PhoneInCallCmdEndOutgoingCall);  
   493         ret.append(PhoneInCallCmdEndOutgoingCall);  
   474     }
   494     }
   475     break;
   495     break;
   476     case EPEStateRinging: {
   496     case EPEStateRinging: {
   477         if (callStates.size()<3){
   497         if (callStates.size()<3){
   487     case EPEStateConnectedConference:     
   507     case EPEStateConnectedConference:     
   488     case EPEStateHeld:
   508     case EPEStateHeld:
   489     case EPEStateHeldConference: {
   509     case EPEStateHeldConference: {
   490         if (!emergencyCall) {
   510         if (!emergencyCall) {
   491             if (PhoneResourceAdapter::Instance()->buttonsController()->
   511             if (PhoneResourceAdapter::Instance()->buttonsController()->
   492                     getButtonFlags(PhoneUIQtButtonsController::Mute)) {
   512                    getButtonFlags(
   493                 ret.append(PhoneInCallCmdUnmute);
   513                            PhoneUIQtButtonsController::IhfAsPushButton)) {
       
   514                 if (PhoneResourceAdapter::Instance()->buttonsController()->getButtonFlags(
       
   515                         PhoneUIQtButtonsController::BluetoothAvailable)) {
       
   516                     if (PhoneResourceAdapter::Instance()->buttonsController()->getButtonFlags(
       
   517                             PhoneUIQtButtonsController::Btaa)) {
       
   518                         ret.append(PhoneInCallCmdHandset);
       
   519                     } else {
       
   520                         ret.append(PhoneInCallCmdBtHandsfree);
       
   521                     } 
       
   522                 } else {
       
   523                     if (!PhoneResourceAdapter::Instance()->buttonsController()->
       
   524                             getButtonFlags(PhoneUIQtButtonsController::Ihf)) {
       
   525                         ret.append(PhoneInCallCmdActivateIhf);
       
   526                     } else {
       
   527                         ret.append(PhoneInCallCmdDeactivateIhf);
       
   528                     }           
       
   529                 }
   494             } else {
   530             } else {
   495                 ret.append(PhoneInCallCmdMute);
   531                 if (PhoneResourceAdapter::Instance()->buttonsController()->
       
   532                         getButtonFlags(PhoneUIQtButtonsController::Mute)) {
       
   533                     ret.append(PhoneInCallCmdUnmute);
       
   534                 } else {
       
   535                     ret.append(PhoneInCallCmdMute);
       
   536                 }
   496             }
   537             }
   497         }
   538         }
   498 
   539 
   499         ret.append(PhoneInCallCmdEndActive);
   540         ret.append(PhoneInCallCmdEndActive);
   500     }
   541     }
   654         action->setIcon(HbIcon("qtg_mono_contacts"));
   695         action->setIcon(HbIcon("qtg_mono_contacts"));
   655         action->setDisabled(disabled);
   696         action->setDisabled(disabled);
   656         action->setCommand(EPhoneInCallCmdContacts); 
   697         action->setCommand(EPhoneInCallCmdContacts); 
   657     }
   698     }
   658     break;
   699     break;
       
   700     case PhoneInCallCmdBtHandsfree: {
       
   701         action = new PhoneAction;
       
   702         action->setIcon(HbIcon("qtg_mono_bluetooth_headset"));
       
   703         action->setDisabled(disabled);
       
   704         action->setCommand(EPhoneInCallCmdBtHandsfree); 
       
   705     }
       
   706     break;
       
   707     case PhoneInCallCmdHandset: {
       
   708         action = new PhoneAction;
       
   709         action->setIcon(HbIcon("qtg_mono_mobile"));
       
   710         action->setDisabled(disabled);
       
   711         action->setCommand(EPhoneInCallCmdHandset); 
       
   712     }
       
   713     break;
   659     default:
   714     default:
   660     break;
   715     break;
   661     }
   716     }
   662             
   717             
   663     return action;
   718     return action;