1 /*

     2 * Copyright (c) 2005-2008 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: Implementation of CPhoneConference class.

    15 *

    16 */

    17 

    18 

    19 // INCLUDES

    20 #include <eikmenub.h> 

    21 #include <eikenv.h>

    22 #include <StringLoader.h>

    23 #include <pevirtualengine.h>

    24 #include <mpeengineinfo.h>

    25 #include <cpephonemodelif.h>

    26 #include <featmgr.h>

    27 #include "cphoneconference.h"

    28 #include "mphonestatemachine.h"

    29 #include "phoneviewcommanddefinitions.h"

    30 #include "phoneui.hrh"

    31 #include "cphonemainresourceresolver.h"

    32 #include "phonerssbase.h"

    33 #include "tphonecmdparaminteger.h"

    34 #include "tphonecmdparamboolean.h"

    35 #include "tphonecmdparamstring.h"

    36 #include "tphonecmdparamcallheaderdata.h"

    37 #include "tphonecmdparamkeyevent.h"

    38 #include "phonestatedefinitions.h"

    39 #include "tphonecmdparamglobalnote.h"

    40 #include "phonestatedefinitionsgsm.h"

    41 #include "tphonecmdparamcallstatedata.h"

    42 #include "cphonekeys.h"

    43 #include "phonelogger.h"

    44 

    45 // ================= MEMBER FUNCTIONS =======================

    46 

    47 // C++ default constructor can NOT contain any code, that

    48 // might leave.

    49 //

    50 CPhoneConference::CPhoneConference( 

    51     MPhoneStateMachine* aStateMachine, 

    52     MPhoneViewCommandHandle* aViewCommandHandle,

    53     MPhoneCustomization* aPhoneCustomization ) : 

    54     CPhoneGsmInCall( aStateMachine, aViewCommandHandle, aPhoneCustomization )

    55     {

    56     }

    57 

    58 // -----------------------------------------------------------

    59 // CPhoneConference::~CPhoneConference()

    60 // Destructor

    61 // (other items were commented in a header).

    62 // -----------------------------------------------------------

    63 //

    64 CPhoneConference::~CPhoneConference()

    65     {

    66     }

    67 

    68 // -----------------------------------------------------------

    69 // CPhoneConference::ConstructL()

    70 // Constructor

    71 // (other items were commented in a header).

    72 // -----------------------------------------------------------

    73 //

    74 void CPhoneConference::ConstructL()

    75     {

    76     CPhoneGsmInCall::ConstructL();

    77     

    78     // Re-enable global notes

    79     TPhoneCmdParamBoolean globalNotifierParam;

    80     globalNotifierParam.SetBoolean( EFalse );

    81     iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,

    82         &globalNotifierParam );

    83     

    84   

    85     DefineAndSetHoldFlagL();

    86     

    87     }

    88 

    89 // -----------------------------------------------------------

    90 // CPhoneConference::NewL()

    91 // Constructor

    92 // (other items were commented in a header).

    93 // -----------------------------------------------------------

    94 //

    95 CPhoneConference* CPhoneConference::NewL( 

    96     MPhoneStateMachine* aStateMachine, 

    97     MPhoneViewCommandHandle* aViewCommandHandle,

    98     MPhoneCustomization* aPhoneCustomization )

    99     {

   100     CPhoneConference* self = new( ELeave ) CPhoneConference( 

   101         aStateMachine, aViewCommandHandle, aPhoneCustomization );

   102     

   103     CleanupStack::PushL( self );

   104     self->ConstructL();

   105     CleanupStack::Pop( self );

   106     

   107     return self;

   108     }

   109 

   110 // -----------------------------------------------------------

   111 // CPhoneConference::HandlePhoneEngineMessageL

   112 // -----------------------------------------------------------

   113 //

   114 void CPhoneConference::HandlePhoneEngineMessageL( 

   115     const TInt aMessage, 

   116     TInt aCallId )

   117     {

   118     __LOGMETHODSTARTEND( EPhoneUIStates, 

   119         "CPhoneConference::HandlePhoneEngineMessageL()");

   120     switch ( aMessage )

   121         {

   122         case MEngineMonitor::EPEMessageIdle:

   123             HandleIdleL( aCallId );

   124             break;

   125         

   126         case MEngineMonitor::EPEMessageConferenceIdle:

   127             HandleConferenceIdleL();

   128             break;

   129             

   130         case MEngineMonitor::EPEMessageHeldConference:

   131             HandleHeldConferenceL( aCallId );

   132             break;

   133             

   134         case MEngineMonitor::EPEMessageConnectedConference:

   135             HandleConnectedConferenceL();

   136             break;

   137 

   138         case MEngineMonitor::EPEMessageAddedConferenceMember:

   139             UpdateConferenceSecurityStatusL( aCallId );

   140             break;

   141             

   142         case MEngineMonitor::EPEMessageWentOneToOne:

   143             HandleWentOneToOneL( aCallId );

   144             break;

   145             

   146         case MEngineMonitor::EPEMessageHeld:

   147             {

   148             TPhoneCmdParamCallHeaderData callHeaderParam;

   149             callHeaderParam.SetCallState( EPEStateHeld );

   150             iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, aCallId, 

   151                 &callHeaderParam );

   152             }

   153             break;

   154             

   155         case MEngineMonitor::EPEMessageConnected:

   156             {

   157             TPhoneCmdParamCallHeaderData callHeaderParam;

   158             callHeaderParam.SetCallState( EPEStateConnected );

   159             iViewCommandHandle->ExecuteCommandL( EPhoneViewUpdateBubble, aCallId, 

   160                 &callHeaderParam );

   161             }

   162             break;

   163             

   164         case MEngineMonitor::EPEMessageDialing:

   165             HandleDiallingL( aCallId );

   166             break;

   167             

   168         case MEngineMonitor::EPEMessageIncoming:

   169             HandleIncomingL( aCallId );

   170             break;

   171 

   172         default:

   173             CPhoneGsmInCall::HandlePhoneEngineMessageL( aMessage, aCallId );

   174             break;

   175         }

   176     }

   177 

   178 // -----------------------------------------------------------

   179 // CPhoneConference:HandleCommandL

   180 // -----------------------------------------------------------

   181 //

   182 TBool CPhoneConference::HandleCommandL( TInt aCommand )

   183     {

   184     __LOGMETHODSTARTEND( EPhoneUIStates, 

   185         "CPhoneConference::HandleCommandL()");

   186     TBool commandStatus = ETrue;

   187 

   188     switch( aCommand )

   189         {   

   190         case EAknSoftkeyCancel:

   191             BeginUiUpdateLC();

   192             CloseSelectionListL();

   193             SetTouchPaneButtons( EPhoneConferenceButtons );

   194             EndUiUpdate();    

   195             UpdateCbaL( EPhoneCallHandlingInCallCBA );

   196             break;

   197     

   198         case EPhoneInCallCmdHold:

   199         case EPhoneInCallCmdConferenceHold:

   200             iStateMachine->SendPhoneEngineMessage( 

   201                 CPEPhoneModelIF::EPEMessageHoldConference );

   202             break;

   203             

   204         case EPhoneInCallCmdUnhold:

   205         case EPhoneInCallCmdConferenceUnhold:

   206             iStateMachine->SendPhoneEngineMessage( 

   207                 CPEPhoneModelIF::EPEMessageResumeConference );

   208             break;

   209             

   210         // Conference -> Drop participant

   211         case EPhoneInCallCmdDropSelection:

   212             OpenDropParticipantSelectionL();

   213             break;

   214         

   215         // Drop CBA    

   216         case EPhoneInCallCmdDrop:

   217             DropSelectedParticipantL();

   218             break;

   219             

   220         case EPhoneInCallCmdPrivateSelection:

   221             OpenPrivateSelectionL();

   222             break;

   223             

   224         case EPhoneInCallCmdPrivate:

   225             PrivateSelectedParticipantL();

   226             break;

   227           

   228         case EPhoneInCallCmdNewCall:

   229             LaunchNewCallQueryL();

   230             break;

   231             

   232         case EPhoneInCallCmdNewCallCall:

   233             CallFromNewCallQueryL();

   234             break;

   235             

   236         case EPhoneInCallCmdParticipants:

   237             OpenParticipantsListL();

   238             break;

   239             

   240         case EPhoneViewOpenNumberEntry:

   241             if ( IsConferenceBubbleInSelectionMode() )

   242                 {

   243                 CloseSelectionListL();

   244                 SetTouchPaneButtons( EPhoneConferenceButtons );

   245                 }

   246             commandStatus = CPhoneGsmInCall::HandleCommandL( aCommand );

   247             break;            

   248 

   249         default:

   250             commandStatus = CPhoneGsmInCall::HandleCommandL( aCommand );

   251             break;

   252         }

   253 

   254     return commandStatus;

   255     }

   256 

   257 // -----------------------------------------------------------

   258 // CPhoneConference::UpdateInCallCbaL

   259 // -----------------------------------------------------------

   260 //

   261 void CPhoneConference::UpdateInCallCbaL()

   262     {

   263     if ( iViewCommandHandle->HandleCommandL( EPhoneViewIsConferenceInExpandedMode ) 

   264         != EPhoneViewResponseSuccess )

   265         {

   266         UpdateCbaL( EPhoneCallHandlingInCallCBA );

   267         }    

   268     }

   269 

   270 // -----------------------------------------------------------

   271 // CPhoneConference::OpenMenuBarL

   272 // -----------------------------------------------------------

   273 //

   274 void CPhoneConference::OpenMenuBarL()

   275     {

   276     __LOGMETHODSTARTEND( EPhoneUIStates, 

   277         "CPhoneConference::OpenMenuBarL()");

   278     TInt resourceId;

   279 

   280     if ( iOnScreenDialer && IsDTMFEditorVisibleL() )

   281         {

   282         resourceId = EPhoneDtmfDialerMenubar;

   283         }

   284     else if ( IsNumberEntryVisibleL() )

   285         {

   286         resourceId = EPhoneConfCallMenubarWithNumberEntry;

   287         }

   288     else if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) 

   289               && IsConferenceBubbleInSelectionMode() )        

   290         {

   291         resourceId = EPhoneConfCallParticipantsMenubar;            

   292         }

   293     else

   294         {

   295         resourceId = EPhoneConfCallMenubar;

   296         }

   297 

   298     TPhoneCmdParamInteger integerParam;

   299     integerParam.SetInteger( 

   300         CPhoneMainResourceResolver::Instance()->

   301         ResolveResourceID( resourceId ) );

   302     iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarOpen, 

   303         &integerParam );

   304     }

   305 

   306 // -----------------------------------------------------------

   307 // CPhoneConference::HandleKeyEventL

   308 // -----------------------------------------------------------

   309 //

   310 void CPhoneConference::HandleKeyEventL( 

   311     const TKeyEvent& aKeyEvent, 

   312     TEventCode aEventCode )

   313     {

   314     __LOGMETHODSTARTEND( EPhoneUIStates, 

   315         "CPhoneConference::HandleKeyEventL()");

   316     if ( IsConferenceBubbleInSelectionMode() )

   317         {

   318         if ( aKeyEvent.iCode == EKeyUpArrow ||

   319              aKeyEvent.iCode == EKeyDownArrow )

   320             {

   321             TPhoneCmdParamKeyEvent keyEventParam;

   322             keyEventParam.SetKeyEvent( aKeyEvent );

   323             keyEventParam.SetEventCode( aEventCode );    

   324             

   325             iViewCommandHandle->ExecuteCommandL( 

   326                 EPhoneViewMoveHighLightInList, &keyEventParam );

   327             }

   328         }

   329     else

   330         {

   331         if ( CPhoneKeys::IsNumericKey( aKeyEvent, aEventCode ) )

   332             {

   333             // Handle numeric keys when key events are received 

   334             // in conference state.

   335             CPhoneGsmInCall::HandleNumericKeyEventL( aKeyEvent, aEventCode );

   336             }

   337         else

   338             {

   339             // Handle other key events.

   340             CPhoneState::HandleKeyEventL( aKeyEvent, aEventCode );

   341             }

   342         }

   343     }

   344 

   345 // --------------------------------------------------------------

   346 // CPhoneConference::HandleKeyMessageL

   347 // --------------------------------------------------------------

   348 //

   349 void CPhoneConference::HandleKeyMessageL( 

   350     TPhoneKeyEventMessages aMessage,

   351     TKeyCode aCode )

   352     {

   353     __LOGMETHODSTARTEND( EPhoneUIStates, 

   354         "CPhoneConference::HandleKeyMessageL()");

   355         

   356     switch ( aCode )

   357         {

   358         // send-key

   359         case EKeyYes:

   360             if( IsNumberEntryVisibleL() )

   361                 {

   362                 CallFromNumberEntryL();    

   363                 }

   364             else

   365                 {

   366                 ToggleHoldL();    

   367                 }

   368             break;

   369             

   370         default:

   371             // do base operation

   372             CPhoneGsmInCall::HandleKeyMessageL( aMessage, aCode );

   373             break;

   374         }

   375     }

   376 

   377 // -----------------------------------------------------------

   378 // CPhoneConference::HandleNumberEntryClearedL

   379 // -----------------------------------------------------------

   380 //

   381 void CPhoneConference::HandleNumberEntryClearedL()

   382     {

   383     __LOGMETHODSTARTEND( EPhoneUIStates, 

   384         "CPhoneConference::HandleNumberEntryClearedL()");

   385     // Update CBA when number entry is cleared

   386     UpdateInCallCbaL();

   387     }

   388 

   389 // -----------------------------------------------------------

   390 // CPhoneConference:HandleIdleL

   391 // -----------------------------------------------------------

   392 //

   393 void CPhoneConference::HandleIdleL( TInt aCallId )

   394     {

   395     __LOGMETHODSTARTEND( EPhoneUIStates, 

   396         "CPhoneConference::HandleIdleL()");

   397     // Re-enable global notes

   398     TPhoneCmdParamBoolean globalNotifierParam;

   399     globalNotifierParam.SetBoolean( EFalse );

   400     iViewCommandHandle->ExecuteCommandL( EPhoneViewSetGlobalNotifiersDisabled,

   401         &globalNotifierParam );

   402 

   403     // Stop capturing keys

   404     CaptureKeysDuringCallNotificationL( EFalse );

   405 

   406     // If dialler is not open then close menu bar.

   407     if ( !IsNumberEntryUsedL() )

   408         {

   409         iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

   410         }

   411         

   412     // If conference bubble still exists then we have conference and

   413     // single call

   414     TPhoneCmdParamBoolean conferenceBubbleExists;

   415     iViewCommandHandle->ExecuteCommandL( EPhoneViewGetIsConference, 

   416         &conferenceBubbleExists ); 

   417         

   418     if( conferenceBubbleExists.Boolean() )

   419         {

   420         // Go to Conference And Single state

   421         iViewCommandHandle->ExecuteCommandL(

   422             EPhoneViewRemoveFromConference, aCallId ); 

   423         }

   424     else

   425         {

   426         // Remove call header

   427         iViewCommandHandle->ExecuteCommandL( 

   428             EPhoneViewRemoveCallHeader, aCallId );    

   429         }

   430     }

   431     

   432 // -----------------------------------------------------------

   433 // CPhoneConference:HandleConferenceIdleL

   434 // -----------------------------------------------------------

   435 //

   436 void CPhoneConference::HandleConferenceIdleL()

   437     {

   438     __LOGMETHODSTARTEND( EPhoneUIStates, 

   439         "CPhoneConference::HandleConferenceIdleL()");

   440     

   441     BeginTransEffectLC( ENumberEntryOpen );

   442     BeginUiUpdateLC();

   443     

   444     iViewCommandHandle->ExecuteCommandL( EPhoneViewRemoveConferenceBubble );

   445 

   446     TPhoneCmdParamInteger activeCallCount;

   447     iViewCommandHandle->ExecuteCommandL(

   448         EPhoneViewGetCountOfActiveCalls, &activeCallCount );

   449 

   450     switch( activeCallCount.Integer() )

   451         {

   452         case ENoActiveCalls:

   453             MakeStateTransitionToIdleL();

   454             break;

   455             

   456         case EOneActiveCall:

   457             {

   458             // Fetch ringing call's id from view

   459             TPhoneCmdParamCallStateData callStateData;

   460             callStateData.SetCallState( EPEStateRinging );

   461             iViewCommandHandle->HandleCommandL(

   462                 EPhoneViewGetCallIdByState, &callStateData );

   463                 

   464             if( callStateData.CallId() > KErrNotFound )

   465                 {

   466                 UpdateCbaL( EPhoneCallHandlingCallWaitingCBA );

   467                 iStateMachine->ChangeState( EPhoneStateWaitingInSingle );    

   468                 }

   469             else

   470                 {

   471                 MakeStateTransitionToSingleL();                    

   472                 }

   473             }

   474             break;

   475             

   476         case ETwoActiveCalls:

   477             MakeStateTransitionToTwoSinglesL();

   478             break;

   479             

   480         default:

   481             MakeStateTransitionToTwoSinglesL();

   482             break;

   483         }

   484     

   485     EndUiUpdate();

   486     EndTransEffect();     

   487     }

   488 

   489 // -----------------------------------------------------------

   490 // CPhoneConference::HandleHeldConferenceL

   491 // -----------------------------------------------------------

   492 //

   493 void CPhoneConference::HandleHeldConferenceL( TInt aCallId )

   494     {

   495     __LOGMETHODSTARTEND( EPhoneUIStates, 

   496         "CPhoneConference::HandleHeldConferenceL()");

   497     TPhoneCmdParamCallHeaderData callHeaderParam;

   498     callHeaderParam.SetCallState( EPEStateHeld );

   499     

   500     TInt callLabelId;

   501     TBuf<KPhoneCallHeaderLabelMaxLength> labelText( KNullDesC );

   502     callLabelId = CPhoneMainResourceResolver::Instance()->

   503             ResolveResourceID( EPhoneCallOnHold );

   504 

   505     StringLoader::Load( 

   506         labelText, 

   507         callLabelId, 

   508         CCoeEnv::Static() );        

   509     callHeaderParam.SetLabelText( labelText );

   510  

   511     iViewCommandHandle->ExecuteCommandL( 

   512         EPhoneViewUpdateBubble, aCallId, &callHeaderParam );

   513        

   514     // Set Hold flag to view

   515     SetHoldFlagL();

   516     

   517     if ( !FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )

   518         {

   519         SendGlobalInfoNoteL( EPhoneInformationConferenceOnHold );

   520         }

   521     

   522     SetTouchPaneButtonDisabled( EPhoneInCallCmdPrivate );

   523     

   524     UpdateInCallCbaL();

   525     }

   526 

   527 

   528 // -----------------------------------------------------------

   529 // CPhoneConference::DefineAndSetHoldFlagL

   530 // -----------------------------------------------------------

   531 //

   532 void CPhoneConference::DefineAndSetHoldFlagL()

   533     {

   534     // Find out is conference held or not

   535     TPhoneCmdParamCallStateData callStateData;

   536     callStateData.SetCallId( KConferenceCallId );

   537     iViewCommandHandle->HandleCommandL( EPhoneViewGetCallState,

   538             &callStateData );

   539     

   540     // Set Hold flag to view

   541     TPhoneCmdParamBoolean holdFlag;

   542         

   543     if( callStateData.CallState() == EPEStateHeld )

   544         {

   545         holdFlag.SetBoolean( ETrue );

   546         }

   547     else

   548         {

   549         holdFlag.SetBoolean( EFalse );   

   550         }

   551     iViewCommandHandle->ExecuteCommandL( EPhoneViewSetHoldFlag, &holdFlag );

   552     

   553     }

   554 

   555 // -----------------------------------------------------------

   556 // CPhoneConference::SetHoldFlagL

   557 // -----------------------------------------------------------

   558 //

   559 void CPhoneConference::SetHoldFlagL()

   560     {

   561     // Set Hold flag to view

   562     TPhoneCmdParamBoolean holdFlag;

   563     holdFlag.SetBoolean( ETrue );

   564     iViewCommandHandle->ExecuteCommandL( EPhoneViewSetHoldFlag, &holdFlag );

   565 

   566     }

   567 

   568 // -----------------------------------------------------------

   569 // CPhoneConference::HandleConnectedConferenceL

   570 // -----------------------------------------------------------

   571 //

   572 void CPhoneConference::HandleConnectedConferenceL()

   573     {

   574     __LOGMETHODSTARTEND( EPhoneUIStates, 

   575         "CPhoneConference::HandleConnectedConferenceL()");

   576     // Update call state

   577     TPhoneCmdParamCallHeaderData callHeaderParam;

   578     callHeaderParam.SetCallState( EPEStateConnected );

   579 

   580     TBuf<KPhoneCallHeaderLabelMaxLength> conferenceText( KNullDesC );

   581     TInt callLabelId = CPhoneMainResourceResolver::Instance()->

   582             ResolveResourceID( EPhoneCLIConferenceCall );

   583 

   584     StringLoader::Load( 

   585         conferenceText, 

   586         callLabelId, 

   587         CCoeEnv::Static() );        

   588     callHeaderParam.SetLabelText( conferenceText );

   589  

   590     iViewCommandHandle->ExecuteCommandL( 

   591         EPhoneViewUpdateBubble, KConferenceCallId, &callHeaderParam );

   592 

   593     // Set Hold flag to view

   594     TPhoneCmdParamBoolean holdFlag;

   595     holdFlag.SetBoolean( EFalse );

   596     iViewCommandHandle->ExecuteCommandL( EPhoneViewSetHoldFlag, &holdFlag );

   597     

   598     if ( !FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )

   599         { 

   600         SendGlobalInfoNoteL( EPhoneInformationConferenceActiveted );

   601         }

   602     

   603     SetTouchPaneButtonEnabled( EPhoneInCallCmdPrivate );

   604     

   605     UpdateInCallCbaL();

   606     }

   607 

   608 // -----------------------------------------------------------

   609 // CPhoneConference::OpenDropParticipantSelectionL

   610 // -----------------------------------------------------------

   611 //

   612 void CPhoneConference::OpenDropParticipantSelectionL()

   613     {

   614     __LOGMETHODSTARTEND( EPhoneUIStates, 

   615         "CPhoneConference::OpenDropParticipantSelectionL()");

   616     TPhoneCmdParamBoolean booleanParam;

   617     booleanParam.SetBoolean( ETrue );

   618     iViewCommandHandle->ExecuteCommandL( 

   619         EPhoneViewOpenConferenceList, &booleanParam );

   620 

   621     iCbaManager->SetCbaL( EPhoneDropParticipantCBA );

   622     }

   623 

   624 // -----------------------------------------------------------

   625 // CPhoneConference::DropSelectedParticipantL

   626 // -----------------------------------------------------------

   627 //

   628 void CPhoneConference::DropSelectedParticipantL()

   629     {

   630     __LOGMETHODSTARTEND( EPhoneUIStates, 

   631         "CPhoneConference::DropSelectedParticipantL()");

   632     // First fetch the call id matching the selected item 

   633     TPhoneViewResponseId response;

   634     TPhoneCmdParamInteger callId;

   635     response = iViewCommandHandle->HandleCommandL(

   636         EPhoneViewSelectedConfMember, &callId );    

   637         

   638     if( response == EPhoneViewResponseSuccess )

   639         {

   640         // Drop the call from conference

   641         iStateMachine->SetCallId( callId.Integer() );    

   642         iStateMachine->SendPhoneEngineMessage( 

   643             CPEPhoneModelIF::EPEMessageDropConferenceMember );            

   644         }

   645     }

   646 

   647 // -----------------------------------------------------------

   648 // CPhoneConference::OpenPrivateSelectionL

   649 // -----------------------------------------------------------

   650 //

   651 void CPhoneConference::OpenPrivateSelectionL()

   652     {

   653     __LOGMETHODSTARTEND( EPhoneUIStates, 

   654         "CPhoneConference::OpenPrivateSelectionL()");

   655     TPhoneCmdParamBoolean booleanParam;

   656     booleanParam.SetBoolean( ETrue );

   657     iViewCommandHandle->ExecuteCommandL( 

   658         EPhoneViewOpenConferenceList, &booleanParam );

   659 

   660     iCbaManager->SetCbaL( EPhonePrivateParticipantCBA );

   661     }

   662 

   663 // -----------------------------------------------------------

   664 // CPhoneConference::PrivateSelectedParticipantL

   665 // -----------------------------------------------------------

   666 //

   667 void CPhoneConference::PrivateSelectedParticipantL()

   668     {

   669     __LOGMETHODSTARTEND( EPhoneUIStates, 

   670         "CPhoneConference::PrivateSelectedParticipantL()");

   671     // First fetch the call id matching the selected item 

   672     TPhoneViewResponseId response;

   673     TPhoneCmdParamInteger callId;

   674     response = iViewCommandHandle->HandleCommandL(

   675         EPhoneViewSelectedConfMember, &callId );

   676     

   677     if( response == EPhoneViewResponseSuccess )

   678         {

   679         // Drop the call from conference

   680         iStateMachine->SetCallId( callId.Integer() );    

   681         iStateMachine->SendPhoneEngineMessage( 

   682             CPEPhoneModelIF::EPEMessageGoOneToOne );

   683         

   684         // Update call view

   685         BeginUiUpdateLC();

   686         CloseSelectionListL();

   687         SetTouchPaneButtons( EPhoneConferenceButtons );

   688         EndUiUpdate();    

   689                 

   690         UpdateCbaL( EPhoneCallHandlingInCallCBA );               

   691         }

   692     }

   693 

   694 // -----------------------------------------------------------

   695 // CPhoneConference::MakeStateTransitionToIdleL

   696 // -----------------------------------------------------------

   697 //

   698 void CPhoneConference::MakeStateTransitionToIdleL()

   699     {

   700     __LOGMETHODSTARTEND( EPhoneUIStates, 

   701         "CPhoneConference::MakeStateTransitionToIdleL()");

   702     

   703     SetDefaultFlagsL();

   704 

   705     if ( IsNumberEntryUsedL() )

   706         {

   707         // Show the number entry if it exists

   708         SetNumberEntryVisibilityL(ETrue);

   709         

   710         // Close dtmf dialer when call is disconnected.

   711         if ( iOnScreenDialer && IsDTMFEditorVisibleL() )

   712             {            

   713             CloseDTMFEditorL();

   714             // Display idle screen and update CBAs

   715             DisplayIdleScreenL();

   716             }        

   717         }

   718     else if ( !TopAppIsDisplayedL() )

   719         {

   720         // Close menu bar, if it is displayed

   721         iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

   722         

   723         // Continue displaying current app but set up the 

   724         // idle screen in the background

   725         SetupIdleScreenInBackgroundL();

   726         }

   727     else

   728         {

   729         // Close menu bar, if it is displayed

   730         iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

   731         

   732          // Display idle screen

   733         DisplayIdleScreenL();

   734         }

   735 

   736     // Display call termination note, if necessary

   737     DisplayCallTerminationNoteL();

   738 

   739     UpdateCbaL( EPhoneEmptyCBA );

   740     // Go to idle state

   741     iStateMachine->ChangeState( EPhoneStateIdle );

   742     }

   743 

   744 // -----------------------------------------------------------

   745 // CPhoneConference::MakeStateTransitionToSingleL

   746 // -----------------------------------------------------------

   747 //

   748 void CPhoneConference::MakeStateTransitionToSingleL()

   749     {

   750     __LOGMETHODSTARTEND( EPhoneUIStates, 

   751         "CPhoneConference::MakeStateTransitionToSingleL()");

   752     // Close menu bar, if it is displayed

   753     iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

   754  

   755     if ( IsNumberEntryUsedL() )

   756         {

   757         // Show the number entry if it exists

   758         SetNumberEntryVisibilityL(ETrue);

   759         }

   760     SetTouchPaneButtons( EPhoneIncallButtons );    

   761   

   762     // Go to single state

   763     UpdateCbaL( EPhoneCallHandlingInCallCBA );

   764     iStateMachine->ChangeState( EPhoneStateSingle );        

   765     }

   766 

   767 // -----------------------------------------------------------

   768 // CPhoneConference::MakeTransitionToTwoSinglesL

   769 // -----------------------------------------------------------

   770 //

   771 void CPhoneConference::MakeStateTransitionToTwoSinglesL()

   772     {

   773     __LOGMETHODSTARTEND( EPhoneUIStates, 

   774         "CPhoneConference::MakeStateTransitionToTwoSinglesL()");

   775     // Close menu bar, if it is displayed

   776     iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

   777 

   778     if ( IsNumberEntryUsedL() )

   779         {

   780         // Show the number entry if it exists

   781         SetNumberEntryVisibilityL(ETrue);

   782         }

   783         

   784     SetTouchPaneButtons( EPhoneTwoSinglesButtons );        

   785     

   786     // Set Two singles softkeys

   787     UpdateCbaL( EPhoneCallHandlingNewCallSwapCBA );

   788 

   789     // Go to two singles state

   790     iStateMachine->ChangeState( EPhoneStateTwoSingles );        

   791     }

   792 

   793 // -----------------------------------------------------------

   794 // CPhoneConference::CloseSelectionListL

   795 // -----------------------------------------------------------

   796 //

   797 void CPhoneConference::CloseSelectionListL()

   798     {

   799     __LOGMETHODSTARTEND( EPhoneUIStates, 

   800         "CPhoneConference::CloseSelectionListL()");

   801     // Close conference list

   802     TPhoneCmdParamBoolean booleanParam;

   803     booleanParam.SetBoolean( EFalse );

   804     iViewCommandHandle->ExecuteCommandL( 

   805         EPhoneViewOpenConferenceList, &booleanParam );

   806     }

   807 

   808 // -----------------------------------------------------------

   809 // CPhoneConference::ToggleHold

   810 // -----------------------------------------------------------

   811 //

   812 void CPhoneConference::ToggleHoldL()

   813     {

   814     __LOGMETHODSTARTEND( EPhoneUIStates, 

   815         "CPhoneConference::ToggleHoldL()");

   816     TPhoneCmdParamBoolean hold;

   817     iViewCommandHandle->ExecuteCommandL( EPhoneViewGetHoldFlag, &hold );

   818     

   819     if( hold.Boolean() )

   820         {

   821         iStateMachine->SendPhoneEngineMessage( 

   822             CPEPhoneModelIF::EPEMessageResumeConference );

   823         }

   824     else

   825         {

   826         iStateMachine->SendPhoneEngineMessage( 

   827             CPEPhoneModelIF::EPEMessageHoldConference );

   828         }

   829     }

   830 

   831 // -----------------------------------------------------------

   832 // CPhoneConference::HandleDiallingL

   833 // -----------------------------------------------------------

   834 //

   835 void CPhoneConference::HandleDiallingL( TInt aCallId )

   836     {

   837     __LOGMETHODSTARTEND( EPhoneUIStates, 

   838         "CPhoneConference::HandleDiallingL()");

   839     

   840     BeginTransEffectLC( ENumberEntryClose );

   841     BeginUiUpdateLC(); 

   842     

   843     CloseSelectionListL(); 

   844     

   845     SetNumberEntryVisibilityL(EFalse);

   846     

   847     // Display call setup 

   848     DisplayCallSetupL( aCallId );

   849     

   850     // Conference is understood as single call in buttons enumerations.

   851     SetTouchPaneButtons(EPhoneCallSetupAndSingleButtons); 

   852 

   853     EndUiUpdate();

   854 

   855     EndTransEffect();

   856     

   857     // Set Call Setup CBA 

   858     UpdateCbaL( EPhoneCallHandlingCallSetupCBA );

   859       

   860     // Go to conference and call setup state

   861     iStateMachine->ChangeState( EPhoneStateConferenceAndCallSetup );

   862     }

   863 

   864 // -----------------------------------------------------------

   865 // CPhoneConference::DisplayCallSetupL

   866 // -----------------------------------------------------------

   867 //

   868 void CPhoneConference::DisplayCallSetupL( TInt aCallId )

   869     {

   870     __LOGMETHODSTARTEND( EPhoneUIStates, 

   871         "CPhoneConference::DisplayCallSetupL()");

   872     // Close menu bar, if it is displayed

   873     iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

   874 

   875     // Remove dialogs if necessary

   876     iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );

   877 

   878     // Capture keys when the phone is dialling

   879     CaptureKeysDuringCallNotificationL( ETrue );

   880 

   881     // Bring Phone app in the foreground

   882     TPhoneCmdParamInteger uidParam;

   883     uidParam.SetInteger( KUidPhoneApplication.iUid );

   884     iViewCommandHandle->ExecuteCommandL( EPhoneViewBringAppToForeground,

   885         &uidParam );

   886 

   887     // Display call setup header

   888     DisplayHeaderForOutgoingCallL( aCallId );

   889     }

   890 

   891 // ---------------------------------------------------------

   892 // CPhoneConference::CallFromNewCallQueryL

   893 // ---------------------------------------------------------

   894 //

   895 void CPhoneConference::CallFromNewCallQueryL()

   896     {

   897     __LOGMETHODSTARTEND( EPhoneUIStates, 

   898         "CPhoneConference::CallFromNewCallQueryL()");

   899     // First get the phone number from the dialog

   900     TPhoneCmdParamString phoneNumberParam;

   901     HBufC *content = HBufC::NewLC( KPhoneNumberEntryBufferSize );

   902     TPtr ptr( content->Des() );

   903     phoneNumberParam.SetString( &ptr );

   904     iViewCommandHandle->ExecuteCommandL( EPhoneViewGetTextQueryContent,

   905         &phoneNumberParam );

   906 

   907     // Store the phone number

   908     iStateMachine->PhoneEngineInfo()->SetPhoneNumber( ptr );

   909 

   910     // clean up stack

   911     CleanupStack::PopAndDestroy( content );

   912   

   913     // Dial number

   914     DialVoiceCallL();

   915     }

   916 

   917 // -----------------------------------------------------------

   918 // CPhoneConference::HandleIncomingL

   919 // -----------------------------------------------------------

   920 //

   921 void CPhoneConference::HandleIncomingL( TInt aCallId )

   922     {

   923     __LOGMETHODSTARTEND( EPhoneUIStates, 

   924         "CPhoneConference::HandleIncomingL()");

   925     

   926     BeginUiUpdateLC();

   927  

   928     TPhoneCmdParamBoolean dialerParam;

   929     dialerParam.SetBoolean( ETrue );

   930     

   931     // Get allow waiting call header param value.

   932     AllowShowingOfWaitingCallHeaderL( dialerParam );

   933             

   934     CloseSelectionListL();

   935 

   936     // Close fast swap window if it's displayed

   937     CEikonEnv::Static()->DismissTaskList();

   938 

   939     // Check if HW Keys or Call UI should be disabled

   940     CheckDisableHWKeysAndCallUIL();

   941     

   942     SetTouchPaneButtons( EPhoneWaitingCallButtons );

   943     

   944     // Display incoming call

   945     DisplayIncomingCallL( aCallId, dialerParam );

   946 

   947     EndUiUpdate();

   948 

   949     // Go to incoming state

   950     UpdateCbaL( EPhoneCallHandlingCallWaitingCBA );

   951     iStateMachine->ChangeState( EPhoneStateConferenceAndWaiting );        

   952     }

   953 

   954 // -----------------------------------------------------------

   955 // CPhoneConference::DisplayIncomingCallL

   956 // -----------------------------------------------------------

   957 //

   958 void CPhoneConference::DisplayIncomingCallL( 

   959     TInt aCallId, 

   960     const TPhoneCmdParamBoolean aCommandParam )

   961     {

   962     __LOGMETHODSTARTEND( EPhoneUIStates, 

   963         "CPhoneConference::DisplayIncomingCallL()");

   964     // Close menu bar, if it is displayed

   965     iViewCommandHandle->ExecuteCommandL( EPhoneViewMenuBarClose );

   966 

   967     // Cannot delete active note, e.g. New call query, 

   968     // but show waiting note with or without caller name

   969     if ( IsAnyQueryActiveL() ||  

   970         ( !aCommandParam.Boolean() && iOnScreenDialer ) )

   971         {

   972         CallWaitingNoteL( aCallId );        

   973         }

   974     else

   975         {

   976         // Remove any phone dialogs if they are displayed

   977         iViewCommandHandle->ExecuteCommandL( EPhoneViewRemovePhoneDialogs );

   978         }

   979 

   980     // Indicate that the Phone needs to be sent to the background if

   981     // an application other than the top application is in the foreground

   982     TPhoneCmdParamBoolean booleanParam;

   983     booleanParam.SetBoolean( !TopAppIsDisplayedL() );

   984     iViewCommandHandle->ExecuteCommandL( 

   985         EPhoneViewSetNeedToSendToBackgroundStatus,

   986         &booleanParam );

   987 

   988     // Bring Phone app in the foreground

   989     TPhoneCmdParamInteger uidParam;

   990     uidParam.SetInteger( KUidPhoneApplication.iUid );

   991     iViewCommandHandle->ExecuteCommandL( EPhoneViewBringAppToForeground,

   992         &uidParam );

   993 

   994     // Set Phone as the top application

   995     iViewCommandHandle->ExecuteCommandL( EPhoneViewSetTopApplication,

   996         &uidParam );

   997 

   998     DisplayHeaderForCallComingInL( aCallId, ETrue ); // waiting call 

   999     }    

  1000 

  1001 // -----------------------------------------------------------

  1002 // CPhoneConference::HandleWentOneToOneL

  1003 // -----------------------------------------------------------

  1004 //

  1005 void CPhoneConference::HandleWentOneToOneL( TInt aCallId )

  1006     {

  1007     __LOGMETHODSTARTEND( EPhoneUIStates, 

  1008         "CPhoneConference::HandleWentOneToOneL()");

  1009 

  1010     BeginUiUpdateLC();

  1011     

  1012     // Update conference bubble

  1013     iViewCommandHandle->ExecuteCommandL(

  1014         EPhoneViewPrivateFromConference, aCallId );

  1015         

  1016     // If conference bubble still exists then we have conference and

  1017     // single call

  1018     TPhoneCmdParamBoolean conferenceBubbleExists;

  1019     iViewCommandHandle->ExecuteCommandL( EPhoneViewGetIsConference, 

  1020         &conferenceBubbleExists );                            

  1021     if( conferenceBubbleExists.Boolean() )

  1022         {

  1023         // Go to Conference And Single state

  1024       

  1025         UpdateCbaL( EPhoneCallHandlingNewCallSwapCBA );

  1026         iStateMachine->ChangeState( EPhoneStateConferenceAndSingle );                    

  1027         SetTouchPaneButtons( EPhoneConferenceAndSingleButtons );

  1028         SetTouchPaneButtonDisabled( EPhoneInCallCmdPrivate );

  1029         }

  1030     else

  1031         {            

  1032         SetTouchPaneButtons( EPhoneTwoSinglesButtons );

  1033         }       

  1034     EndUiUpdate();

  1035     }

  1036 

  1037 // -----------------------------------------------------------

  1038 // CPhoneConference::OpenParticipantsListL

  1039 // -----------------------------------------------------------

  1040 //    

  1041 void CPhoneConference::OpenParticipantsListL()

  1042     {

  1043     BeginUiUpdateLC();

  1044     

  1045     TPhoneCmdParamBoolean booleanParam;

  1046     booleanParam.SetBoolean( ETrue );

  1047     

  1048     iViewCommandHandle->ExecuteCommandL( EPhoneViewOpenConferenceList,

  1049                                          &booleanParam );    

  1050 

  1051     SetTouchPaneButtons( EPhoneParticipantListButtons );

  1052                                          

  1053     EndUiUpdate();

  1054     

  1055     iCbaManager->SetCbaL( EPhoneParticipantListCBA );

  1056      

  1057     // Find out is conference held or not

  1058     TPhoneCmdParamCallStateData callStateData;

  1059     callStateData.SetCallId( KConferenceCallId );

  1060     iViewCommandHandle->HandleCommandL( EPhoneViewGetCallState,

  1061         &callStateData );

  1062     

  1063     if( callStateData.CallState() == EPEStateHeld )

  1064         {

  1065         //set Private button to Dimmed.        

  1066         SetTouchPaneButtonDisabled( EPhoneInCallCmdPrivate );

  1067         } 

  1068     else

  1069         {

  1070         //set Private button to UnDimmed.        

  1071          SetTouchPaneButtonEnabled( EPhoneInCallCmdPrivate );        

  1072         }   

  1073                                            

  1074     }

  1075 

  1076 // -----------------------------------------------------------

  1077 // CPhoneConference::IsConferenceBubbleInSelectionMode

  1078 // -----------------------------------------------------------

  1079 //

  1080 TBool CPhoneConference::IsConferenceBubbleInSelectionMode() const

  1081     {

  1082     TPhoneCmdParamBoolean booleanParam;

  1083     

  1084     iViewCommandHandle->ExecuteCommand( 

  1085         EPhoneViewGetIsConferenceInSelectionMode, &booleanParam );

  1086     

  1087     return booleanParam.Boolean();

  1088     }

  1089 

  1090 // ---------------------------------------------------------

  1091 // CPhoneState::HandleCreateNumberEntryL

  1092 // ---------------------------------------------------------

  1093 //

  1094 void CPhoneConference::HandleCreateNumberEntryL( const TKeyEvent& aKeyEvent,

  1095         TEventCode aEventCode )

  1096     {

  1097     __LOGMETHODSTARTEND( EPhoneControl, "CPhoneConference::HandleCreateNumberEntryL() ");

  1098     if ( !IsConferenceBubbleInSelectionMode() )

  1099         {

  1100         CPhoneGsmInCall::HandleCreateNumberEntryL( aKeyEvent,aEventCode );

  1101         }

  1102     }

  1103     

  1104 // -----------------------------------------------------------

  1105 // CPhoneConference::UpdateConferenceSecurityStatusL

  1106 // -----------------------------------------------------------

  1107 //

  1108 void CPhoneConference::UpdateConferenceSecurityStatusL( TInt aCallId )

  1109     {

  1110     __PHONELOG1( EBasic, EPhoneUIStates, 

  1111         "CPhoneConference::UpdateConferenceSecurityStatusL() - callId = %d", aCallId );

  1112 

  1113     if( !iStateMachine->PhoneEngineInfo()->IsSecureCall( aCallId ) &&

  1114         iStateMachine->PhoneEngineInfo()->IsSecureCall( KPEConferenceCallID ) )

  1115         {

  1116         TPhoneCmdParamCallHeaderData callHeaderParam;

  1117         

  1118         callHeaderParam.SetCiphering( EFalse );

  1119         callHeaderParam.SetCipheringIndicatorAllowed(

  1120             iStateMachine->PhoneEngineInfo()->SecureSpecified() );

  1121         

  1122         iViewCommandHandle->ExecuteCommandL( 

  1123             EPhoneViewCipheringInfoChange,

  1124             KPEConferenceCallID,

  1125             &callHeaderParam );

  1126         }

  1127     }

  1128 

  1129 // End of File