1 /*!

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Handles phone ui commands.

    15 */

    16 

    17 #include "phoneuicommandcontroller.h"

    18 #include "phoneresourceadapter.h"

    19 #include <QtDebug>

    20 #include <hbaction.h>

    21 #include <spsettings.h>

    22 #include <spentry.h>

    23 #include <spproperty.h>

    24 #include <xqphoneappcommands.h>

    25 #include <phoneappcommands.hrh>

    26 #include <phoneappvoipcommands.hrh>

    27 #include <pevirtualengine.h>

    28 #include <xqteluicommandextension.h>

    29 

    30   

    31 PhoneUiCommandController::PhoneUiCommandController(

    32         PhoneUIQtViewIF &view, QObject *parent) 

    33 : QObject (parent), m_view(view), m_lastCommandExtension(0)

    34 {

    35     qDebug() << "PhoneMenuController::PhoneMenuController";

    36 }

    37 

    38 PhoneUiCommandController::~PhoneUiCommandController()

    39 {

    40     qDebug() << "PhoneMenuController::~PhoneMenuController";

    41     for (int i=0;i<m_commandExtensions.count();++i) {

    42         m_commandExtensions.at(i)->release();

    43     }

    44 }

    45 

    46 void PhoneUiCommandController::setCallMenuActions(

    47         QMap<int,int> callStates, QMap<int,int> serviceIds, 

    48         int serviceId, int expandedCallId )

    49 {

    50     qDebug() << "PhoneMenuController::setCallMenuActions";

    51     releaseMenu();

    52     

    53     PhoneCommandExtensionWrapper *extension = commandExtension(serviceId);

    54     QList<int> menuCmdList = menuCommands(callStates, serviceIds);

    55     

    56     if (extension) {

    57         QList<XQTelUiCommandExtension::CallInfo> callInfo;

    58         extension->getCallInfoList(

    59                 callInfo,callStates,serviceIds,expandedCallId);

    60         

    61         //Modify command list by extension

    62         extension->modifyMenuCommandList(callInfo,menuCmdList);

    63         addMenuItems(menuCmdList);

    64         

    65         extension->addMenuActions(callInfo,m_customMenuActions);        

    66         for (int i=0;i<m_customMenuActions.count();++i) {

    67             m_view.menuReference().addAction(m_customMenuActions.at(i));

    68         }

    69     } else {

    70         addMenuItems(menuCmdList);

    71     }

    72         

    73     

    74 }

    75 

    76 void PhoneUiCommandController::setDialpadMenuActions()

    77 {

    78     qDebug() << "PhoneMenuController::setDialpadMenuActions";

    79     releaseMenu();

    80     QList<PhoneAction*> values;

    81     m_view.setMenuActions(values);

    82     qDeleteAll(values);

    83 }

    84 

    85 QMap<PhoneAction::ActionType, PhoneAction *> 

    86     PhoneUiCommandController::pushButtonActionsForCall( 

    87         int callState,

    88         bool emergencyCall,

    89         QMap<int,int> callStates,

    90         QMap<int,int> serviceIds,

    91         int serviceId,

    92         int callId)

    93 {

    94     QMap<PhoneAction::ActionType, PhoneAction *> translatedActions;

    95     bool sameServices = areServicesSame(callStates, serviceIds);

    96     QList<int> commands = buttonCommandList(

    97             callState, emergencyCall, sameServices, callStates.values());

    98 

    99     PhoneCommandExtensionWrapper *extension = commandExtension(serviceId);

   100     

   101     if (extension) {

   102         QList<XQTelUiCommandExtension::CallInfo> callInfo;

   103         extension->getCallInfoList(

   104                 callInfo,callStates,serviceIds,callId);

   105         

   106         //Modify command list by extension

   107         extension->modifyPushButtonCommandList(callInfo,commands);

   108     }

   109     

   110     if (1 == commands.count()) {

   111         PhoneAction *action = mapCommandToAction(commands.at(0));

   112         if (action) {

   113             translatedActions[PhoneAction::LeftButton] = action;

   114         }

   115     } else if (1 < commands.count()){

   116         PhoneAction *action = mapCommandToAction(commands.at(0));

   117         PhoneAction *action2 = mapCommandToAction(commands.at(1));

   118         if (action) {

   119             translatedActions[PhoneAction::LeftButton] = action;

   120         }

   121         if (action2) {

   122             translatedActions[PhoneAction::RightButton] = action2;

   123         }

   124     }

   125     

   126     return translatedActions;

   127 }

   128 

   129 QList<int> PhoneUiCommandController::menuCommands(

   130         QMap<int,int> callStates, QMap<int,int> serviceIds )

   131 {

   132     qDebug() << "PhoneMenuController::menuCommands";

   133     QList<int> commands;

   134     bool sameServices = areServicesSame(callStates,serviceIds);

   135 

   136     switch(callStates.values().count()) {

   137     case 1:

   138         // No logical string for switch to video option	

   139         /*if (callStates.values().contains(EPEStateConnected)) {

   140             commands.append(PhoneInCallCmdSwitchToVideo);

   141         }*/

   142         break;

   143     case 2:

   144         if (callStates.values().contains(EPEStateConnected) &&

   145             callStates.values().contains(EPEStateHeld)) {

   146             commands.append(PhoneInCallCmdEndAllCalls);

   147             if (sameServices) {

   148                 commands.append(PhoneInCallCmdTransfer);

   149             }

   150         }

   151         break;

   152     case 3:

   153 

   154         break;

   155     default:

   156         break;

   157     }

   158     

   159     return commands;

   160 }

   161 

   162 void PhoneUiCommandController::addMenuItems(QList<int> menuCmdList)

   163 {

   164     QList<PhoneAction*> values;

   165     

   166     for (int i=0;i<menuCmdList.count();++i) {

   167         int command = mapCommand(menuCmdList.at(i));

   168         if (-1 != command) {

   169             PhoneAction* phoneAction = new PhoneAction();

   170             phoneAction->setCommand(command);

   171             phoneAction->setText(

   172                     PhoneResourceAdapter::Instance()->

   173                         convertCommandToString(command));

   174             

   175             values.append(phoneAction);

   176         }

   177     }

   178     

   179     m_view.setMenuActions(values);

   180     qDeleteAll(values);

   181 }

   182 

   183 int PhoneUiCommandController::mapCommand(int command)

   184 {

   185     int ret(-1);

   186     

   187     switch(command) {

   188     case PhoneInCallCmdEndAllCalls:

   189         ret = EPhoneInCallCmdEndAllCalls;

   190         break;     

   191     case PhoneInCallCmdTransfer:

   192         ret = EPhoneInCallCmdTransfer;

   193         break;    

   194     case PhoneInCallCmdSwitchToVideo:

   195         ret = EPhoneInCallCmdSwitchToVideo;

   196         break;  

   197     case PhoneInCallCmdSendMessage:

   198         //TODO

   199         break;    

   200     case PhoneInCallShareVideo:

   201         //TODO

   202         break;

   203     case PhoneInCallCmdHandoverToWlan:

   204         ret = EPhoneCmdHandoverToWlan;

   205         break;

   206     case PhoneInCallCmdHandoverToGsm:

   207         ret = EPhoneCmdHandoverToGsm;

   208         break;

   209     default:

   210         break;

   211     }

   212     

   213     return ret;

   214 }

   215 

   216 PhoneCommandExtensionWrapper *PhoneUiCommandController::commandExtension(

   217         int serviceId)

   218 {

   219     PhoneCommandExtensionWrapper *extension = 0;

   220     TRAP_IGNORE( extension = CommandExtensionL(serviceId) );

   221     return extension;

   222 }

   223 

   224 TUid PhoneUiCommandController::ResolveImplementationUidL( 

   225         TUint32 aServiceId, TServicePropertyName aPropertyName )

   226     {

   227     TUid implUid = { 0 };

   228     CSPEntry* entry = CSPEntry::NewLC();

   229 

   230     CSPSettings* spSettings = CSPSettings::NewLC(); 

   231     

   232     User::LeaveIfError(

   233         spSettings->FindEntryL( aServiceId, *entry ) ); 

   234 

   235     CleanupStack::PopAndDestroy( spSettings ); 

   236 

   237     const CSPProperty* property = NULL;

   238     User::LeaveIfError( entry->GetProperty( property, aPropertyName ) );

   239     

   240     if ( property ) 

   241         {

   242         TInt temp(0);

   243         User::LeaveIfError( property->GetValue( temp ) );

   244         implUid.iUid = temp;

   245         }

   246 

   247     CleanupStack::PopAndDestroy( entry );

   248     return implUid;   

   249     }

   250 

   251 PhoneCommandExtensionWrapper 

   252     *PhoneUiCommandController::CommandExtensionL( TUint aServiceId )

   253 {

   254     TUid pluginUid = ResolveImplementationUidL( aServiceId, 

   255         EPropertyCallMenuHandlerPluginId );

   256     

   257     int pluginInd(-1);

   258     PhoneCommandExtensionWrapper* wrapper = NULL;

   259     

   260     for (int i=0; i<m_commandExtensions.count();++i) {

   261         if (pluginUid.iUid==m_commandExtensions.at(i)->pluginUid()) {

   262             pluginInd = i;

   263             break;

   264         }

   265     }

   266     

   267     if ( -1 == pluginInd )

   268         {

   269         wrapper = new PhoneCommandExtensionWrapper( pluginUid.iUid );

   270         if (wrapper)

   271             m_commandExtensions.append( wrapper );

   272         }

   273     else

   274         {

   275         wrapper = m_commandExtensions[pluginInd];

   276         }

   277     

   278     m_lastCommandExtension = wrapper;

   279     return wrapper;

   280 }

   281 

   282 void PhoneUiCommandController::releaseMenu()

   283 {

   284     qDebug() << "PhoneMenuController::setDialpadMenuActions";

   285     for (int i=0;i<m_customMenuActions.count();i++) {

   286         m_view.menuReference().removeAction(m_customMenuActions.at(i));

   287     }

   288     m_customMenuActions.clear();

   289     

   290     if (m_lastCommandExtension) {

   291         m_lastCommandExtension->releaseMenu();

   292         m_lastCommandExtension = 0;

   293     }

   294 }

   295 

   296 bool PhoneUiCommandController::areServicesSame(

   297         QMap<int,int> callStates, QMap<int,int> serviceIds)

   298 {

   299     bool ret(true);

   300     int serviceId(-1);

   301     for(int i=0;i<callStates.count()&&ret;++i) {

   302         if (-1==serviceId) {

   303             serviceId = serviceIds.value(callStates.keys().at(i));

   304         } else if (serviceId!=serviceIds.value(callStates.keys().at(i))) {

   305             ret = false;

   306         }

   307     }

   308     

   309     return ret;

   310 }

   311 

   312 QList<int> PhoneUiCommandController::buttonCommandList(

   313         int callState,

   314         bool emergencyCall,

   315         bool sameServices,

   316         QList<int> callStates)

   317 {

   318     QList<int> ret;

   319     

   320     switch( callState ) {

   321     case EPEStateIdle:

   322     case EPEStateDisconnecting:

   323     case EPEStateConferenceIdle:    

   324     break;

   325     

   326     case EPEStateDialing:

   327     case EPEStateConnecting: {

   328         ret.append(PhoneInCallCmdEndOutgoingCall);  

   329     }

   330     break;

   331     case EPEStateRinging: {

   332         if (callStates.size()<3){

   333             ret.append(PhoneInCallCmdAnswer);

   334             ret.append(PhoneInCallCmdReject); 

   335         } else {

   336             ret.append(PhoneInCallCmdReplace); 

   337         }

   338     }

   339     break;

   340     

   341     case EPEStateConnected:

   342     case EPEStateConnectedConference: {

   343         if (!emergencyCall) {

   344             if ( 1 == callStates.size() || 

   345                  (2 == callStates.size() && 

   346                   callStates.contains(EPEStateRinging)) ) {

   347                 ret.append(PhoneInCallCmdHold);

   348             } else {

   349                 

   350                 if (EPEStateConnectedConference == callState) {

   351                     ret.append(PhoneInCallCmdSwap);

   352                 } else if (sameServices) {

   353                     if ( callStates.contains(EPEStateHeldConference) ) {

   354                         ret.append(PhoneInCallCmdJoinToConference);                  

   355                     } else {

   356                         ret.append(PhoneInCallCmdCreateConference);

   357                     }

   358                 }

   359             }            

   360         }

   361         

   362         ret.append(PhoneInCallCmdEndActive); 

   363     }

   364     break;

   365     

   366     case EPEStateHeld:

   367     case EPEStateHeldConference: {

   368         if (1 == callStates.size() || 

   369             (2 == callStates.size() && 

   370              callStates.contains(EPEStateRinging))) {

   371              

   372             ret.append(PhoneInCallCmdUnhold);

   373         } else {

   374             if (EPEStateHeldConference == callState) {

   375                 ret.append(PhoneInCallCmdSwap);

   376             } else if (sameServices) {

   377                 if ( callStates.contains(EPEStateConnectedConference)) {

   378                     ret.append(PhoneInCallCmdJoinToConference);

   379                 } else {

   380                     ret.append(PhoneInCallCmdCreateConference);

   381                 }

   382             }

   383         }

   384 

   385         ret.append(PhoneInCallCmdEndActive);

   386     }

   387     break;

   388     

   389     case EPEStateUnknown:

   390     break;

   391     

   392     default:

   393     break;    

   394     }

   395     

   396     return ret;

   397 }

   398 

   399 PhoneAction *PhoneUiCommandController::mapCommandToAction(int command)

   400 {

   401     PhoneAction *action=0;

   402     

   403     switch( command ) {

   404     case PhoneInCallCmdJoinToConference: {

   405         action = new PhoneAction;

   406         action->setIcon(HbIcon(":/qtg_mono_join_call.svg"));

   407         action->setCommand(EPhoneInCallCmdJoin);

   408     }

   409     break;

   410 

   411     case PhoneInCallCmdCreateConference: {

   412         action = new PhoneAction;

   413         action->setIcon(HbIcon(":/qtg_mono_join_call.svg"));

   414         action->setCommand(EPhoneInCallCmdCreateConference);

   415     }

   416     break;

   417         

   418     case PhoneInCallCmdAnswer: {

   419         action = new PhoneAction;

   420         action->setIcon(HbIcon(":/qtg_mono_answer_call.svg"));

   421         action->setCommand (EPhoneCallComingCmdAnswer);

   422         action->setActionRole(PhoneAction::Accept);

   423     }

   424     break;

   425     

   426     case PhoneInCallCmdReject: {

   427         action = new PhoneAction;

   428         action->setIcon(HbIcon(":/qtg_mono_reject_call.svg"));

   429         action->setCommand (EPhoneCallComingCmdReject);

   430         action->setActionRole(PhoneAction::Decline);

   431     }

   432     break;

   433     

   434     case PhoneInCallCmdHold: {

   435         action = new PhoneAction;

   436         action->setIcon(HbIcon(":/qtg_mono_hold_call.svg"));

   437         action->setCommand(EPhoneInCallCmdHold);

   438     }

   439     break;

   440     

   441     case PhoneInCallCmdUnhold: {

   442         action = new PhoneAction;

   443         action->setIcon(HbIcon(":/qtg_mono_answer_call.svg")); // todo icon missing

   444         action->setCommand(EPhoneInCallCmdUnhold);

   445     }

   446     break;

   447     

   448     case PhoneInCallCmdEndActive: {

   449         action = new PhoneAction;

   450         action->setIcon(HbIcon(":/qtg_mono_end_call.svg"));

   451         action->setCommand(EPhoneInCallCmdEndThisActiveCall);

   452         action->setActionRole(PhoneAction::Decline);

   453     }

   454     break;

   455     

   456     case PhoneInCallCmdEndOutgoingCall: {

   457         action = new PhoneAction;

   458         action->setIcon(HbIcon(":/qtg_mono_end_call.svg"));

   459         action->setCommand(EPhoneInCallCmdEndThisOutgoingCall);

   460         action->setActionRole(PhoneAction::Decline);

   461     }

   462     break;

   463 

   464     case PhoneInCallCmdReplace: {

   465         action = new PhoneAction;

   466         action->setIcon(HbIcon(":/qtg_mono_replace_call.svg"));

   467         action->setCommand(EPhoneInCallCmdReplace);

   468         action->setActionRole(PhoneAction::Accept);

   469     }

   470     break;

   471     

   472     case PhoneInCallCmdSwap: {

   473         action = new PhoneAction;

   474         action->setIcon(HbIcon(":/qgn_indi_button_swap.svg"));

   475         action->setCommand(EPhoneInCallCmdSwap); 

   476     }

   477     break;

   478     

   479     default:

   480     break;

   481     }

   482             

   483     return action;

   484 }