--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/phoneapp/phoneuiview/src/cphoneviewcontroller.cpp Wed Sep 01 12:30:10 2010 +0100
@@ -0,0 +1,4310 @@
+/*
+* Copyright (c) 2005 - 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: The control class of phone ui view in PhoneUI
+*
+*/
+
+
+// INCLUDE FILES
+#include "cphoneviewcontroller.h"
+
+#include "phoneui.pan"
+#include "cphonetoolbarcontroller.h"
+#include "cphonebuttonscontroller.h"
+#include "cphonedialercontroller.h"
+#include "cphoneeasydialingcontroller.h"
+#include "cphonedtmfdialercontroller.h"
+#include "cphonemenucontroller.h"
+#include "cphonenotecontroller.h"
+#include "cphonequerycontroller.h"
+#include "cphonekeycapturecontroller.h"
+#include "cphoneview.h"
+#include "cphonedialerview.h"
+#include "tphonecommandparam.h"
+#include "cphonebubblewrapper.h"
+#include "tphonecmdparamcallstatedata.h"
+#include "tphonecmdparamKeycapture.h"
+#include "tphonecmdparaminteger.h"
+#include "tphonecmdparamboolean.h"
+#include "tphonecmdparamstring.h"
+#include "tphonecmdparamappinfo.h"
+#include "tphonecmdparammessageeditor.h"
+#include "tphonecmdparamcallheaderdata.h"
+#include "tphonecmdparamsingleitemfetch.h"
+#include "tphonecmdparamaudiooutput.h"
+#include "tphonecmdparamaudioavailability.h"
+#include "tphonecmdparamquery.h"
+#include "tphonecmdparamsfidata.h"
+#include "tphonecmdparamtranseffect.h"
+#include "phoneconstants.h"
+#include "cphonestatuspane.h"
+#include "cphonepubsubproxy.h"
+#include "cphoneincallindicator.h"
+#include "phonelogger.h"
+#include "cphonetimer.h"
+#include "cphonecenrepproxy.h"
+#include "cphonerecoverysystem.h"
+#include "cphonecontactcontroller.h"
+#include "cphoneapplicationexit.h"
+#include "cphoneaudiocontroller.h"
+#include "cphoneringingtoneplayerao.h"
+#include "cphonevmbxhandler.h"
+#include "cphonemainresourceresolver.h"
+#include "phonerssbase.h"
+#include "telprivatecrkeys.h"
+#include "cphonesingleitemfetch.h"
+#include "mnumberentry.h"
+#include "cdialer.h"
+#include "dialer.hrh"
+#include "cphonemediatorfactory.h"
+#include "cphonemediatorsender.h"
+#include "mphoneviewcustomization.h"
+#include "tphonecmdparamcustomdialer.h"
+#include "tphonecmdparampointer.h"
+#include "dialer.hrh"
+#include "phoneui.hrh"
+#include "musmanager.h"
+#include <apgtask.h>
+#include <apgwgnam.h>
+#include <apacmdln.h>
+#include <coedef.h> // TKeyResponse
+#include <eikenv.h>
+#include <eikappui.h>
+#include <eikapp.h>
+#include <eikmenub.h>
+#include <eikspane.h>
+#include <aknkeylock.h>
+#include <SpdiaControl.h>
+#include <hlplch.h>
+#include <aknnavide.h>
+#include <aknnavilabel.h>
+#include <AknNotifierController.h>
+#include <CMessageData.h> // CMessageData
+#include <sendui.h> // CSendUi
+#include <SenduiMtmUids.h> // KSenduiMtmIrUid
+#include <cphonecntsaveaddtoname.h>
+#include <PbkDataSaveAppUi.hrh>
+#include <PhCltUtils.h>
+#include <telephonyvariant.hrh>
+#include <ConeResLoader.h>
+#include <bldvariant.hrh>
+#include <data_caging_path_literals.hrh>
+#include <AknDlgShut.h> // Avkon dialog shutter.
+#include <cphcntrfshandler.h>
+#include <bautils.h>
+#include <CPbkContactEngine.h>
+#include <CPbkContactItem.h>
+#include <CPbkFieldInfo.h>
+#include <PbkFields.hrh>
+#include <cphcntcontactid.h>
+#include <AknUtils.h>
+#include <AknSgcc.h>
+#include <settingsinternalcrkeys.h>
+#include <UikonInternalPSKeys.h>
+#include <startupdomainpskeys.h>
+#include <utf.h>
+#include <activeidle2domainpskeys.h>
+#include <telinternalpskeys.h>
+#include <featmgr.h>
+#include <layoutmetadata.cdl.h>
+#include <akntoolbar.h>
+#include <LogsUiCmdStarter.h>
+#include <AknIndicatorContainer.h>
+
+#include <SoftReject.rsg>
+#include <ConeResLoader.h>
+#include <StringLoader.h>
+#include <txtrich.h>
+
+#include <vmnumber.h>
+#include <coreapplicationuisdomainpskeys.h>
+#include <gfxtranseffect/gfxtranseffect.h>
+#include <akntranseffect.h>
+
+#include <gslauncher.h> // Call Settings launch.
+
+#include <dialingextensioninterface.h>
+#include <easydialingcommands.hrh>
+#include <AknIncallBubbleNotify.h>
+
+// Kastor effect IDs, aknskincontent/101f84b9.sel
+// These effects cannot be used for internal transitions (Call UI<->Dialer)
+const TInt KTouchDialerOpenEffect = 3;
+const TInt KTouchDialerCloseEffect = 5;
+
+const TInt KTouchCallUiOpenEffect = 1000;
+const TInt KTouchCallUiCloseEffect = 1001;
+
+const TInt KDialerInputMaxChars( 100 );
+
+// ================= MEMBER FUNCTIONS =======================
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::CPhoneViewController
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// ---------------------------------------------------------------------------
+//
+CPhoneViewController::CPhoneViewController() :
+ iEikEnv( *CEikonEnv::Static() ),
+ iHelpCommand( KINCAL_HLP_CALL_HANDLING ),
+ iBlockingDialogIsDisplayed( EFalse ),
+ iIdleUid( KErrNotFound ),
+ iFetchContent( KNullDesC ),
+ iEffectOngoing( EFalse ),
+ iSendBack( ETrue ),
+ iDialerActive( EFalse ),
+ iPriotityChanged( EFalse ),
+ iSecurityMode( ETrue ),
+ iNeedToReturnToForegroundAppAfterCall( EFalse )
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ConstructL
+// Symbian 2nd phase constructor can leave.
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::ConstructL( TRect aRect )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView, "CPhoneViewController::ConstructL()");
+ // Create the status pane singleton
+ iStatusPane = CPhoneStatusPane::Instance();
+ // Reserve the title pane
+ iStatusPane->AddTitlePaneHandlerL( *this );
+ iStatusPane->ReserveTitlePane( *this );
+ // Set status pane dimming
+ iStatusPane->StatusPane().SetDimmed( iSecurityMode );
+
+ iAppui = (CAknAppUi*)iEikEnv.EikAppUi();
+ iCba = iEikEnv.AppUiFactory()->Cba();
+
+ iPhoneView = CPhoneView::NewL( aRect, *iCba, this );
+
+ iBubbleWrapper = CPhoneBubbleWrapper::NewL( iPhoneView, aRect );
+
+ iPhoneView->SetControl( iBubbleWrapper->Control() );
+ iPhoneView->ActivateL(); // We're ready to activate view after the bubble is initialized
+
+ iIncallIndicator = CPhoneIncallIndicator::NewL();
+ iMenuController = CPhoneMenuController::NewL( iEikEnv );
+ iNoteController = CPhoneNoteController::NewL( iEikEnv );
+ iQueryController = CPhoneQueryController::NewL( iEikEnv );
+ iAudioController = CPhoneAudioController::NewL();
+
+ iRingingTonePlayerAO = CPhoneRingingTonePlayerAO::NewL();
+ // Set display provider for ringing tone player.
+ // Display access is needed for visual ringing tones.
+ iRingingTonePlayerAO->SetVideoPlayer( iBubbleWrapper );
+
+ // Contact
+ CPhoneContactController* contactManager =
+ CPhoneContactController::NewL();
+ iContactController = contactManager;
+
+ iContactControllerId =
+ CPhoneRecoverySystem::Instance()->AddL(
+ TCallBack( DoConstructContactControllerL, this ),
+ CTeleRecoverySystem::EPhonePriorityHigh,
+ CTeleRecoverySystem::EPhoneStateStarting );
+
+ iKeyCaptureController = CPhoneKeyCaptureController::NewL( iEikEnv );
+
+ iApplicationExit = CPhoneApplicationExit::NewL(
+ this,
+ iEikEnv.WsSession(),
+ iEikEnv.WsSession().FindWindowGroupIdentifier( 0, KPhoneEikonServer ) );
+
+ CCoeEnv* coeEnv = CCoeEnv::Static();
+
+ if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )
+ {
+ iButtonsController = CPhoneButtonsController::NewL( iBubbleWrapper->TouchPane() );
+ iToolbarController = CPhoneToolbarController::NewL( *coeEnv );
+ }
+
+ if ( FeatureManager::FeatureSupported( KFeatureIdOnScreenDialer ) )
+ {
+ iDialerActive = EFalse;
+ // Create dialer controller
+ iDialerController = CPhoneDialerController::NewL( iBubbleWrapper,
+ *coeEnv );
+ // Create dialer view
+ iDialerView = CPhoneDialerView::NewL( aRect );
+ iDialerView->DrawableWindow()->SetOrdinalPosition( -1 );
+ iDialerView->MakeVisible( EFalse );
+ // Create dialer
+ iDialer = CDialer::NewL( *iDialerView, aRect, iDialerController );
+ // Set NE for bubbleWrapper
+ iBubbleWrapper->SetNumberEntry( iDialer->NumberEntry() );
+ iBubbleWrapper->SetNumberEntryObserver( *this );
+ // Finalise dialer view
+ iDialerView->SetControl( iDialer );
+ iDialerView->ActivateL();
+
+ // Create controller for Easy Dialing
+ iEasyDialingController = CPhoneEasyDialingController::NewL( *iDialer );
+ iDialerController->SetEasyDialingController( iEasyDialingController );
+
+ // Create controller for DTMF mode of the dialer
+ iDtmfDialerController = CPhoneDtmfDialerController::NewL( iBubbleWrapper,
+ *coeEnv );
+ }
+
+ User::LeaveIfError( iKeyLock.Connect() );
+
+ // if you are using sgc-client's session to capserver,
+ //you are not allowed to close the session.
+ iAknUiServerClient = CAknSgcClient::AknSrv();
+
+ iIncallBubble = CAknIncallBubble::NewL();
+
+ User::LeaveIfError( iSkinServerSession.Connect( this ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CPhoneViewController::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CPhoneViewController* CPhoneViewController::NewL( TRect aRect )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::NewL()" );
+ CPhoneViewController* self = new (ELeave) CPhoneViewController;
+
+ CleanupStack::PushL( self );
+ self->ConstructL( aRect );
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+// Destructor
+CPhoneViewController::~CPhoneViewController()
+ {
+ __LOGMETHODSTARTEND( EPhoneUIView,
+ "CPhoneViewController::~CPhoneViewController()" );
+ iSkinServerSession.Close();
+
+ delete iButtonsController;
+ delete iDialerController;
+ delete iToolbarController;
+ iKeyLock.Close();
+ delete iApplicationExit;
+ delete iSpeedDialController;
+ if ( iVmbxHandler )
+ {
+ delete iVmbxHandler;
+ iVmbxHandler = NULL;
+ }
+ delete iKeyCaptureController;
+ CPhoneRecoverySystem::Remove( iContactControllerId );
+ delete iContactController;
+ delete iRingingTonePlayerAO;
+ delete iAudioController;
+ delete iQueryController;
+ delete iNoteController;
+ delete iMenuController;
+ delete iIncallIndicator;
+ delete iBubbleWrapper;
+ delete iPhoneView;
+ delete iIndiContainer;
+ if ( iDialerView )
+ {
+ if(iAppui) //for codescanner
+ {
+ iAppui->RemoveFromStack( iDialerView );
+ }
+ delete iDialerView;
+ }
+
+ delete iEasyDialingController;
+ delete iDtmfDialerController;
+
+ delete iDialer;
+ if ( iSingleItemFetch )
+ {
+ delete iSingleItemFetch;
+ iSingleItemFetch = NULL;
+ }
+ delete iRfsHandler;
+ RemoveAddToContactDialog();
+
+// delete iStatusPane; <-- CCoeStatic are destroyed outside application
+
+ iApaLsSession.Close();
+
+ delete iIncallBubble;
+ }
+
+// ---------------------------------------------------------
+// CPhoneViewController::PhoneView
+// ---------------------------------------------------------
+//
+EXPORT_C CPhoneView* CPhoneViewController::PhoneView()
+ {
+ return iPhoneView;
+ }
+
+// ---------------------------------------------------------
+// CPhoneViewController::ExecuteCommandL( aCmdId )
+// ---------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::ExecuteCommandL(
+ TPhoneViewCommandId aCmdId )
+ {
+ __PHONELOGVIEWMSG( aCmdId, 0 );
+
+ switch ( aCmdId )
+ {
+ case EPhoneViewLaunchApplication:
+ LaunchApplicationL();
+ break;
+
+ case EPhoneViewMenuBarClose:
+ iMenuController->CloseMenuBar();
+ break;
+
+ case EPhoneViewRemoveNumberEntry:
+ if ( iDialer && iDialerActive )
+ {
+ SetControltoCallHandlingL();
+ iBubbleWrapper->RemoveNumberEntry();
+ iPhoneView->SetActivatePreviousApp( EFalse );
+
+ TPhoneCmdParamCallStateData callStateData;
+ callStateData.SetCallState( EPEStateConnected );
+ iBubbleWrapper->GetCallIdByState( &callStateData );
+ TInt connected = callStateData.CallId();
+
+ // If video call
+ if( connected == KVideoTelephonyCallId1 ||
+ connected == KVideoTelephonyCallId2 )
+ {
+ TPhoneCmdParamInteger uidParam;
+ // Bring video telephone app in the foreground
+ uidParam.SetInteger( KVtUiAppUidValue.iUid );
+ BringAppToForeground( &uidParam );
+ }
+ }
+ else
+ {
+ iBubbleWrapper->RemoveNumberEntry();
+ }
+ break;
+
+ case EPhoneViewRemoveNote:
+ iNoteController->DestroyNote();
+ break;
+
+ case EPhoneViewRemoveDtmfNote:
+ iNoteController->DestroyDTMFNote();
+ break;
+
+ case EPhoneViewRemoveGlobalNote:
+ iNoteController->DestroyGlobalNoteL();
+ break;
+
+ case EPhoneViewRemoveQuery:
+ iQueryController->DestroyQuery();
+ iQueryController->DestroyGlobalQuery();
+ break;
+
+ case EPhoneViewRemoveGlobalWaitNote:
+ iQueryController->DestroyGlobalWaitNote();
+ break;
+ case EPhoneViewRemoveProgressNote:
+ iNoteController->DestroyProgressNote();
+ break;
+
+ case EPhoneViewSendToBackground:
+ SendToBackgroundL();
+ break;
+
+ case EPhoneViewExitApplications:
+ iApplicationExit->ExitApplication();
+ break;
+
+ case EPhoneViewHideNaviPaneAudioVolume:
+ iAudioController->DeactivateVolumeControl();
+ break;
+
+ case EPhoneViewShowNaviPaneAudioVolume:
+ iAudioController->ActivateVolumeControlL();
+ break;
+
+ case EPhoneViewRemovePhoneDialogs:
+ RemovePhoneDialogsL();
+ break;
+
+ case EPhoneViewRemoveAllCallHeaders:
+ iBubbleWrapper->RemoveAllCallHeadersL();
+ break;
+
+ case EPhoneViewMuteRingToneOnAnswer:
+ iRingingTonePlayerAO->MuteRingingToneOnAnswer();
+ break;
+
+ case EPhoneViewStopRingTone:
+ iRingingTonePlayerAO->StopPlaying();
+ break;
+
+ case EPhoneViewMuteRingTone:
+ iRingingTonePlayerAO->MuteRingingTone();
+ break;
+
+ case EPhoneViewAddToConference:
+ iBubbleWrapper->AddToConferenceL();
+ break;
+
+ case EPhoneViewCreateNumberEntry:
+ // Keep menu controller in synch with number entry mode
+ iMenuController->SetAlphaModeFlag( EFalse );
+ iBubbleWrapper->CreateNumberEntry();
+ if ( iDialer && !iDialerActive )
+ {
+ SetControltoDialerL();
+ }
+ break;
+
+ case EPhoneViewUpdateMaxConfMemberFlag:
+ iMenuController->SetMaxConfMembersFlag(
+ iBubbleWrapper->IsMaxMembersInConf() );
+ if ( iButtonsController )
+ {
+ TPhoneCmdParamBoolean joinParam;
+ joinParam.SetBoolean( iBubbleWrapper->IsMaxMembersInConf() );
+ iButtonsController->SetInCallJoinEnabled( &joinParam );
+ }
+ break;
+
+ case EPhoneViewLaunchRfsDeep:
+ LaunchRfsL( ETrue );
+ break;
+
+ case EPhoneViewLaunchRfsNormal:
+ LaunchRfsL( EFalse );
+ break;
+
+ case EPhoneViewUpdateView:
+ iPhoneView->DrawDeferred();
+ break;
+
+ case EPhoneViewUpdateContact:
+ OpenAddToContactL( EPbkCmdDataSaveAddToExisting );
+ break;
+
+ case EPhoneViewAddContact:
+ OpenAddToContactL( EPbkCmdDataSaveCreateNew );
+ break;
+
+ case EPhoneViewSendMessage:
+ SendMessageL();
+ break;
+
+ case EPhoneViewEnableKeyLock:
+ iKeyLock.EnableKeyLock();
+ break;
+
+ case EPhoneViewDisableKeyLockWithoutNote:
+ iKeyLock.DisableWithoutNote();
+ break;
+
+ case EPhoneViewUpdateFSW:
+ SetHiddenL( !iBubbleWrapper->IsNumberEntryUsed() );
+ UpdateFSW();
+ break;
+
+ case EPhoneViewUpdatePhoneIconToFSW:
+ SetHiddenL( EFalse );
+ UpdateFSW();
+ break;
+
+ case EPhoneViewCloseFSW:
+ iEikEnv.DismissTaskList();
+ break;
+
+ case EPhoneViewBringIdleToForeground:
+ {
+ // bringe idle application to fore.
+ TPhoneCmdParamInteger uidParam;
+ uidParam.SetInteger( IdleAppUid() );
+ BringAppToForeground( &uidParam );
+ if ( iSingleItemFetch )
+ {
+ // Cancel the Single Item Fetch
+ iSingleItemFetch->Delete();
+ }
+ }
+ break;
+
+ case EPhoneViewSetIdleTopApplication:
+ {
+ TPhoneCmdParamInteger uidParam;
+ uidParam.SetInteger( IdleAppUid() );
+ SetTopApplicationL( &uidParam );
+ }
+ break;
+
+ case EPhoneViewRemoveConferenceBubble:
+ {
+ iBubbleWrapper->RemoveConferenceL();
+ }
+ break;
+
+ case EPhoneViewClearNumberEntryContent:
+ {
+ iBubbleWrapper->SetNumberEntryContent( KNullDesC );
+ }
+ break;
+
+ case EPhoneViewUpdateToolbar:
+ {
+ if ( iDialer )
+ {
+ iDialer->UpdateToolbar();
+ }
+ }
+ break;
+
+ case EPhoneViewSetControlAndVisibility:
+ if ( iDialer )
+ {
+ SetDialerControlAndVisibilityL();
+ }
+ else
+ {
+ // If iDialer is false then set numberentry
+ // visible.
+ TPhoneCmdParamBoolean booleanParam;
+ booleanParam.SetBoolean( ETrue );
+ iBubbleWrapper->SetNumberEntryVisible( &booleanParam );
+ }
+ break;
+
+ case EPhoneViewActivatePreviousApp:
+ {
+ TApaTaskList appList( iEikEnv.WsSession() );
+ TApaTask bring = appList.FindApp( KUidPhoneApplication );
+ // If CheckSendBackRoundEventNeed returns false then the
+ // active/foreground application is phone&singleitemfetch and
+ // there is no need to make SendToBackRound event or update
+ // window group position.
+ if ( bring.Exists() )
+ {
+ CAknSgcClient::MoveApp( bring.WgId(),
+ ESgcMoveAppToBackground );
+ // Position needs to be updated to ensure that exit works
+ // from previous view.
+ SetWindowGroupPosition();
+ }
+ }
+ break;
+
+ case EPhoneViewKeypadAudioEnabled:
+ {
+ iBubbleWrapper->KeypadAudioEnabled();
+ }
+ break;
+
+ case EPhoneViewKeypadAudioDisabled:
+ {
+ iBubbleWrapper->KeypadAudioDisabled();
+ }
+ break;
+
+ case EPhoneViewCancelAllNotications:
+ {
+ CancelAllNotications();
+ }
+ break;
+ case EPhoneViewOpenVirtualKeyBoard:
+ {
+ iBubbleWrapper->OpenVkbL();
+ }
+ break;
+ case EPhoneViewCreatePhoneBookServices:
+ {
+ // Open and create phonebook services(phonebook stores etc).
+ iContactController->CreatePhoneBookServiceL();
+ break;
+ }
+ case EPhoneViewHideToolbar:
+ {
+ iToolbarController->HideToolbar();
+ }
+ break;
+
+ case EPhoneViewLaunchMultimediaSharing:
+ {
+ LaunchMultimediaSharingL();
+ }
+ break;
+
+ case EPhoneViewSetIncallBubbleTrue:
+ {
+ // Allow small call bubble, if call handling view is in background and allow for dialer also
+ SetIncallBubbleVisibility( ETrue );
+ }
+ break;
+
+ case EPhoneViewSetIncallBubbleFalse:
+ {
+ // Don't allow small call bubble, if call handling view is not in foreground
+ SetIncallBubbleVisibility( EFalse );
+ }
+ break;
+
+ default:
+ __PHONELOG( EBasic, EPhonePhoneapp,
+ "CPhoneViewController::ExecuteCommandL -> UnKnownMessage !");
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ExecuteCommandL( aCmdId, aCallId )
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::ExecuteCommandL(
+ TPhoneViewCommandId aCmdId,
+ TInt aCallId )
+ {
+ __PHONELOGVIEWMSG( aCmdId, aCallId );
+ __ASSERT_DEBUG( aCallId > KErrNotFound,
+ Panic( EPhoneViewParameterNotInitialized ) );
+
+ switch ( aCmdId )
+ {
+ case EPhoneViewRemoveCallHeader:
+ iBubbleWrapper->RemoveCallHeaderL( aCallId );
+ break;
+
+ case EPhoneViewRemoveFromConference:
+ iBubbleWrapper->RemoveFromConferenceL( aCallId );
+ break;
+
+ case EPhoneViewPrivateFromConference:
+ iBubbleWrapper->ConferenceMemberToPrivateL( aCallId );
+ break;
+
+ default:
+ __PHONELOG( EBasic, EPhonePhoneapp,
+ "CPhoneViewController::ExecuteCommandL -> UnKnownMessage !!! ");
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId, aCallId );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ExecuteCommandL( aCmdId, aCommandParam )
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::ExecuteCommandL(
+ TPhoneViewCommandId aCmdId,
+ TPhoneCommandParam* aCommandParam )
+ {
+ __PHONELOGVIEWMSG( aCmdId, 0 );
+
+ switch ( aCmdId )
+ {
+ case EPhoneViewSetSendKeyDialerActivationFlag:
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ iPhoneView->SetDialerActivation( booleanParam->Boolean() );
+ }
+ break;
+
+ case EPhoneViewAllowWaitingCallHeader:
+ AllowWaitingCallHeaderL( aCommandParam );
+ break;
+
+ case EPhoneViewCreateNumberEntry:
+ iBubbleWrapper->CreateNumberEntry();
+ if ( iDialer && !iDialerActive )
+ {
+ SetControltoDialerL();
+ }
+ // Pass the key event to number entry
+ iBubbleWrapper->HandleKeyEventL( aCommandParam );
+ break;
+
+ case EPhoneViewUpdateContextMenu:
+ {
+ iMenuController->SetContextMenu( aCommandParam );
+ }
+ break;
+
+ case EPhoneViewGetLocalizedNumberFromEntry:
+ iBubbleWrapper->GetLocalizedNumberEntryContent( aCommandParam );
+ break;
+
+ case EPhoneViewSetNumberEntryVisible:
+ if ( iDialer )
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+
+ if ( booleanParam->Boolean() )
+ {
+ SetControltoDialerL();
+ }
+ else
+ {
+ // Set activate previous to false since dialer was set to
+ // hidden status.
+ iPhoneView->SetActivatePreviousApp( EFalse );
+ SetControltoCallHandlingL();
+ }
+ }
+ else
+ {
+ iBubbleWrapper->SetNumberEntryVisible( aCommandParam );
+ }
+ break;
+
+ case EPhoneViewGetNumberEntryCount:
+ iBubbleWrapper->GetNumberEntryCount( aCommandParam );
+ break;
+
+ case EPhoneViewMenuBarOpen:
+ iMenuController->SetNEVisibleFlag(
+ iBubbleWrapper->IsNumberEntryVisible() );
+ iMenuController->OpenMenuBarL( aCommandParam );
+ break;
+
+ case EPhoneViewUpdateCba:
+ SetCbaL( aCommandParam );
+ break;
+
+ case EPhoneViewMenuPane:
+ // First offer initialization to easydialing, and if no
+ // initialization done, give it to the menu controller.
+ if ( !iEasyDialingController->InitializeEasyDialingMenuL( aCommandParam ) )
+ {
+ iMenuController->SetReplaceFlag( IsReplaceAllowed() );
+ iMenuController->DynInitMenuPaneL( aCommandParam );
+ }
+ break;
+
+ case EPhoneViewMenuBar:
+ iMenuController->DynInitMenuBar( aCommandParam );
+ break;
+
+ case EPhoneViewShowNote:
+ iNoteController->CreateNoteL( aCommandParam );
+ break;
+
+ case EPhoneViewShowGlobalNote:
+ iNoteController->CreateGlobalNoteL( aCommandParam );
+ break;
+
+ case EPhoneViewShowQuery:
+ iQueryController->CreateQueryL( aCommandParam );
+ break;
+
+ case EPhoneViewSetListQueryString:
+ iQueryController->SetListQueryStringL( aCommandParam );
+ break;
+
+ case EPhoneViewUpdateNoteSoftkeys:
+ iNoteController->UpdateNoteSoftkeysL( aCommandParam );
+ break;
+
+ case EPhoneViewShowProgressNote:
+ iNoteController->CreateProgressNoteL( aCommandParam );
+ break;
+
+ case EPhoneViewActivateAudioPathUIChanges:
+ UpdateAudioPathOptions( aCommandParam );
+ break;
+
+ case EPhoneViewActivateAudioAvailabilityUIChanges:
+ UpdateAudioAvailabilityOptions( aCommandParam );
+ break;
+
+ case EPhoneViewActivateMuteUIChanges:
+ iMenuController->SetMuteFlag( aCommandParam );
+ iBubbleWrapper->SetPhoneMuted( aCommandParam );
+ iIncallIndicator->HandleMuteChange( aCommandParam );
+ iToolbarController->SetMuteFlag( aCommandParam );
+ if ( iButtonsController )
+ {
+ iButtonsController->SetMuteFlag( aCommandParam );
+ }
+ break;
+
+ case EPhoneViewBringAppToForeground:
+ {
+ TPhoneCmdParamInteger* integerParam =
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam );
+ // If uid is phone app then call phone app specific foreground
+ // method.
+ if ( KUidPhoneApplication.iUid == integerParam->Integer() )
+ {
+ BringPhoneAppToForeground( aCommandParam );
+ }
+ else
+ {
+ BringAppToForeground( aCommandParam );
+ }
+ }
+ break;
+
+ case EPhoneViewSetNeedToReturnToForegroundAppStatus:
+ SetNeedToReturnToForegroundAppAfterCall( aCommandParam );
+ break;
+
+ case EPhoneViewSetBlockingDialogStatus:
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ SetBlockingDialogIsDisplayed( booleanParam->Boolean() );
+ }
+ break;
+
+ case EPhoneViewGetBlockingDialogStatus:
+ GetBlockingDialogIsDisplayed( aCommandParam );
+ break;
+
+ case EPhoneViewGetForegroundApplication:
+ GetForegroundApplication( aCommandParam );
+ break;
+
+ case EPhoneViewSetTopApplication:
+ SetTopApplicationL( aCommandParam );
+ break;
+
+ case EPhoneViewActivateApp:
+ ActivateAppL( aCommandParam );
+ break;
+
+ case EPhoneViewActivateAppView:
+ ActivateAppViewL( aCommandParam );
+ break;
+
+ case EPhoneViewActivateAppViewWithCustomMessage:
+ ActivateAppViewWithCustomMessageL( aCommandParam );
+ break;
+
+ case EPhoneViewActivateAppViewConventional:
+ ActivateAppViewConventionalL( aCommandParam );
+ break;
+
+ case EPhoneViewUpdateIncallIndicator:
+ iMenuController->CloseMenuBar();
+ iIncallIndicator->Update( aCommandParam );
+ iMenuController->SetCallInProgressFlag( aCommandParam );
+ iToolbarController->SetCallInProgressFlag( aCommandParam );
+ break;
+
+ case EPhoneViewStartCapturingKey:
+ iKeyCaptureController->StartCapturingKey( aCommandParam );
+ break;
+
+ case EPhoneViewStopCapturingKey:
+ iKeyCaptureController->StopCapturingKey( aCommandParam );
+ break;
+
+ case EPhoneViewSetPointerCapture:
+ CapturePointerEvents( aCommandParam );
+ break;
+ case EPhoneViewSetGlobalNotifiersDisabled:
+ SetGlobalNotifiersDisabledL( aCommandParam );
+ break;
+ case EPhoneViewSetEikonNotifiersDisabled:
+ SetEikonNotifiersDisabled( aCommandParam );
+ break;
+
+ case EPhoneViewGetHoldFlag:
+ iMenuController->GetHoldFlag( aCommandParam );
+ break;
+
+ case EPhoneViewSetHoldFlag:
+ iMenuController->SetHoldFlag( aCommandParam );
+ if ( iButtonsController )
+ {
+ iButtonsController->SetHoldFlag( aCommandParam );
+ }
+ break;
+
+ case EPhoneViewSetVideoCallFlag:
+ if ( iButtonsController )
+ {
+ iButtonsController->SetVideoCallFlag( aCommandParam );
+ }
+ break;
+
+ case EPhoneViewGetConferenceAndSingleFlag:
+ iMenuController->GetConferenceAndSingleFlag( aCommandParam );
+ break;
+
+ case EPhoneViewSetConferenceAndSingleFlag:
+ iMenuController->SetConferenceAndSingleFlag( aCommandParam );
+ break;
+
+ case EPhoneViewGetSoftRejectFlag:
+ iMenuController->GetSoftRejectFlag( aCommandParam );
+ break;
+
+ case EPhoneViewSetSoftRejectFlag:
+ iMenuController->SetSoftRejectFlag( aCommandParam );
+ break;
+
+ case EPhoneViewSetServiceCodeFlag:
+ iMenuController->SetServiceCodeFlag( aCommandParam );
+
+ if ( iDialer )
+ {
+ iDialerController->SetServiceCodeFlag( aCommandParam );
+ }
+ break;
+
+ case EPhoneViewGetTextQueryContent:
+ iQueryController->GetTextQueryContentL( aCommandParam );
+ break;
+
+ case EPhoneViewOpenSoftRejectEditor:
+ OpenSoftRejectMessageEditorL( aCommandParam );
+ break;
+
+ case EPhoneViewOpenMessageEditor:
+ OpenMessageEditorL( aCommandParam );
+ break;
+
+ case EPhoneViewOpenConferenceList:
+ iBubbleWrapper->OpenConferenceList( aCommandParam );
+ iMenuController->SetConferenceParticipantsListVisibleFlag(
+ aCommandParam );
+ break;
+
+ case EPhoneViewGetConferenceListVisibleFlag:
+ iMenuController->GetConferenceParticipantsListVisibleFlag(
+ aCommandParam );
+ break;
+
+ case EPhoneViewMoveHighLightInList:
+ iBubbleWrapper->MoveHighlightInConference( aCommandParam );
+ break;
+
+ case EPhoneViewGetCountOfActiveCalls:
+ iBubbleWrapper->GetActiveCallsCount( aCommandParam );
+ break;
+
+ case EPhoneViewSetNaviPaneAudioVolume:
+ iAudioController->HandleVolumeChangeL( aCommandParam );
+ break;
+
+ case EPhoneViewSetTitlePanePicture:
+ iStatusPane->SetTitlePanePictureL( aCommandParam );
+ break;
+
+ case EPhoneViewSetStatusPaneVisible:
+ SetStatusPaneVisible( aCommandParam );
+ break;
+
+ case EPhoneViewSetBackgroundImageBitmap:
+ iPhoneView->SetBitmap( aCommandParam );
+ break;
+
+ case EPhoneViewGetBackgroundImageBitmap:
+ iPhoneView->GetBitmap( aCommandParam );
+ break;
+
+ case EPhoneViewGetIsConference:
+ iBubbleWrapper->GetIsConference( aCommandParam );
+ break;
+
+ case EPhoneViewPlayRingTone:
+ iRingingTonePlayerAO->PlayRingToneL( aCommandParam );
+ break;
+
+ case EPhoneViewGetIsNoteVisible:
+ iNoteController->IsNoteVisible( aCommandParam );
+ break;
+
+ case EPhoneViewIsNoteActive:
+ iNoteController->IsNoteActive( aCommandParam );
+ break;
+
+ case EPhoneViewIsActiveNoteDissmissableByKeyEvent:
+ iNoteController->IsActiveNoteDissmissableByKeyEvent( aCommandParam );
+ break;
+
+ case EPhoneViewGetIsProgressNoteVisible:
+ iNoteController->IsProgressNoteVisible( aCommandParam );
+ break;
+
+ case EPhoneViewSetPhoneNumberAvailableInPhoneEngine:
+ iMenuController->SetPhoneNumberAvailableInPhoneEngine(
+ aCommandParam );
+ break;
+
+ case EPhoneViewSendAiwCommand:
+ iMenuController->SendAiwCommandL( aCommandParam );
+ break;
+
+ case EPhoneViewIsQuery:
+ iQueryController->IsQueryActive( aCommandParam );
+ break;
+
+ case EPhoneViewToggleNumberEntryAlphaNumericMode:
+ {
+ iBubbleWrapper->ToggleNumberEntryAlphaNumericMode( aCommandParam );
+ TPhoneCmdParamBoolean* modeAlpha =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ iMenuController->SetAlphaModeFlag( modeAlpha->Boolean() );
+ }
+ break;
+
+ case EPhoneViewSetConfrenceOptionsFlag:
+ {
+ TPhoneCmdParamBoolean* param =
+ static_cast<TPhoneCmdParamBoolean*>(aCommandParam);
+ iMenuController->SetRemoveConfrenceOptionsFlag( param->Boolean() );
+ }
+ break;
+
+ case EPhoneViewGetSoftRejectWindowGroupId:
+ GetSoftRejectWindowGroupId( aCommandParam );
+ break;
+
+ case EPhoneViewSetTouchPaneButtons:
+ iButtonsController->SetButtonSet( aCommandParam );
+ break;
+
+ case EPhoneViewSetTouchPaneVisible:
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ iBubbleWrapper->SetTouchPaneVisible( booleanParam->Boolean() );
+ }
+ break;
+
+ case EPhoneViewSetDtmfDialerViewVisible:
+ {
+ if ( iDialer )
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ if ( booleanParam->Boolean() )
+ {
+ iDialer->SetControllerL( iDtmfDialerController );
+ }
+ else
+ {
+ iDialer->SetControllerL( iDialerController );
+ }
+ }
+ break;
+ }
+
+ case EPhoneViewSetDtmfOptionsFlag:
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ iMenuController->SetAllowDtmfOptionsFlag(
+ booleanParam->Boolean() );
+ break;
+ }
+
+ case EPhoneViewSetVoipCallDTMFVisibilityFlag:
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ iMenuController->SetHideVoipCallDTMFVisibilityFlag(
+ booleanParam->Boolean() );
+ break;
+ }
+ case EPhoneViewSetVideoCallDTMFVisibilityFlag:
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ iMenuController->SetHideVideoCallDTMFVisibilityFlag(
+ booleanParam->Boolean() );
+ break;
+ }
+
+ case EPhoneViewShowVTSetupFailedCreateCallToSameContactQuery:
+ iQueryController->CreateQueryL( aCommandParam );
+ break;
+
+ case EPhoneViewGetActivatePreviousApp:
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ booleanParam->SetBoolean( iPhoneView->GetActivatePreviousApp() );
+ }
+ break;
+
+ case EPhoneViewShowCustomizedDialer:
+ {
+ if ( iDialer )
+ {
+ TPhoneCmdParamCustomDialer* customDialerParam =
+ static_cast<TPhoneCmdParamCustomDialer*>( aCommandParam );
+ iDialer->SetControllerL( customDialerParam->DialerController() );
+ }
+ }
+ break;
+ case EPhoneViewGetNumberFromEntry:
+ {
+ iBubbleWrapper->GetNumberEntryContent( aCommandParam );
+ break;
+ }
+ case EPhoneViewUpdateContactByString:
+ {
+ TPhoneCmdParamString* paramString =
+ static_cast<TPhoneCmdParamString*>( aCommandParam );
+
+ OpenAddToContactL( EPbkCmdDataSaveAddToExisting,
+ *paramString->String() );
+ }
+ break;
+
+ case EPhoneViewAddContactByString:
+ {
+ TPhoneCmdParamString* paramString =
+ static_cast<TPhoneCmdParamString*>( aCommandParam );
+
+ OpenAddToContactL( EPbkCmdDataSaveCreateNew,
+ *paramString->String() );
+ }
+ break;
+ case EPhoneViewSetNoConnectedCalls:
+ {
+ iQueryController->SetNoConnectedCalls( aCommandParam );
+ }
+ break;
+ case EPhoneViewSetToolbarDimming:
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ iToolbarController->DimToolbar( booleanParam->Boolean());
+ break;
+ }
+
+ case EPhoneViewSetInvalidCsPhoneNumberFlag:
+ iMenuController->SetInvalidCsPhoneNumberFlag( aCommandParam );
+ break;
+
+ case EPhoneViewGetInvalidCsPhoneNumberFlag:
+ iMenuController->GetInvalidCsPhoneNumberFlag( aCommandParam );
+ break;
+
+ case EPhoneViewGetEasyDialingMenuId:
+ case EPhoneViewGetEasyDialingCbaId:
+ {
+ iEasyDialingController->ExecuteCommandL( aCmdId, aCommandParam );
+ }
+ break;
+ case EPhoneViewSetConferenceAndWaitingVideo:
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ iMenuController->SetConferenceAndWaitingVideoFlag( booleanParam->Boolean() );
+ }
+ break;
+ default:
+ __PHONELOG( EBasic, EPhonePhoneapp,
+ "CPhoneViewController::ExecuteCommandL -> UnKnownMessage !!! " );
+ break;
+ }
+
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId,
+ *aCommandParam );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ExecuteCommandL( aCmdId, aCallId, aCommandParam )
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::ExecuteCommandL(
+ TPhoneViewCommandId aCmdId,
+ TInt aCallId,
+ TPhoneCommandParam* aCommandParam )
+ {
+ __PHONELOGVIEWMSG( aCmdId, aCallId );
+
+ switch ( aCmdId )
+ {
+ case EPhoneViewUpdateBubble:
+ HandleUpdateBubbleL( aCallId, aCommandParam );
+ break;
+
+ case EPhoneViewCreateCallHeader:
+ iBubbleWrapper->CreateCallHeaderL( aCallId, aCommandParam );
+ break;
+
+ case EPhoneViewUpdateCallHeaderRemoteInfoData:
+ iBubbleWrapper->UpdateCallHeaderDisplay( aCallId, aCommandParam );
+ break;
+
+ case EPhoneViewUpdateCallHeaderRemoteInfoDataAndLabel:
+ iBubbleWrapper->UpdateCallHeaderAndLabel( aCallId, aCommandParam );
+ break;
+
+ case EPhoneViewCreateEmergencyCallHeader:
+ iBubbleWrapper->CreateEmergencyCallHeaderL( aCallId,
+ aCommandParam );
+ break;
+
+ case EPhoneViewCreateConference:
+ iBubbleWrapper->CreateConferenceL( aCallId, aCommandParam );
+ break;
+
+ case EPhoneViewGetCallExistsInConference:
+ iBubbleWrapper->CallExistsInConference( aCallId, aCommandParam );
+ break;
+
+ case EPhoneViewCipheringInfoChange:
+ {
+ iBubbleWrapper->UpdateCipheringIndicator( aCallId, aCommandParam );
+ }
+ break;
+
+ default:
+ __PHONELOG( EBasic, EPhonePhoneapp,
+ "CPhoneViewController::ExecuteCommandL -> UnKnownMessage !!! " );
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId, aCallId,
+ *aCommandParam );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ExecuteCommandL( aCmdId, aCallId, aMessage )
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::ExecuteCommandL(
+ TPhoneViewCommandId aCmdId,
+ TInt aCallId,
+ TDesC& aMessage )
+ {
+ __PHONELOGVIEWMSG( aCmdId, aCallId );
+
+ switch( aCmdId )
+ {
+ case EPhoneViewSetNumberEntryContent:
+ iBubbleWrapper->SetNumberEntryContent( aMessage );
+ break;
+
+ case EPhoneViewSetTitlePaneContent:
+ iStatusPane->SetTitlePaneContentL( aMessage );
+ break;
+
+ case EPhoneViewSetNaviPaneContent:
+ {
+ if ( !iDialer )
+ {
+ CAknNaviLabel* naviLabel = static_cast<CAknNaviLabel*>(
+ iStatusPane->NaviDecorator().DecoratedControl() );
+ naviLabel->SetTextL( aMessage );
+ iStatusPane->NaviDecorator().DrawDeferred();
+ }
+
+ }
+ break;
+
+ case EPhoneViewLaunchHelpApplication:
+ LaunchHelpApplicationL( aMessage );
+ break;
+
+ case EPhoneViewUpdateCallHeaderCallDuration:
+ iBubbleWrapper->UpdateCallDuration( aCallId, aMessage );
+ break;
+
+ default:
+ __PHONELOG (EBasic, EPhonePhoneapp, " CPhoneViewController::ExecuteCommandL -> UnHandledMessage !!! ");
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId, aCallId, &aMessage );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ExecuteCommand( aCmdId )
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::ExecuteCommand(
+ TPhoneViewCommandId aCmdId )
+ {
+ switch( aCmdId )
+ {
+ case EPhoneResetTouchButtons:
+ if ( iButtonsController )
+ {
+ iButtonsController->SetToggleButtons();
+ }
+ break;
+
+ case EPhoneViewBeginUpdate:
+ {
+ iBubbleWrapper->StartChanges();
+ }
+ break;
+
+ case EPhoneViewEndUpdate:
+ {
+ iBubbleWrapper->EndChanges();
+ }
+ break;
+ case EPhoneViewCloseSingleItemFetchDialog:
+ {
+ if ( iSingleItemFetch )
+ {
+ // Cancel the Single Item Fetch
+ iSingleItemFetch->Delete();
+ iSingleItemFetch = NULL;
+ }
+ }
+ break;
+
+ case EPhoneViewPrepareIcons:
+ iBubbleWrapper->BubbleManager().PrepareIcons();
+ break;
+
+ case EPhoneViewLoadPlugins:
+ iBubbleWrapper->LoadPlugins();
+ break;
+
+ case EPhoneViewCipheringInfoChangePlayTone:
+ {
+ iRingingTonePlayerAO->PlayUnsecureVoIPTone();
+ }
+ break;
+
+ default:
+ __PHONELOG (EBasic, EPhonePhoneapp, " CPhoneViewController::ExecuteCommand -> UnHandledMessage !!! ");
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ExecuteCommand( aCmdId, aCommandParam )
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::ExecuteCommand(
+ TPhoneViewCommandId aCmdId,
+ TPhoneCommandParam* aCommandParam )
+ {
+ __PHONELOGVIEWMSG( aCmdId, 0 );
+
+ switch ( aCmdId )
+ {
+ case EPhoneViewGetIsConferenceInSelectionMode:
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam )->SetBoolean(
+ iBubbleWrapper->BubbleManager().SelectionIdInConference() !=
+ KBubbleInvalidId );
+ break;
+
+ case EPhoneViewEnableTouchButton:
+ if ( iButtonsController )
+ {
+ iButtonsController->SetButtonEnabled( aCommandParam );
+ }
+ break;
+
+ case EPhoneViewDisableTouchButton:
+ if ( iButtonsController )
+ {
+ iButtonsController->SetButtonDisabled( aCommandParam );
+ }
+ break;
+
+ case EPhoneViewGetAudioVolumeLevel:
+ {
+ TInt level = iAudioController->VolumeLevelFromControl();
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam )->SetInteger(
+ level );
+ }
+ break;
+
+ case EPhoneViewBeginTransEffect:
+ {
+ if ( iDialer )
+ {
+ TPhoneTransEffectType type =
+ static_cast<TPhoneCmdParamTransEffect*>( aCommandParam )->Type();
+ if ( CanTransEffectBeUsed( type ) )
+ {
+ HandleTransitionEffect( type,
+ static_cast<TPhoneCmdParamTransEffect*>( aCommandParam )->AppUid());
+ }
+ }
+ break;
+ }
+
+ case EPhoneViewEndTransEffect:
+ {
+ if ( iDialer )
+ {
+ HandleTransitionEffect(
+ static_cast<TPhoneCmdParamTransEffect*>( aCommandParam )->Type() );
+ }
+ break;
+ }
+ case EPhoneViewGetNumberFromEntry:
+ {
+ iBubbleWrapper->GetNumberEntryContent( aCommandParam );
+ break;
+ }
+
+ case EPhoneViewGetKeyLockStatus:
+ {
+ TPhoneCmdParamBoolean* booleanParam = static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ booleanParam->SetBoolean( iKeyLock.IsKeyLockEnabled() );
+ }
+ break;
+
+ case EPhoneViewSetNumberEntryObserver:
+ {
+ iBubbleWrapper->SetNumberEntryChangedCallBack( aCommandParam );
+ break;
+ }
+ case EPhoneViewGetSingleItemFetchType:
+ {
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam )->SetInteger( SingleItemFetchType() );
+ break;
+ }
+ case EPhoneViewSetPhoneCustomization:
+ {
+ TPhoneCmdParamPointer* pointerParam =
+ static_cast<TPhoneCmdParamPointer*>( aCommandParam );
+ MPhoneCustomization* phoneCustomization =
+ static_cast<MPhoneCustomization*>( pointerParam->Pointer() );
+ iBubbleWrapper->SetPhoneCustomization( phoneCustomization );
+ }
+ break;
+ case EPhoneViewSetViewCustomization:
+ {
+ TPhoneCmdParamPointer* pointerParam =
+ static_cast<TPhoneCmdParamPointer*>( aCommandParam );
+ iCustomization =
+ static_cast<MPhoneViewCustomization*>( pointerParam->Pointer() );
+ }
+ break;
+ case EPhoneViewSetButtonCustomization:
+ {
+ if ( iButtonsController )
+ {
+ TPhoneCmdParamPointer* pointerParam =
+ static_cast<TPhoneCmdParamPointer*>( aCommandParam );
+ MPhoneButtonCustomization* customization =
+ static_cast<MPhoneButtonCustomization*>( pointerParam->Pointer() );
+ iButtonsController->SetCustomization( customization );
+ }
+ }
+ break;
+
+ case EPhoneViewEnableToolbarButton:
+ {
+ TPhoneCmdParamInteger* integerParam =
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam );
+ iToolbarController->SetToolbarButtonDimmed( integerParam->Integer(), EFalse );
+ }
+ break;
+
+ case EPhoneViewGetQwertyModeObserver:
+ {
+ TPhoneCmdParamPointer* ptrParam = static_cast<TPhoneCmdParamPointer*>( aCommandParam );
+ ptrParam->SetPointer( static_cast<TAny*>( iDialer ) );
+ }
+ break;
+
+ default:
+ __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneViewController::ExecuteCommand -> UnHandledMessage !!! " );
+ break;
+ }
+ CPhoneMediatorFactory::Instance()->Sender()->SendEvent( aCmdId, *aCommandParam );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::HandleCommandL( aCmdId )
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TPhoneViewResponseId CPhoneViewController::HandleCommandL(
+ TPhoneViewCommandId aCmdId )
+ {
+ __PHONELOGVIEWMSG( aCmdId, 0 );
+
+ TPhoneViewResponseId viewResponse = EPhoneViewResponseSuccess;
+
+ switch ( aCmdId )
+ {
+ case EPhoneViewGetNumberEntryIsUsedStatus:
+ viewResponse = iBubbleWrapper->IsNumberEntryUsed() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ break;
+
+ case EPhoneViewGetNumberEntryIsVisibleStatus:
+ if ( iDialer )
+ {
+ viewResponse = iDialerActive ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ }
+ else
+ {
+ viewResponse = iBubbleWrapper->IsNumberEntryVisible() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ }
+ break;
+
+ case EPhoneViewGetEasyDialingInFocusStatus:
+ case EEasyDialingVoiceCall:
+ case EEasyDialingVideoCall:
+ case EEasyDialingSendMessage:
+ case EEasyDialingOpenContact:
+ case EEasyDialingCallHandlingActivated:
+ case EEasyDialingEnterKeyAction:
+ case EEasyDialingOn:
+ case EEasyDialingOff:
+ if ( iDialer )
+ {
+ viewResponse = iEasyDialingController->HandleCommandL( aCmdId );
+ }
+ else
+ {
+ viewResponse = EPhoneViewResponseFailed;
+ }
+ break;
+
+ case EPhoneViewIsNumberEntryNumericMode:
+ viewResponse = iBubbleWrapper->IsNENumericMode() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ break;
+
+ case EPhoneViewGetNeedToReturnToForegroundAppStatus:
+ viewResponse = GetNeedToReturnToForegroundAppAfterCallL() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ break;
+
+ case EPhoneViewGetTopApplicationIsDisplayedStatus:
+ {
+ const TInt foregroundWg = ForegroundApplicationWindowGroupId();
+ const TBool topAppDisplayed = ( IdleWindowGroupId() == foregroundWg ) ||
+ ( ApplicationWindowGroupId() == foregroundWg );
+ viewResponse = topAppDisplayed ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ }
+ break;
+
+ case EPhoneViewGetTitlePaneIsVisibleStatus:
+ viewResponse = iStatusPane->IsTitlePaneVisible( *this ) ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ break;
+
+ case EPhoneViewIsMenuBarVisible:
+ viewResponse = iMenuController->IsMenuBarVisible() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ break;
+
+ case EPhoneViewIsStraightCallToVideoMailBox:
+ {
+ if( !iVmbxHandler )
+ {
+ iVmbxHandler = CPhoneVmbxHandler::NewL();
+ }
+
+ viewResponse = iVmbxHandler->IsStraightCallToVideoMailBox() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ }
+ break;
+
+ // Dialer specific commands start
+
+ // Dialer handles these commands.
+ // ** TODO Here we need just to flag if functionality creates blocking dialog.
+ case EPhoneDialerCmdLog:
+ {
+ BeginTransEffectForAppStartFromDialerLC( LogsUiCmdStarterConsts::KLogsUID3 );
+ LogsUiCmdStarter::CmdStartL( LogsUiCmdStarterConsts::KDialledView());
+ EndTransEffect();
+ }
+ break;
+
+ case EPhoneDialerCmdContacts:
+ {
+ // Launch Phonebook application
+ TPhoneCmdParamAppInfo appInfoParam;
+ appInfoParam.SetAppUid( KPhoneUidAppPhonebook );
+ BeginTransEffectForAppStartFromDialerLC( appInfoParam.AppUid() );
+ ExecuteCommandL( EPhoneViewActivateApp, &appInfoParam );
+ EndTransEffect();
+ }
+ break;
+
+ case EPhoneDialerCmdSpeedDial:
+ {
+ // Launch speeddial application.
+ TPhoneCmdParamAppInfo appInfoParam;
+ appInfoParam.SetAppUid( KUidSpdia );
+ ExecuteCommandL( EPhoneViewActivateApp, &appInfoParam );
+ break;
+ }
+
+ case EPhoneDialerCallSettings:
+ {
+ CGSLauncher* launcher = CGSLauncher::NewLC();
+ launcher->LaunchGSViewL( TUid::Uid( 0x102824A2),
+ TUid::Uid( 0x100058B3),
+ KNullDesC8 );
+ CleanupStack::PopAndDestroy( launcher );
+ break;
+ }
+
+ case EPhoneViewIsDTMFEditorVisible:
+ if ( iDialer )
+ {
+ viewResponse = ( IsDtmfDialerActive() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed );
+ }
+ else // non-touch.
+ {
+ viewResponse = iQueryController->IsDTMFQueryVisible() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ }
+ break;
+
+ case EPhoneViewIsConferenceInExpandedMode:
+ viewResponse = iBubbleWrapper->IsConferenceInExpandedMode() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ break;
+
+ case EPhoneViewOpenNumberEntry:
+ if ( iDialer )
+ {
+ TPhoneCmdParamBoolean booleanParam;
+ booleanParam.SetBoolean( ETrue );
+
+ if ( iBubbleWrapper->IsNumberEntryUsed() )
+ {
+ // Launch dialer.
+ ExecuteCommandL( EPhoneViewSetNumberEntryVisible, &booleanParam );
+ }
+ else // dialer doesnt exist.
+ {
+ // Create and launch dialer.
+ ExecuteCommandL( EPhoneViewCreateNumberEntry, &booleanParam );
+ }
+ // Set Number Entry CBA
+ TPhoneCmdParamInteger integerParam;
+ if ( iSecurityMode )
+ {
+ iNoteController->DestroyNote();
+ integerParam.SetInteger(
+ CPhoneMainResourceResolver::Instance()->
+ ResolveResourceID( EPhoneEmergencyModeNoteCBA ) );
+ }
+ else
+ {
+ integerParam.SetInteger(
+ CPhoneMainResourceResolver::Instance()->
+ ResolveResourceID( EPhoneNumberAcqCBA ) );
+ }
+ ExecuteCommandL( EPhoneViewUpdateCba, &integerParam );
+ // Set flag to false because dialler is set to open status.
+ iPhoneView->SetPhoneAppViewToDialer( EFalse );
+ }
+ break;
+
+ case EPhoneViewOpenCallHandling:
+ if ( iDialer )
+ {
+ if ( iBlockingDialogIsDisplayed )
+ {
+ RemovePhoneDialogsL();
+ }
+ // Remove DTMF dialer when exist
+ if ( IsDtmfDialerActive() )
+ {
+ static_cast<MEikCommandObserver*>( CEikonEnv::Static()->EikAppUi() )
+ ->ProcessCommandL( EPhoneDtmfDialerExit );
+ }
+ else if ( iCustomization &&
+ IsCustomDialerActive() )
+ {
+ iCustomization->HandleCommandL(
+ *this, EPhoneViewOpenCallHandling, NULL );
+ }
+ else
+ {
+ SetControltoCallHandlingL();
+ }
+ }
+ break;
+
+ case EPhoneViewIsIdleTopApp:
+ {
+ viewResponse = CPhonePubSubProxy::Instance()->Value(
+ KPSUidUikon, KUikVideoCallTopApp ) == IdleAppUid() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ }
+ break;
+
+ case EPhoneViewSetDialerControlVisible:
+ {
+ // If dialer was not active and needtosendback is false
+ // then check if dialer view is to be opened.
+ if ( !iDialerActive &&
+ !iNeedToReturnToForegroundAppAfterCall &&
+ iPhoneView->PhoneAppViewToDialer() )
+ {
+ SetControltoDialerL();
+ // Reset flag.
+ iPhoneView->SetPhoneAppViewToDialer( EFalse );
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ else
+ {
+ // Reset flag.
+ iPhoneView->SetPhoneAppViewToDialer( EFalse );
+ viewResponse = EPhoneViewResponseFailed;
+ }
+ }
+ break;
+// Dialer specific commands end.
+
+ case EPhoneIsCustomizedDialerVisible:
+ {
+ viewResponse = IsCustomDialerActive() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ }
+ break;
+
+ case EPhoneViewHideCustomizedDialer:
+ {
+ if ( iDialer )
+ {
+ iDialer->SetControllerL( iDialerController );
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ }
+ break;
+ case EPhoneViewShowToolbar:
+ {
+ iToolbarController->ShowToolbar();
+ }
+ break;
+
+ case EPhoneViewIsDisplayingMenuOrDialog:
+ {
+ viewResponse = iEikEnv.EikAppUi()->IsDisplayingMenuOrDialog() ?
+ EPhoneViewResponseSuccess :
+ EPhoneViewResponseFailed;
+ }
+ break;
+ default:
+ viewResponse = EPhoneViewResponseFailed;
+ __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneViewController::HandleCommandL -> UnKnownMessage !!! ");
+ break;
+ }
+
+ return viewResponse;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::HandleCommand( aCmdId, aCommandParam )
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TPhoneViewResponseId CPhoneViewController::HandleCommandL(
+ TPhoneViewCommandId aCmdId,
+ TPhoneCommandParam* aCommandParam )
+ {
+ __PHONELOGVIEWMSG( aCmdId, 0 );
+ TPhoneViewResponseId viewResponse = EPhoneViewResponseSuccess;
+ TInt err;
+
+ switch ( aCmdId )
+ {
+ case EPhoneViewSendKeyEventToNumberEntry:
+ {
+ // Pass the key event to the Bubble Manager (ignore key
+ // reponse)
+ iBubbleWrapper->HandleKeyEventL( aCommandParam );
+
+ // Indicate whether the number entry has been cleared
+ if ( iBubbleWrapper->CountNumberEntryCharacters() == 0 && !iDialer )
+ {
+ viewResponse = EPhoneViewResponseNumberEntryCleared;
+ }
+ else
+ {
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ break;
+ }
+
+ case EPhoneViewAssignSpeedDialLocation:
+ {
+ if ( AssignSpeedDialLocation( aCommandParam ) )
+ {
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ else
+ {
+ viewResponse = EPhoneViewResponseFailed;
+ }
+ break;
+ }
+
+ case EPhoneViewSelectedConfMember:
+ {
+ if ( iBubbleWrapper->SelectedConfMemberCallIdL( aCommandParam ) )
+ {
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ else
+ {
+ viewResponse = EPhoneViewResponseFailed;
+ }
+ break;
+ }
+
+ case EPhoneViewGetCallState:
+ {
+ if ( iBubbleWrapper->GetCallState( aCommandParam ) )
+ {
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ else
+ {
+ viewResponse = EPhoneViewResponseFailed;
+ }
+ break;
+ }
+
+ case EPhoneViewGetCallIdByState:
+ {
+ if ( iBubbleWrapper->GetCallIdByState( aCommandParam ) )
+ {
+ viewResponse = EPhoneViewResponseFailed;
+ }
+ else
+ {
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ break;
+ }
+
+ case EPhoneViewOpenSingleItemFetchDialog:
+ {
+ // Create CPhoneSingleItemFetch, if not exist
+ if ( !iSingleItemFetch )
+ {
+ iSingleItemFetch = CPhoneSingleItemFetch::NewL(
+ iEikEnv, *this, *iContactController, *iStatusPane );
+ }
+
+ iBlockingDialogIsDisplayed = ETrue;
+
+ TRAP( err, iSingleItemFetch->OpenSingleItemFetchDialogL( aCommandParam ))
+ if ( err )
+ {
+ iBlockingDialogIsDisplayed = EFalse;
+ User::Leave( err );
+ }
+ break;
+ }
+
+ case EPhoneViewGetNumberFromSpeedDialLocation:
+ if ( iBlockingDialogIsDisplayed )
+ {
+ viewResponse = EPhoneViewResponseFailed;
+ }
+ else
+ {
+ TBool status( EFalse );
+ TRAP( err, status = GetNumberFromSpeedDialLocationL( aCommandParam ))
+ if ( err )
+ {
+ viewResponse = EPhoneViewResponseFailed;
+ // Set and reset in GetNumberFromSpeedDialLocationL when not leave
+ iBlockingDialogIsDisplayed = EFalse;
+ }
+ else if ( status )
+ {
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ else
+ {
+ viewResponse = EPhoneViewResponseFailed;
+ }
+ }
+ break;
+
+ case EPhoneViewGetCustomizedDialerMenuResourceId:
+ {
+ TInt resId = iDialer->Controller()->MenuResourceId(); // easydialing change
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam )->SetInteger( resId );
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ break;
+ case EPhoneViewGetCustomizedDialerCbaResourceId:
+ {
+ TInt resId = iDialer->Controller()->CbaResourceId(); // easydialing change
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam )->SetInteger( resId );
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ break;
+
+ default:
+ if ( iCustomization )
+ {
+ // Let customization handle view command
+ if ( iCustomization->HandleCommandL(
+ *this, aCmdId, aCommandParam ) )
+ {
+ viewResponse = EPhoneViewResponseSuccess;
+ }
+ else
+ {
+ viewResponse = EPhoneViewResponseFailed;
+ }
+ }
+ else
+ {
+ __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneViewController::HandleCommandL -> UnKnownMessage !!! ");
+ }
+ break;
+ }
+
+ return viewResponse;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::HandleTitlePaneActiveL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::HandleTitlePaneActiveL( TBool aActive )
+ {
+ if ( aActive )
+ {
+ iStatusPane->UpdateTitlePane();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ApplicationWindowGroupId
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt CPhoneViewController::ApplicationWindowGroupId()
+ {
+ TInt phoneAppWg = iEikEnv.RootWin().Identifier();
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::ApplicationWindowGroupId - PhoneApplicationWindowGroupId = (%d)",
+ phoneAppWg );
+ return phoneAppWg;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::IdleWindowGroupId
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt CPhoneViewController::IdleWindowGroupId()
+ {
+ if ( !iIdleWg )
+ {
+ // Save Idle window group.
+ TApaTaskList appList( iEikEnv.WsSession() );
+ TApaTask bring = appList.FindApp( TUid::Uid( IdleAppUid() ) );
+ if ( bring.Exists() )
+ {
+ iIdleWg = bring.WgId();
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::ConstructL -> iIdleWindowGroupId = (%d)",
+ iIdleWg );
+ }
+ }
+
+ return iIdleWg;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::GetSoftRejectWindowGroupId
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::GetSoftRejectWindowGroupId(
+ TPhoneCommandParam* aCommandParam )
+ {
+ TInt softRejectWg( KErrNotFound );
+ TPhoneCmdParamInteger* integerParam =
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam );
+
+ TApaTaskList appList( iEikEnv.WsSession() );
+ TApaTask bring = appList.FindApp( TUid::Uid( KSenduiUniEditorUidValue ) );
+ if ( bring.Exists() )
+ {
+ softRejectWg = bring.WgId();
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SoftRejectWindowGroupId = (%d)",
+ softRejectWg );
+ }
+ integerParam->SetInteger( softRejectWg );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ForegroundApplicationWindowGroupId
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt CPhoneViewController::ForegroundApplicationWindowGroupId()
+ {
+ TInt result(0);
+ TRAP_IGNORE( result = DoFetchForegroundApplicationWindowGroupIdL(
+ iEikEnv ) );
+ __PHONELOG1( EBasic,
+ EPhoneUIView,
+ "CPhoneViewController::ForegroundApplicationWindowGroupId() GroupId %d",
+ result );
+ return result;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::DoFetchForegroundApplicationWindowGroupIdL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt CPhoneViewController::DoFetchForegroundApplicationWindowGroupIdL(
+ CEikonEnv& aEnv )
+ {
+ TInt result = 0;
+ RWsSession& wsSession = aEnv.WsSession();
+ const TInt numWg = wsSession.NumWindowGroups(
+ KPhoneApplicationWindowGroupPriority );
+
+ CArrayFixFlat<TInt>* wgList =
+ new (ELeave) CArrayFixFlat<TInt>( numWg );
+ CleanupStack::PushL( wgList );
+ wgList->SetReserveL( numWg );
+
+ // Get list of window groups; all applications should be at priority 0.
+ //
+ if ( wsSession.WindowGroupList(
+ KPhoneApplicationWindowGroupPriority,
+ wgList ) == KErrNone )
+ {
+ if ( wgList->Count() )
+ {
+ result = wgList->At( 0 ); // The very first window group id
+ }
+ }
+
+ CleanupStack::PopAndDestroy( wgList );
+ return result;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetHiddenL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::SetHiddenL( const TBool aHidden )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,"CPhoneViewController::SetHiddenL()" )
+ CApaWindowGroupName* windowGroupName =
+ CApaWindowGroupName::NewLC(
+ iEikEnv.WsSession(),
+ iEikEnv.RootWin().Identifier() );
+ windowGroupName->SetHidden( aHidden );
+ User::LeaveIfError(
+ windowGroupName->SetWindowGroupName(
+ iEikEnv.RootWin() ) );
+ CleanupStack::PopAndDestroy( windowGroupName );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::HandleResourceChangeL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::HandleResourceChangeL( TInt aType )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::HandleResourceChangeL()" )
+ // Notify the bubble that there has been a resource change
+ iBubbleWrapper->Control()->HandleResourceChange( aType );
+
+ // Notify dialer and switch statuspane layout.
+ if ( iDialer )
+ {
+ if ( aType == KEikDynamicLayoutVariantSwitch )
+ {
+ SwitchLayoutToFlatStatusPaneL( iDialerActive );
+ }
+ static_cast<CCoeControl*>(iDialer)->HandleResourceChange( aType );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::BlockingDialogIsDisplayed
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TBool CPhoneViewController::BlockingDialogIsDisplayed() const
+ {
+ return iBlockingDialogIsDisplayed;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::HandleLayoutChange
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::HandleLayoutChange( TRect aRect )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,"CPhoneViewController::HandleLayoutChange()" )
+ iPhoneView->SetRect( aRect );
+ if ( iDialerView )
+ {
+ iDialerView->SetRect( aRect );
+ iStatusPane->UpdateTitlePane();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::StatusPaneDisplayed
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TBool CPhoneViewController::StatusPaneDisplayed()
+ {
+ return CPhoneStatusPane::Instance()->IsVisible();
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::IsEmergencyCallOngoing()
+// ---------------------------------------------------------------------------
+//
+TBool CPhoneViewController::IsEmergencyCallOngoing()
+ {
+ __LOGMETHODSTARTEND( EPhoneUIView,
+ "CPhoneViewController::IsEmergencyCallOngoing()");
+
+ TPhoneCmdParamCallStateData callStateData;
+ callStateData.SetCallState( EPEStateConnected );
+ iBubbleWrapper->GetCallIdByState( &callStateData );
+ TInt connected = callStateData.CallId();
+
+ callStateData.SetCallState( EPEStateConnecting );
+ iBubbleWrapper->GetCallIdByState( &callStateData );
+ TInt connecting = callStateData.CallId();
+
+ return ( ( connected == KEmergencyCallId ) ||
+ ( connecting == KEmergencyCallId ) );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::HandleSecurityModeChanged
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::HandleSecurityModeChanged( TBool aIsEnabled )
+ {
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::HandleSecurityModeChanged Mode = (%d)", aIsEnabled );
+
+ TBool emergencyCallOngoing = IsEmergencyCallOngoing();
+
+ // Don't undim toolbar if emergency call is ongoing
+ if ( !emergencyCallOngoing )
+ {
+ iToolbarController->DimToolbar( aIsEnabled );
+ }
+ iPhoneView->SetSecurityMode( aIsEnabled );
+ iMenuController->SetSecurityMode( aIsEnabled );
+
+ TBool securityModeChanged = ( iSecurityMode != aIsEnabled );
+
+ iSecurityMode = aIsEnabled;
+
+ if ( iDialer )
+ {
+ iDialerController->SetRestrictedDialer( aIsEnabled );
+
+ if ( iDialerActive && securityModeChanged )
+ {
+ CDialingExtensionInterface* easyDialing = iDialer->GetEasyDialingInterface();
+ if ( easyDialing )
+ {
+ if ( aIsEnabled )
+ {
+ // Reset the Easy Dialing just in case, this clears the existing matches
+ // when restricted mode is activated
+ easyDialing->Reset();
+ }
+ else
+ {
+ if ( easyDialing->IsEnabled() )
+ {
+ // If Easy Dialing is enabled, set the input from the numeric entry
+ // field for updating the search result when restricted mode is
+ // deactivated.
+ TBuf<KDialerInputMaxChars> buf;
+ iDialer->NumberEntry()->GetTextFromNumberEntry( buf );
+ TRAP_IGNORE( easyDialing->SetInputL( buf ) );
+ }
+ }
+ }
+ iDialer->RelayoutAndDraw();
+
+ // Don't update cba here if emergency call is ongoing
+ if ( !emergencyCallOngoing )
+ {
+ // also update cba if security mode changes while dialer is open
+ TPhoneCmdParamInteger integerParam;
+ if ( aIsEnabled )
+ {
+ iNoteController->DestroyNote();
+ integerParam.SetInteger( CPhoneMainResourceResolver::Instance()->
+ ResolveResourceID( EPhoneEmergencyModeNoteCBA ) );
+ }
+ else
+ {
+ integerParam.SetInteger( CPhoneMainResourceResolver::Instance()->
+ ResolveResourceID( EPhoneNumberAcqCBA ) );
+ }
+ TRAP_IGNORE( ExecuteCommandL( EPhoneViewUpdateCba, &integerParam ) );
+ }
+ if ( !aIsEnabled )
+ {
+ TRAP_IGNORE( SwitchLayoutToFlatStatusPaneL( ETrue ) );
+ }
+ }
+ }
+ if ( securityModeChanged )
+ {
+ // Update cba if security mode changes while emergency call is ongoing
+ if ( emergencyCallOngoing )
+ {
+ TRAP_IGNORE( static_cast<MEikCommandObserver*>( CEikonEnv::Static()->EikAppUi() )
+ ->ProcessCommandL( EPhoneCmdUpdateEmergencyCba ) );
+ }
+
+ // Update status pane dimming
+ iStatusPane->StatusPane().SetDimmed( aIsEnabled );
+
+ // Uncapture the App key for sure
+ TPhoneCmdParamKeyCapture appKeyCaptureParam;
+ appKeyCaptureParam.SetKey( EStdKeyApplication0 );
+ appKeyCaptureParam.SetKeyCode( EKeyApplication0 );
+ appKeyCaptureParam.SetCaptureType( EPhoneKeyAllEvents );
+
+ iKeyCaptureController->StopCapturingKey( &appKeyCaptureParam );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::IdleAppUid
+// ---------------------------------------------------------------------------
+//
+TInt CPhoneViewController::IdleAppUid()
+ {
+ if ( iIdleUid == KErrNotFound )
+ {
+ // Get Idle's UID from PubSub.
+ iIdleUid = CPhonePubSubProxy::Instance()->Value(
+ KPSUidAiInformation,
+ KActiveIdleUid );
+
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::ConstructL -> iIdleUid = (%d)", iIdleUid );
+ }
+ return iIdleUid;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetBlockingDialogIsDisplayed
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CPhoneViewController::SetBlockingDialogIsDisplayed(
+ TBool aBlockingDialog )
+ {
+ iBlockingDialogIsDisplayed = aBlockingDialog;
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SetBlockingDialogIsDisplayed(%d)",
+ iBlockingDialogIsDisplayed );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::NumberEntryStateChanged
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::NumberEntryStateChanged( TBool aEntryHasText )
+ {
+ iMenuController->SetNumberEntryEmptyFlag( !aEntryHasText );
+ iBubbleWrapper->HandleNumberEntryChanged();
+ TRAP_IGNORE( ExecuteCommandL( EPhoneViewUpdateToolbar ) );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::GetBlockingDialogIsDisplayed
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::GetBlockingDialogIsDisplayed(
+ TPhoneCommandParam* aCommandParam )
+ {
+ if( aCommandParam->ParamId() == TPhoneCommandParam::EPhoneParamIdBoolean )
+ {
+ TPhoneCmdParamBoolean* booleanValue =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+ booleanValue->SetBoolean( iBlockingDialogIsDisplayed );
+ }
+ }
+
+
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SendToBackgroundL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SendToBackgroundL()
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::SendToBackgroundL" );
+
+ TApaTaskList appList( iEikEnv.WsSession() );
+ TApaTask phoneApp = appList.FindApp( KUidPhoneApplication );
+ iSendBack = EFalse;
+
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SendToBackgroundL - phoneApp.WgId() (%d)", phoneApp.WgId() );
+
+ // no need for sending phone background if it is not front
+ if ( ( phoneApp.Exists() ) && phoneApp.WgId() ==
+ ForegroundApplicationWindowGroupId() )
+ {
+ // make sure that previous application window group id is not
+ //telephony's
+ if( iPrevForegroundAppWg > 0 &&
+ iPrevForegroundAppWg != phoneApp.WgId() )
+ {
+ // check that previous app still exists. It might be for example
+ // add to contact - dialog that is allready destroyed.
+ TInt previousApp = FindAppByWgIDL( iPrevForegroundAppWg );
+
+ if( previousApp != KErrNotFound )
+ {
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SendToBackgroundL - Bring previous app to foreground (%d)"
+ , iPrevForegroundAppWg );
+
+ CAknSgcClient::MoveApp( iPrevForegroundAppWg, ESgcMoveAppToForeground );
+ iSendBack = ETrue;
+ SetWindowGroupPosition();
+ }
+ }
+ else
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::SendToBackgroundL - send telephony to background" );
+
+ iSendBack = ETrue;
+ CAknSgcClient::MoveApp( phoneApp.WgId(),
+ ESgcMoveAppToBackground );
+ }
+ }
+
+ // Clear the send to background flag
+ iNeedToReturnToForegroundAppAfterCall = EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::FindAppByWgIDL
+// ---------------------------------------------------------------------------
+//
+TInt CPhoneViewController::FindAppByWgIDL( TInt aAppWgID ) const
+ {
+ __LOGMETHODSTARTEND( EPhoneUIView,
+ "CPhoneViewController::FindAppByWgIDL() ")
+ TInt appExists( KErrNotFound );
+ RWsSession& wsSession = iEikEnv.WsSession();
+ const TInt numWg = wsSession.NumWindowGroups(
+ KPhoneApplicationWindowGroupPriority );
+
+ CArrayFixFlat<TInt>* wgList =
+ new (ELeave) CArrayFixFlat<TInt>( numWg );
+ CleanupStack::PushL( wgList );
+ wgList->SetReserveL( numWg );
+
+ // Get list of window groups; all applications should be at priority 0.
+ if ( wsSession.WindowGroupList(
+ KPhoneApplicationWindowGroupPriority,
+ wgList ) == KErrNone )
+ {
+ for( TInt i = 0; i < wgList->Count(); i++ )
+ {
+ if( aAppWgID == wgList->At( i ) )
+ {
+ appExists = i;
+ break;
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( wgList );
+ return appExists;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetWindowGroupPosition
+// This is used when dialer has opened some other
+// app(Logs) and MT call arrives, when MT call is
+// answered phone is put to backround and it isnt anymore next
+// active app which means that when previous app is opened
+// after answer and user presses exit we need to update
+// ordinal position so that dialer is activated.
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetWindowGroupPosition()
+ {
+ iEikEnv.WsSession().SetWindowGroupOrdinalPosition(
+ ApplicationWindowGroupId(),
+ KPhoneWindowGroupPositionBackground );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::BringAppToForeground
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::BringAppToForeground(
+ TPhoneCommandParam* aCommandParam )
+ {
+ TPhoneCmdParamInteger* integerParam =
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam );
+
+ TApaTaskList appList( iEikEnv.WsSession() );
+ TApaTask application = appList.FindApp(
+ TUid::Uid( integerParam->Integer() ) );
+
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::BringAppToForeground - App WG ID: %d",
+ application.WgId() );
+ if( application.Exists() )
+ {
+ iPrevForegroundAppWg = ForegroundApplicationWindowGroupId();
+ CAknSgcClient::MoveApp( application.WgId(), ESgcMoveAppToForeground );
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::BringAppToForeground - Previous App WG ID: %d",
+ iPrevForegroundAppWg );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::BringPhoneAppToForeground
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::BringPhoneAppToForeground(
+ TPhoneCommandParam* aCommandParam )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::BringPhoneAppToForeground()" );
+
+ TPhoneCmdParamInteger* integerParam =
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam );
+
+ TApaTaskList appList( iEikEnv.WsSession() );
+ TApaTask phoneApp = appList.FindApp(
+ TUid::Uid( integerParam->Integer() ) );
+
+ // Saves previous window group id. Test if app is allready in front.
+ if( phoneApp.Exists() &&
+ ForegroundApplicationWindowGroupId() != phoneApp.WgId() )
+ {
+ iPrevForegroundAppWg = ForegroundApplicationWindowGroupId();
+ CAknSgcClient::MoveApp( phoneApp.WgId(), ESgcMoveAppToForeground );
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::BringPhoneAppToForeground - Previous App WG ID: %d",
+ iPrevForegroundAppWg );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetTopApplicationL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetTopApplicationL(
+ TPhoneCommandParam* aCommandParam )
+ {
+ // Set the top application
+ TPhoneCmdParamInteger* integerParam =
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam );
+ CPhonePubSubProxy::Instance()->ChangePropertyValue(
+ KPSUidUikon,
+ KUikVideoCallTopApp,
+ integerParam->Integer() );
+
+ // Hide the Phone icon if it is not the top application
+ SetHiddenL( integerParam->Integer() != KUidPhoneApplication.iUid );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::GetForegroundApplication
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::GetForegroundApplication(
+ TPhoneCommandParam* aCommandParam )
+ {
+ // Get the foreground application window group id
+ TPhoneCmdParamInteger* integerParam =
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam );
+ integerParam->SetInteger( ForegroundApplicationWindowGroupId() );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ActivateAppViewConventionalL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::ActivateAppViewConventionalL(
+ TPhoneCommandParam* aCommandParam )
+ {
+ TPhoneCmdParamAppInfo* appInfoParam =
+ static_cast<TPhoneCmdParamAppInfo*>( aCommandParam );
+
+ TApaTaskList taskList( iEikEnv.WsSession() );
+ TApaTask task = taskList.FindApp( appInfoParam->AppUid() );
+ if ( task.Exists() )
+ {
+ CAknSgcClient::MoveApp( task.WgId(), ESgcMoveAppToForeground );
+ }
+ else
+ {
+ CreateConnectionL();
+ HBufC* param = HBufC::NewLC( appInfoParam->Param().Length() );
+ param->Des().Copy( appInfoParam->Param() );
+ TThreadId id;
+ User::LeaveIfError(
+ iApaLsSession.StartDocument( *param,
+ appInfoParam->AppUid(), id ) );
+ CleanupStack::PopAndDestroy( param );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ActivateAppL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::ActivateAppL(
+ TPhoneCommandParam* aCommandParam )
+ {
+ TPhoneCmdParamAppInfo* appInfoParam =
+ static_cast<TPhoneCmdParamAppInfo*>( aCommandParam );
+
+ __PHONELOG( EBasic, EPhoneUIView,"CPhoneViewController::ActivateAppL()" );
+
+ CreateConnectionL();
+
+ if ( appInfoParam->MultipleInstances() )
+ {
+ ActivateAppInstanceL( appInfoParam->AppUid() );
+ }
+ else
+ {
+ TApaTaskList apaTaskList( iEikEnv.WsSession() );
+ TApaTask apaTask = apaTaskList.FindApp( appInfoParam->AppUid() );
+ if ( apaTask.Exists() )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::ActivateAppL() bring to foreground" );
+ CAknSgcClient::MoveApp( apaTask.WgId(), ESgcMoveAppToForeground );
+ }
+ else
+ {
+ ActivateAppInstanceL( appInfoParam->AppUid() );
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ActivateAppInstanceL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::ActivateAppInstanceL( TUid aUid )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::ActivateAppInstanceL()" );
+ CreateConnectionL();
+
+ TApaAppInfo appInfo;
+ User::LeaveIfError( iApaLsSession.GetAppInfo( appInfo, aUid ) );
+
+#ifdef SYMBIAN_SUPPORT_UI_FRAMEWORKS_V1
+ CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC(
+ appInfo.iFullName );
+#else
+ CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC();
+ apaCommandLine->SetExecutableNameL( appInfo.iFullName );
+ apaCommandLine->SetCommandL( EApaCommandRun );
+#endif // SYMBIAN_SUPPORT_UI_FRAMEWORKS_V1
+
+ User::LeaveIfError ( iApaLsSession.StartApp( *apaCommandLine ) );
+ CleanupStack::PopAndDestroy( apaCommandLine );
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::ActivateAppInstanceL() done" );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ActivateAppViewL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::ActivateAppViewL(
+ TPhoneCommandParam* aCommandParam )
+ {
+ TPhoneCmdParamAppInfo* appInfoParam =
+ static_cast<TPhoneCmdParamAppInfo*>( aCommandParam );
+
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::ActivateAppViewL()" );
+
+ TVwsViewId view( appInfoParam->AppUid(), appInfoParam->ViewUid() );
+ iEikEnv.EikAppUi()->ActivateViewL( view );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ActivateAppViewL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::ActivateAppViewWithCustomMessageL(
+ TPhoneCommandParam* aCommandParam )
+ {
+ TPhoneCmdParamAppInfo* appInfoParam =
+ static_cast<TPhoneCmdParamAppInfo*>( aCommandParam );
+
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::ActivateAppViewWithCustomMessageL()" );
+
+ TVwsViewId view( appInfoParam->AppUid(), appInfoParam->ViewUid() );
+ iEikEnv.EikAppUi()->ActivateViewL(
+ view,
+ appInfoParam->CustomMessageId(),
+ appInfoParam->CustomMessage() );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::CreateConnectionL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::CreateConnectionL()
+ {
+ if ( !iApaLsSession.Handle() )
+ {
+ User::LeaveIfError( iApaLsSession.Connect() );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::LaunchMultimediaSharingL (static)
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::LaunchMultimediaSharingL()
+ {
+ CMusManager* manager = CMusManager::NewLC();
+ manager->StartApplicationL( MultimediaSharing::EMusLiveVideo );
+ CleanupStack::PopAndDestroy( manager );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::LaunchApplicationL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::LaunchApplicationL()
+ {
+ //long 0 launches application defined in KTelAppLaunch key.
+ TInt appId(0);
+ TUid appUid;
+ User::LeaveIfError( CPhoneCenRepProxy::Instance()->GetInt(
+ KCRUidTelPrivateVariation,
+ KTelAppLaunch,
+ appId ) );
+ appUid.iUid = appId;
+
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::LaunchApplicationL appId: %d",
+ appId );
+
+ HBufC* params = HBufC::NewLC( KPhoneMaxParamLength );
+ TPtr ptr = params->Des();
+ User::LeaveIfError( CPhoneCenRepProxy::Instance()->GetString(
+ KCRUidTelPrivateVariation,
+ KTelAppLaunchParam,
+ ptr ) );
+
+ TApaTaskList taskList( iEikEnv.WsSession() );
+ TApaTask task = taskList.FindApp( appUid );
+ if ( task.Exists() )
+ {
+ // Uid is not used.
+ HBufC8* param = CnvUtfConverter::ConvertFromUnicodeToUtf8L( *params );
+ User::LeaveIfError( task.SendMessage( TUid::Uid( 0 ), *param ) );
+ delete param;
+ }
+ else
+ {
+ CreateConnectionL();
+ TThreadId thread;
+ User::LeaveIfError(
+ iApaLsSession.StartDocument(
+ *params,
+ appUid,
+ thread ) );
+ }
+ CleanupStack::PopAndDestroy( params ); // params
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::LaunchHelpApplicationL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::LaunchHelpApplicationL(
+ const TDesC& aHelpCommand )
+ {
+ // Save the help command
+ iHelpCommand.Set( aHelpCommand );
+
+ // Activate Help application
+ HlpLauncher::LaunchHelpApplicationL(
+ CCoeEnv::Static()->WsSession(),
+ iEikEnv.EikAppUi()->AppHelpContextL() );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::HelpContext
+// ---------------------------------------------------------------------------
+//
+EXPORT_C const TDesC& CPhoneViewController::HelpContext()
+ {
+ return iHelpCommand;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetCbaL
+// Set the CBA to the specified setting
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetCbaL( TPhoneCommandParam* aCommandParam )
+ {
+ TPhoneCmdParamInteger* cbaResource =
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam );
+
+ TInt resourceId = cbaResource->Integer();
+
+ iCba->SetCommandSetL( resourceId );
+
+ iCba->DrawDeferred();
+
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetEikonNotifiersDisabled
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetEikonNotifiersDisabled(
+ TPhoneCommandParam* aCommandParam )
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+
+ if ( booleanParam->Boolean() )
+ {
+ if ( !iPriotityChanged )
+ {
+ //Store current ordinal priority.
+ iPrevious = CEikonEnv::Static()->RootWin().OrdinalPriority();
+ iPriotityChanged = ETrue;
+ //Rise window priority in order to get phoneview on top of eikon
+ //notifiers. e.g. Select USB mode notifier is the one which using
+ //eikon notiers.
+ CEikonEnv::Static()->RootWin().SetOrdinalPosition(
+ 0,
+ ECoeWinPriorityAlwaysAtFront-1 );
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::SetEikonNotifiersDisabled()_priority_rise" );
+ }
+ }
+ // enable notifiers, sametime reset previous rootwin priority
+ else if ( iPriotityChanged )
+ {
+ TInt ordinalPos = CEikonEnv::Static()->RootWin().OrdinalPosition();
+ CEikonEnv::Static()->RootWin().SetOrdinalPosition(
+ ordinalPos,
+ iPrevious );
+ iPriotityChanged = EFalse;
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::SetEikonNotifiersDisabled()_priority_reset" );
+ }
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SetEikonNotifiersDisabled(%d)",
+ booleanParam->Boolean() );
+ }
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetGlobalNotifiersDisabledL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetGlobalNotifiersDisabledL(
+ TPhoneCommandParam* aCommandParam )
+ {
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+
+ // Global note always removed if exists when notifiers disabled
+ if ( booleanParam->Boolean() )
+ {
+ ExecuteCommandL( EPhoneViewRemoveGlobalNote );
+ }
+ iKeyLock.EnableSoftNotifications( !booleanParam->Boolean() );
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SetGlobalNotifiersDisabledL(%d)",
+ booleanParam->Boolean() );
+ }
+
+// CPhoneViewController::CancelAllNotications
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::CancelAllNotications()
+ {
+ iKeyLock.CancelAllNotifications();
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::CancelAllNotications()");
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::HandleUpdateBubbleL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::HandleUpdateBubbleL(
+ TInt aCallId,
+ TPhoneCommandParam* aCommandParam )
+ {
+ // Check is the given parameter valid
+ if ( aCommandParam->ParamId() ==
+ TPhoneCommandParam::EPhoneParamIdCallHeaderData )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::HandleUpdateBubble()" );
+
+ TPhoneCmdParamCallHeaderData* callHeaderParam =
+ static_cast<TPhoneCmdParamCallHeaderData*>( aCommandParam );
+ iBubbleWrapper->PrepareCallStateL(
+ aCallId,
+ callHeaderParam->CallState(),
+ callHeaderParam->LabelText(),
+ callHeaderParam->ShortLabelText() );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SoftRejectIsEnabled
+// ---------------------------------------------------------------------------
+//
+TBool CPhoneViewController::SoftRejectIsEnabled() const
+ {
+ // Check if phone is locked
+ const TBool phoneIsLocked =
+ CPhonePubSubProxy::Instance()->Value(
+ KPSUidCoreApplicationUIs,
+ KCoreAppUIsAutolockStatus ) > EAutolockOff;
+
+ if ( phoneIsLocked || IsSecurityCodeQuery() )
+ {
+ // Soft Reject is enabled if the phone is not locked.
+ // Security Code query is checked because in the boot
+ // autolock status value is OFF even when it's actually
+ // ON so we need to do this double checking.
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::IsSecurityCodeQuery
+// ---------------------------------------------------------------------------
+//
+TBool CPhoneViewController::IsSecurityCodeQuery() const
+ {
+ return CPhonePubSubProxy::Instance()->Value(
+ KPSUidStartup,
+ KStartupSecurityCodeQueryStatus ) == ESecurityQueryActive;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::GetNumberFromSpeedDialLocationL
+// ---------------------------------------------------------------------------
+//
+TBool CPhoneViewController::GetNumberFromSpeedDialLocationL(
+ TPhoneCommandParam* aCommandParam )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::GetNumberFromSpeedDialLocationL() ");
+ TPhoneCmdParamSpeedDial* speedDialContent =
+ static_cast<TPhoneCmdParamSpeedDial*>( aCommandParam );
+ TBool retValue( ETrue );
+
+ if ( speedDialContent->Location() != KErrNotFound )
+ {
+ TBuf<KPhoneNumberEntryBufferSize> speedDialNumber;
+ speedDialNumber.Zero(); // empty the string
+
+ // Indicate that the speed dial controller is blocking key
+ // events from the Phone
+ iBlockingDialogIsDisplayed = ETrue;
+
+ CreateSpeedDialControllerL();
+
+ TInt err = iVmbxHandler->GetStraightSpeedDialNumber(
+ speedDialContent->Location(),
+ speedDialNumber );
+
+ // Straight number founded
+ if ( err == KErrNone && speedDialNumber.Length() != 0)
+ {
+ if ( iVmbxHandler->GetMailboxType() == EVmbxVideo )
+ {
+ speedDialContent->SetNumberType( EPhoneNumberTypeVideo );
+ }
+ else
+ {
+ speedDialContent->SetNumberType( EPhoneNumberTypeCS );
+ }
+ }
+ else if ( iVmbxHandler->IsStraightCallToVideoMailBox() &&
+ ( speedDialContent->Location() == KPhoneVideoMbxLocation ||
+ speedDialContent->Location() == KPhoneVoiceMailBoxLocation ))
+ {
+ // Mbx number field of given type was empty and assigning cancelled
+ retValue = EFalse;
+ }
+
+ else if ( speedDialContent->Location() == KPhoneVoiceMailBoxLocation )
+ {
+ // Get the voice mail box type and service ID
+ TUint serviceId( 0 );
+ TInt mailboxType = iVmbxHandler->SelectMailboxTypeL( serviceId );
+ speedDialContent->SetServiceId( serviceId );
+
+ // Get the voice mail box number
+ if ( mailboxType == EVmbxNone )
+ {
+ // Nothing selected from the mailbox selection
+ retValue = EFalse;
+ }
+ else if ( iVmbxHandler->LaunchMbx( mailboxType, speedDialNumber )
+ == KErrNone )
+ {
+ if ( mailboxType == EVmbxVideo )
+ {
+ speedDialContent->SetNumberType( EPhoneNumberTypeVideo );
+ }
+ else if ( mailboxType == EVmbxIP )
+ {
+ speedDialContent->SetNumberType( EPhoneNumberTypeVoip );
+ }
+ else
+ {
+ speedDialContent->SetNumberType( EPhoneNumberTypeCS );
+ }
+ }
+ else
+ {
+ // Mbx number field of given type was empty and assigning cancelled
+ retValue = EFalse;
+ }
+ }
+ else
+ {
+ // Get the number from the speed dial location
+ iSpeedDialController->GetSpeedDialFieldL(
+ speedDialContent->Location(), speedDialNumber );
+ if (speedDialNumber.Length() == 0 )
+ {
+ AssignSpeedDialLocationL( speedDialContent->Location() );
+ // Get the number from the speed dial location
+ iSpeedDialController->GetSpeedDialFieldL(
+ speedDialContent->Location(), speedDialNumber );
+ }
+
+ // If assigned
+ if ( speedDialNumber.Length() )
+ {
+ speedDialContent->SetNumberType(
+ SpeedDialNumberTypeL( speedDialContent->Location() ) );
+ }
+ else
+ {
+ retValue = EFalse;
+ }
+ }
+
+ // Reset the flag
+ iBlockingDialogIsDisplayed = EFalse;
+
+ TPtr* phoneNumber = speedDialContent->PhoneNumber();
+ phoneNumber->Append( speedDialNumber );
+
+ }
+ return retValue;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SpeedDialNumberTypeL
+// ---------------------------------------------------------------------------
+//
+TPhoneNumberType CPhoneViewController::SpeedDialNumberTypeL(
+ TInt aSpeedDialLocation )
+ {
+ __LOGMETHODSTARTEND( EPhoneUIView,
+ "CPhoneViewController::SpeedDialNumberTypeL() ");
+ CPhCntSpeedDialMonitor::TSpdDialFieldInfo fieldInfo;
+
+ TBuf<KPhoneNumberEntryBufferSize> number;
+ TContactItemId itemId = iSpeedDialController->GetSpeedDialFieldL(
+ aSpeedDialLocation,
+ number,
+ fieldInfo );
+
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SpeedDialNumberTypeL - itemId = %d ", itemId );
+
+ return ConvertNumberTypeFromSpeedDialFieldInfo( fieldInfo );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::ConvertNumberTypeFromSpeedDialFieldInfo
+// ---------------------------------------------------------------------------
+//
+TPhoneNumberType CPhoneViewController::ConvertNumberTypeFromSpeedDialFieldInfo(
+ const CPhCntSpeedDialMonitor::TSpdDialFieldInfo& aFieldInfo )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::ConvertNumberTypeFromSpeedDialFieldInfo() ");
+ TPhoneNumberType retValue;
+ switch( aFieldInfo.iNumberType )
+ {
+ case MPhCntMatch::EVideoNumber:
+ retValue = EPhoneNumberTypeVideo;
+ break;
+ case MPhCntMatch::EVoipNumber:
+ retValue = EPhoneNumberTypeVoip;
+ break;
+ case KErrNotFound:
+ retValue = EPhoneNumberTypeNotFound;
+ break;
+ default:
+ retValue = EPhoneNumberTypeCS;
+ break;
+ }
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::ConvertNumberTypeFromSpeedDialFieldInfo - number type = %d ",
+ retValue );
+
+ return retValue;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::AssignSpeedDialLocation
+// ---------------------------------------------------------------------------
+//
+TBool CPhoneViewController::AssignSpeedDialLocation(
+ TPhoneCommandParam* aCommandParam )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView, "CPhoneViewController::AssignSpeedDialLocation( ) ")
+
+ TPhoneCmdParamInteger* locationParam =
+ static_cast<TPhoneCmdParamInteger*>( aCommandParam );
+
+ // Indicate that the contact operation is blocking key
+ // events from the Phone
+ iBlockingDialogIsDisplayed = ETrue;
+ TBool numberAssigned = EFalse;
+ TRAP_IGNORE( numberAssigned = AssignSpeedDialLocationL(locationParam->Integer()) );
+
+ // Reset the flag
+ iBlockingDialogIsDisplayed = EFalse;
+
+ return numberAssigned;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::AssignSpeedDialLocationL
+// ---------------------------------------------------------------------------
+//
+TBool CPhoneViewController::AssignSpeedDialLocationL(
+ TInt aLocation )
+ {
+ CreateSpeedDialControllerL();
+
+ // Assign speed dial location
+ TBuf<KPhoneNumberEntryBufferSize> number;
+
+ const TBool numberAssigned =
+ iSpeedDialController->AssignSpeedDialFieldL( aLocation, number );
+
+ return numberAssigned;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::OpenMessageEditorL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::OpenMessageEditorL(
+ TPhoneCommandParam* aCommandParam )
+ {
+ TPhoneCmdParamMessageEditor* messageEditorParam =
+ static_cast<TPhoneCmdParamMessageEditor*>( aCommandParam );
+
+ //Launch message editor standalone
+ TUid mtmUid = { KSenduiMtmUniMessageUidValue };
+
+ CSendUi* messageEditor = CSendUi::NewL();
+ CleanupStack::PushL( messageEditor );
+
+ // Inform the SendUi to open the message editor. This is not a blocking
+ // dialog so the flag does not need to be set.
+ messageEditor->CreateAndSendMessageL(
+ mtmUid,
+ messageEditorParam->MessageData(),
+ KNullUid,
+ EFalse );
+
+ CleanupStack::PopAndDestroy( messageEditor );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::OpenContactL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::OpenAddToContactL(
+ TInt aCommand,
+ const TDesC& aString )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView, "CPhoneViewController::OpenAddToContactL( ) ")
+
+ TPhoneCmdParamString phoneNumberString;
+
+ HBufC *phoneNumber = HBufC::NewL( KPhoneNumberEntryBufferSize );
+
+ if ( KErrNone == aString.Compare( KNullDesC ) )
+ {
+ // get the number entry contents
+ TPtr ptr( phoneNumber->Des() );
+ phoneNumberString.SetString( &ptr );
+ iBubbleWrapper->GetNumberEntryContent( &phoneNumberString );
+ }
+ else
+ {
+ phoneNumber->Des().Copy( aString );
+ }
+
+ // Indicate that the contact operation is blocking key
+ // events from the Phone
+ iBlockingDialogIsDisplayed = ETrue;
+
+ TRAPD( err,
+ {
+ // Create the contact dialog
+ iContactSaveAddToName = iContactController->CreateSaveAddToNameL();
+
+ // The contact operation may be cancelled if the END key
+ // is pressed. If so, the blocking dialog will be removed.
+ if ( iBlockingDialogIsDisplayed )
+ {
+ // Inform the Contact to open the contacts
+ iContactSaveAddToName->HandlePbkOperationL(
+ *phoneNumber, // TelNum
+ aCommand );//CreateNew/Update
+ }
+ }) //TRAPD
+
+ RemoveAddToContactDialog();
+ delete phoneNumber;
+
+ // Reset the flag
+ iBlockingDialogIsDisplayed = EFalse;
+
+ User::LeaveIfError( err );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::RemovePhoneDialogsL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::RemovePhoneDialogsL()
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::RemovePhoneDialogsL()" );
+ // Remove the note, if necessary
+ iNoteController->DestroyNote();
+
+ // Remove the query, if necessary.
+ // Global query not allowed to destroy in this phase.
+ iQueryController->DestroyQuery();
+
+ // Remove contact dialog.
+ RemoveAddToContactDialog();
+
+ // Dismiss queries from customization, if necessary
+ if ( iCustomization )
+ {
+ iCustomization->RemoveDialog();
+ }
+
+ // Remove speeddial dialogs.
+ if ( iSpeedDialController )
+ {
+ iSpeedDialController->Cancel();
+ }
+
+ if ( iSingleItemFetch )
+ {
+ // Cancel the Single Item Fetch
+ iSingleItemFetch->Delete();
+ }
+
+ if ( iVmbxHandler )
+ {
+ iVmbxHandler->CancelVmbx();
+ }
+
+ if ( iRfsHandler )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::RemovePhoneDialogsL() CPhCntRfsHandler::ERfsCmdCancel" );
+ iRfsHandler->ProcessCommandL( CPhCntRfsHandler::ERfsCmdCancel );
+ delete iRfsHandler;
+ iRfsHandler = NULL;
+ }
+
+ // Remove all blocking dialogs
+ if ( iBlockingDialogIsDisplayed )
+ {
+ // Reset the flag
+ iBlockingDialogIsDisplayed = EFalse;
+
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::RemovePhoneDialogsL() AknDialogShutter::ShutDialogsL" );
+
+ TRAP_IGNORE(
+ AknDialogShutter::ShutDialogsL( iEikEnv ) );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::RemoveAddToContactDialog
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::RemoveAddToContactDialog()
+ {
+ if ( iContactSaveAddToName )
+ {
+ delete iContactSaveAddToName;
+ iContactSaveAddToName = NULL;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::DoConstructContactControllerL
+//
+// Callback function.
+// ---------------------------------------------------------------------------
+//
+TInt CPhoneViewController::DoConstructContactControllerL( TAny* aAny )
+ {
+ CPhoneViewController* viewController =
+ static_cast< CPhoneViewController* >( aAny );
+
+ return viewController->iContactController->ContinueConstructL();
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::UpdateAudioPathOptions
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::UpdateAudioPathOptions(
+ TPhoneCommandParam* aCommandParam )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::UpdateAudioPathOptions()" );
+ TPhoneCmdParamBoolean ihfParam;
+ TPhoneCmdParamBoolean wiredParam;
+ TPhoneCmdParamBoolean btaaParam;
+
+ TPhoneCmdParamAudioOutput* outputParam =
+ static_cast<TPhoneCmdParamAudioOutput*>( aCommandParam );
+
+ ihfParam.SetBoolean(
+ outputParam->AudioOutput() == EPELoudspeaker );
+ wiredParam.SetBoolean(
+ ( outputParam->AudioOutput() == EPEWiredAudioAccessory ) ||
+ ( outputParam->AudioOutput() == EPETTY ) );
+
+ btaaParam.SetBoolean(
+ outputParam->AudioOutput() == EPEBTAudioAccessory );
+
+ // Wired options
+ iMenuController->SetWiredAccFlag( &wiredParam );
+ iToolbarController->SetWiredAccFlag( &wiredParam );
+ iMenuController->SetIhfFlag( &ihfParam );
+ iToolbarController->SetIhfFlag( &ihfParam );
+
+ // btaa menu options
+ iMenuController->SetBTAccFlag( &btaaParam );
+ iToolbarController->SetBTAccFlag( &btaaParam );
+ iAudioController->HandleIhfChange( &ihfParam );
+
+ if ( iButtonsController )
+ {
+ iButtonsController->SetIhfFlag( &ihfParam );
+ iButtonsController->SetWiredAccFlag( &wiredParam );
+ iButtonsController->SetBTAccFlag( &btaaParam );
+ iButtonsController->ReplaceAudioButton();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::UpdateAudioAvailabilityOptions
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::UpdateAudioAvailabilityOptions(
+ TPhoneCommandParam* aCommandParam )
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::UpdateAudioAvailabilityOptions()" );
+
+ TPhoneCmdParamBoolean wiredAvailableParam;
+ TPhoneCmdParamBoolean btAvailableParam;
+
+ TPhoneCmdParamAudioAvailability* outputParam =
+ static_cast<TPhoneCmdParamAudioAvailability*>( aCommandParam );
+
+ wiredAvailableParam.SetBoolean(
+ outputParam->IsWiredAccAvailable() );
+
+ btAvailableParam.SetBoolean(
+ outputParam->IsBTAccAvailable());
+
+ // Wired options
+ iMenuController->SetWiredAccAvailableFlag( &wiredAvailableParam );
+ iToolbarController->SetWiredAccFlag( &wiredAvailableParam );
+
+ // btaa menu options
+ iMenuController->SetBTAccAvailableFlag( &btAvailableParam );
+ iToolbarController->SetBTAccAvailableFlag( &btAvailableParam );
+
+ if ( iButtonsController )
+ {
+ iButtonsController->SetBTAccAvailableFlag( &btAvailableParam );
+ iButtonsController->ReplaceAudioButton();
+ }
+
+ __PHONELOG2(
+ EBasic,
+ EPhoneUIView,
+ "CPhoneViewController::UpdateAudioAvailabilityOptions( BT: (%d), Wired: (%d) ) )",
+ btAvailableParam.Boolean(),
+ wiredAvailableParam.Boolean() );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::LaunchRfsL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::LaunchRfsL( TBool aDeepRfs )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::LaunchRfsL()" );
+ CPhCntRfsHandler::TRfsCommand command;
+ if ( !iRfsHandler )
+ {
+ iRfsHandler = iContactController->CreateRfsHandlerL();
+ }
+
+ if( aDeepRfs )
+ {
+ command = CPhCntRfsHandler::ERfsCmdActivateDeep;
+ }
+ else
+ {
+ command = CPhCntRfsHandler::ERfsCmdActivateNormal;
+ }
+
+ // Indicate that the rfs dialog is blocking key
+ // events from the Phone
+ iBlockingDialogIsDisplayed = ETrue;
+
+ TRAPD( err,
+ {
+ if ( iDialer )
+ {
+ ExecuteCommandL( EPhoneViewClearNumberEntryContent );
+ }
+ else
+ {
+ // Remove number entry
+ ExecuteCommandL( EPhoneViewRemoveNumberEntry );
+ }
+
+ iRfsHandler->ProcessCommandL( command );
+ })
+ delete iRfsHandler;
+ iRfsHandler = NULL;
+
+ iBlockingDialogIsDisplayed = EFalse;
+ User::LeaveIfError( err );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::OpenSoftRejectMessageEditorL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::OpenSoftRejectMessageEditorL(
+ TPhoneCommandParam* aCommandParam )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::OpenSoftRejectMessageEditorL ()" );
+
+ TPhoneCmdParamSfiData* sfiParam =
+ static_cast<TPhoneCmdParamSfiData*>( aCommandParam );
+
+ CMessageData* messageData = CMessageData::NewL();
+ CleanupStack::PushL( messageData );
+
+ // Get message body
+ HBufC* softRejectTxt = HBufC::NewLC( KPhoneSMSLength );
+ TPtr string( softRejectTxt->Des() );
+
+ TInt softRejectDefaultInUseValue = 0;
+ const TInt err = CPhoneCenRepProxy::Instance()->GetInt(
+ KCRUidTelephonySettings,
+ KSettingsSoftRejectDefaultInUse,
+ softRejectDefaultInUseValue );
+
+ if ( err == KErrNone && softRejectDefaultInUseValue )
+ {
+ // Default txt used or not
+ CPhoneCenRepProxy::Instance()->GetString(
+ KCRUidTelephonySettings,
+ KSettingsSoftRejectText,
+ string );
+ }
+ else
+ {
+
+ TParse fp;
+ fp.Set( KPhoneSoftRejectResource, &KDC_RESOURCE_FILES_DIR, NULL );
+ TFileName name( fp.FullName() );
+ // Open soft reject resource file
+ RConeResourceLoader coneResourceLoader( iEikEnv );
+ TInt softRejectResourceError = coneResourceLoader.Open( name );
+ if ( softRejectResourceError != KErrNone )
+ {
+ // Indicate that the soft reject feature cannot be enabled
+ Panic( EPhoneViewErrorInAddingResourceFile );
+ }
+
+ CleanupStack::PopAndDestroy( softRejectTxt );
+ softRejectTxt = StringLoader::LoadLC( R_SOFT_REJECT_DEFAULT_TXT );
+ string.Set( softRejectTxt->Des() );
+ coneResourceLoader.Close();
+ }
+
+ CRichText* text = CRichText::NewL(
+ iEikEnv.SystemParaFormatLayerL(),
+ iEikEnv.SystemCharFormatLayerL());
+ CleanupStack::PushL( text );
+ text->Reset();
+ text->InsertL( 0, string );
+
+ // Set body text
+ messageData->SetBodyTextL( text );
+
+ // store the remote caller's info
+ if ( sfiParam->Name().Length() )
+ {
+ // store both the name and the number
+ messageData->AppendToAddressL(
+ sfiParam->Number(), sfiParam->Name() );
+ }
+ else
+ {
+ // store the number
+ messageData->AppendToAddressL(
+ sfiParam->Number() );
+ }
+
+ // Inform SysAp not to re-activate keyguard even if the call ends.
+ CPhonePubSubProxy::Instance()->ChangePropertyValue(
+ KPSUidCoreApplicationUIs,
+ KCoreAppUIsSoftReject,
+ ECoreAppUIsSoftReject );
+
+ // Launch the Soft Reject message Editor.
+ TPhoneCmdParamMessageEditor messageEditorParam;
+ messageEditorParam.SetMessageData( messageData );
+ OpenMessageEditorL( &messageEditorParam );
+
+ CleanupStack::PopAndDestroy( text );
+ CleanupStack::PopAndDestroy( softRejectTxt );
+ CleanupStack::PopAndDestroy( messageData );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SendMessageL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SendMessageL()
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::SendMessageL()" );
+ // get the number entry contents
+ HBufC *phoneNumber = HBufC::NewLC( KPhoneNumberEntryBufferSize );
+ TPtr ptr( phoneNumber->Des() );
+ TPhoneCmdParamString stringParam;
+ stringParam.SetString( &ptr );
+ iBubbleWrapper->GetNumberEntryContent( &stringParam );
+
+ // Launch the message Editor.
+ TPhoneCmdParamMessageEditor messageEditorParam;
+
+ // create the message data
+ CMessageData* messageData = CMessageData::NewLC();
+ messageData->AppendToAddressL( ptr );
+ messageEditorParam.SetMessageData( messageData );
+
+ if ( !iDialer )
+ {
+ // Remove number entry from screen
+ iPhoneView->SetControl( iBubbleWrapper->Control() );
+ ExecuteCommandL( EPhoneViewRemoveNumberEntry );
+ }
+
+ // Open the message editor
+ OpenMessageEditorL( &messageEditorParam );
+
+ CleanupStack::PopAndDestroy( messageData );
+ CleanupStack::PopAndDestroy( phoneNumber );
+ }
+
+// -----------------------------------------------------------
+// CPhoneViewController::SetStatusPaneVisible
+// -----------------------------------------------------------
+//
+void CPhoneViewController::SetStatusPaneVisible(
+ TPhoneCommandParam* aCommandParam )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::SetStatusPaneVisible()" );
+ TPhoneCmdParamBoolean* booleanParam = static_cast<TPhoneCmdParamBoolean*>(
+ aCommandParam );
+ iStatusPane->StatusPane().MakeVisible( booleanParam->Boolean() );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::UpdateFSW()
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::UpdateFSW()
+ {
+ __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneViewController::UpdateFSW()" );
+ iAknUiServerClient->UpdateTaskList();
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::CreateSpeedDialControllerL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::CreateSpeedDialControllerL()
+ {
+ __LOGMETHODSTARTEND( EPhoneUIView,
+ "CPhoneViewController::CreateSpeedDialControllerL()" );
+ if( !iSpeedDialController )
+ {
+ iSpeedDialController = iContactController->CreateSpeedDialMonitorL();
+ }
+
+ if( !iVmbxHandler )
+ {
+ iVmbxHandler = CPhoneVmbxHandler::NewL();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::IsReplaceAllowed()
+// ---------------------------------------------------------------------------
+//
+TBool CPhoneViewController::IsReplaceAllowed()
+ {
+ __LOGMETHODSTARTEND( EPhoneUIView,
+ "CPhoneViewController::IsReplaceAllowed()");
+
+ TPhoneCmdParamCallStateData callStateData;
+ callStateData.SetCallState( EPEStateConnected );
+ iBubbleWrapper->GetCallIdByState( &callStateData );
+ TInt connected = callStateData.CallId();
+
+ callStateData.SetCallState( EPEStateRinging );
+ iBubbleWrapper->GetCallIdByState( &callStateData );
+ TInt waiting = callStateData.CallId();
+
+ return // both video or
+ (( connected == KVideoTelephonyCallId1 ||
+ connected == KVideoTelephonyCallId2 ) &&
+
+ ( waiting == KVideoTelephonyCallId1 ||
+ waiting == KVideoTelephonyCallId2 )) ||
+
+ // both voice ( including active conference )
+ ((( connected >= KVoiceCallIdFirst &&
+ connected < KEmergencyCallId ) ||
+ connected == KConferenceCallId ) &&
+
+ ( waiting >= KVoiceCallIdFirst &&
+ waiting < KEmergencyCallId ));
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SingleItemFetchL()
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SingleItemFetchL()
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::SingleItemFetchL()" );
+
+ TPhoneCmdParamInteger integerParam;
+ integerParam.SetInteger( EPhoneNewCallFetchTitle );
+
+ // Make sure the dialog is not ended prematurely
+ HandleCommandL(
+ EPhoneViewOpenSingleItemFetchDialog,
+ &integerParam );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetFetchContent
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetFetchContent( TDesC& aFetchContent )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::SetFetchContent()" );
+ iFetchContent = aFetchContent;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::FetchContent
+// ---------------------------------------------------------------------------
+//
+EXPORT_C const TDesC& CPhoneViewController::FetchContent()
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::FetchContent()" );
+ return iFetchContent;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetSingleItemFetchType
+// -----------------------------------------------------------
+//
+void CPhoneViewController::SetSingleItemFetchType( TInt aType )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::SetSingleItemFetchType()" );
+ iSingleItemFetchType = aType;
+ }
+
+// -----------------------------------------------------------
+// CPhoneViewController::SingleItemFetchType
+// -----------------------------------------------------------
+//
+TInt CPhoneViewController::SingleItemFetchType() const
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::SingleItemFetchType()" );
+
+ return iSingleItemFetchType;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SwitchLayoutToFlatStatusPaneL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SwitchLayoutToFlatStatusPaneL( TBool aSwitch )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::SwitchLayoutToFlatStatusPaneL()" );
+
+ if ( aSwitch )
+ {
+ SwapEmptyIndicatorPaneL( ETrue );
+ if ( !Layout_Meta_Data::IsLandscapeOrientation() )
+ {
+ iStatusPane->StatusPane().SwitchLayoutL
+ ( R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT );
+ }
+ else
+ {
+ iStatusPane->StatusPane().SwitchLayoutL
+ ( R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT );
+ }
+ }
+ else
+ {
+ SwapEmptyIndicatorPaneL( EFalse );
+ if ( !Layout_Meta_Data::IsLandscapeOrientation() )
+ {
+ iStatusPane->StatusPane().SwitchLayoutL
+ ( R_AVKON_STATUS_PANE_LAYOUT_IDLE );
+ }
+ else
+ {
+ iStatusPane->StatusPane().SwitchLayoutL
+ ( R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT );
+ }
+ }
+ // ApplyCurrentSettingsL is called whenever statuspane
+ // visibility status or pane layout changes.
+ iStatusPane->StatusPane().ApplyCurrentSettingsL();
+ iStatusPane->StatusPane().DrawNow();
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SwapEmptyIndicatorPaneL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SwapEmptyIndicatorPaneL(
+ const TBool aSwapEmpty )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::SwapEmptyIndicatorPaneL()" );
+ if ( iSecurityMode )
+ {
+ if ( aSwapEmpty )
+ {
+ if ( !iIndiContainer )
+ {
+ iIndiContainer =
+ iStatusPane->CreateEmptyIndicatorContainerL();
+ }
+ //Save previous indicator control
+ iPreviousIndicatorControl =
+ iStatusPane->StatusPane().SwapControlL(
+ TUid::Uid( EEikStatusPaneUidIndic ), iIndiContainer );
+ }
+ else if ( iPreviousIndicatorControl )
+ {
+ //Restore previous indicator control
+ iStatusPane->StatusPane().SwapControlL(
+ TUid::Uid( EEikStatusPaneUidIndic ), iPreviousIndicatorControl );
+ }
+ }
+ else if ( iPreviousIndicatorControl
+ && iIndiContainer
+ && ( iIndiContainer ==
+ iStatusPane->StatusPane().ControlL(
+ TUid::Uid( EEikStatusPaneUidIndic ) ) ) )
+ {
+ //Restore previous indicator control if security mode is not on anymore
+ // and empty indicator pane is still in status pane.
+ iStatusPane->StatusPane().SwapControlL(
+ TUid::Uid( EEikStatusPaneUidIndic ), iPreviousIndicatorControl );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::HandleTransitionEffect
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::HandleTransitionEffect(
+ TPhoneTransEffectType aType, const TUid& aAppUidEffectParam )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::HandleTransitionEffect()" );
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::HandleTransitionEffect aType:(%d)", aType );
+ TInt useEffect(KErrNotFound);
+ switch ( aType )
+ {
+ case EPhoneTransEffectDialerCreate:
+ case EPhoneTransEffectDialerOpen:
+ useEffect = KTouchDialerOpenEffect;
+ break;
+ case EPhoneTransEffectDialerClose:
+ useEffect = KTouchDialerCloseEffect;
+ break;
+ case EPhoneTransEffectAppStartFromDialer:
+ useEffect = AknTransEffect::EApplicationStart;
+ break;
+ case EPhoneTransEffectCallUiAppear:
+ useEffect = KTouchCallUiOpenEffect;
+ break;
+ case EPhoneTransEffectCallUiDisappear:
+ useEffect = KTouchCallUiCloseEffect;
+ break;
+ case EPhoneTransEffectStop:
+ {
+ if ( iEffectOngoing )
+ {
+ GfxTransEffect::EndFullScreen();
+ iEffectOngoing = EFalse;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
+ if ( KErrNotFound < useEffect )
+ {
+ GfxTransEffect::BeginFullScreen(
+ useEffect,
+ TRect(),
+ AknTransEffect::EParameterType,
+ AknTransEffect::GfxTransParam( aAppUidEffectParam,
+ AknTransEffect::TParameter::EActivateExplicitCancel ) );
+ iEffectOngoing = ETrue;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetControltoDialerL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetControltoDialerL()
+ {
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SetControltoDialerL iDialerActive (%d)", iDialerActive );
+
+ SetIncallBubbleVisibility( ETrue );
+
+ if ( !iDialerActive )
+ {
+ iDialerActive = ETrue;
+
+ // Ensure that toolbar and menu commands are up-to-date
+ TBuf<1> temp; // we are only interested if the text is empty or not
+ iDialer->GetTextFromNumberEntry( temp );
+ NumberEntryStateChanged( temp.Length() > 0 );
+
+ // Make dialer view top most
+ iDialerView->DrawableWindow()->SetOrdinalPosition(
+ iPhoneView->DrawableWindow()->OrdinalPosition() );
+
+ // Hide in-call view toolbar
+ iToolbarController->HideToolbar();
+
+ SwitchLayoutToFlatStatusPaneL( ETrue );
+
+ // Don't make dialer view visible before status pane is updated.
+ // This prevents unnecessary resizings.
+ // But do it right away after it. Otherwice a black toolbar area is shortly shown.
+ iDialerView->MakeVisible( ETrue );
+ // Number entry is emptied when dialer is hidden but drawing doesn't
+ // succeed at that point as dialer is hidden first. So must draw
+ // dialer as soon as it becomes visible to prevent the flashing of
+ // number entry (DrawDeferred() isn't fast enough here).
+ iDialerView->DrawNow();
+
+ iPhoneView->DrawableWindow()->SetOrdinalPosition( -1 );
+ iPhoneView->MakeVisible( EFalse );
+
+ // Update control stack
+ iAppui->AddToStackL( iDialerView );
+ iAppui->RemoveFromStack( iPhoneView );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetControltoCallHandlingL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetControltoCallHandlingL()
+ {
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SetControltoCallHandlingL iDialerActive (%d)", iDialerActive );
+
+ SetIncallBubbleVisibility( EFalse );
+ iToolbarController->ShowToolbar();
+ if ( iDialerActive )
+ {
+ iDialerActive = EFalse;
+ // Hide dialer view. Do this before resizing status pane to prevent unnecessary
+ // resizing of dialer components. Hiding dialer view already before showing
+ // phone view might cause screen flickering but tests have proven it doesn't happen.
+ iDialerView->MakeVisible( EFalse );
+
+ SwitchLayoutToFlatStatusPaneL( EFalse );
+
+ // Make call handling view top most
+ iPhoneView->DrawableWindow()->SetOrdinalPosition(
+ iDialerView->DrawableWindow()->OrdinalPosition() );
+ iPhoneView->MakeVisible( ETrue );
+ iPhoneView->DrawNow();
+
+ iDialerView->DrawableWindow()->SetOrdinalPosition( -1 );
+
+ // Update control stack
+ iAppui->AddToStackL( iPhoneView );
+ iAppui->RemoveFromStack( iDialerView );
+
+ iEasyDialingController->HandleCommandL( EEasyDialingCallHandlingActivated );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetDialerControlAndVisibilityL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetDialerControlAndVisibilityL()
+ {
+ __PHONELOG( EBasic, EPhoneUIView,
+ "CPhoneViewController::SetDialerControlAndVisibilityL" );
+
+ if ( iBubbleWrapper->IsNumberEntryUsed() )
+ {
+ if ( !iSendBack )
+ {
+ SetControltoDialerL();
+ // Reset flag to default value.
+ iSendBack = ETrue;
+ }
+ // next active phone app view is dialer.
+ iPhoneView->SetPhoneAppViewToDialer( ETrue );
+ }
+ else
+ {
+ // Reset flag.
+ iPhoneView->SetPhoneAppViewToDialer( EFalse );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::CapturePointerEvents
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::CapturePointerEvents(
+ TPhoneCommandParam* aCommandParam )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::CapturePointerEvents()" );
+ TPhoneCmdParamBoolean* booleanParam = static_cast<TPhoneCmdParamBoolean*>(
+ aCommandParam );
+ iPhoneView->CapturePointerEvents( booleanParam->Boolean() );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::AllowWaitingCallHeaderL
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::AllowWaitingCallHeaderL(
+ TPhoneCommandParam* aCommandParam )
+ {
+ __LOGMETHODSTARTEND(EPhoneUIView,
+ "CPhoneViewController::AllowWaitingCallHeaderL()" );
+
+ TPhoneCmdParamBoolean* booleanParam =
+ static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
+
+ // Phone in foreground and control is in dialer ->
+ //do not show waiting call header.
+ if ( ( ( ApplicationWindowGroupId() ==
+ ForegroundApplicationWindowGroupId() ) &&
+ ( iDialerActive ) ) )
+ {
+ booleanParam->SetBoolean( EFalse );
+ }
+ // Phone isnt in foreground but since control is in dialer and save add to
+ // name service is active -> do not show waiting call header.
+ else if ( ( ( ApplicationWindowGroupId() !=
+ ForegroundApplicationWindowGroupId() ) &&
+ ( iDialerActive ) && iContactSaveAddToName ) )
+ {
+ booleanParam->SetBoolean( EFalse );
+ }
+ // If Phone is in foreground and control is in bubble we need to check
+ // query status -> if query is active do not show waiting call header, if
+ // query is not active then show waiting call header.
+ else if ( ( ( ApplicationWindowGroupId() ==
+ ForegroundApplicationWindowGroupId() ) &&
+ ( !iDialerActive ) ) )
+ {
+ TPhoneCmdParamBoolean isQueryDisplayed;
+ // Check is query displayed
+ ExecuteCommandL( EPhoneViewIsQuery, &isQueryDisplayed );
+
+ if ( isQueryDisplayed.Boolean() )
+ {
+ booleanParam->SetBoolean( EFalse );
+ }
+ else
+ {
+ booleanParam->SetBoolean( ETrue );
+ }
+ }
+ // Phone isnt in foreground but since control is in bubble and single item
+ // service is active(note! iBlockingDialogIsDisplayed must be true if it
+ // not then iSingleItemFetch is not active anymore) -> do not show waiting
+ // call header.
+ else if ( ( ( ApplicationWindowGroupId() !=
+ ForegroundApplicationWindowGroupId() ) &&
+ ( !iDialerActive ) &&
+ ( iSingleItemFetch && iBlockingDialogIsDisplayed ) ) )
+ {
+ booleanParam->SetBoolean( EFalse );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::IsDtmfDialerActive
+// ---------------------------------------------------------------------------
+//
+TBool CPhoneViewController::IsDtmfDialerActive() const
+ {
+ TBool ret =
+ ( iDialer && iDtmfDialerController &&
+ iDialer->Controller() == iDtmfDialerController );
+ return ret;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::IsCustomDialerActive
+// ---------------------------------------------------------------------------
+//
+TBool CPhoneViewController::IsCustomDialerActive() const
+ {
+ TBool ret = EFalse;
+ if ( iDialer )
+ {
+ MPhoneDialerController* curController = iDialer->Controller();
+ ret = ( curController &&
+ curController != iDialerController &&
+ curController != iDtmfDialerController );
+ }
+ return ret;
+ }
+
+// -----------------------------------------------------------
+// CPhoneViewController::CanTransEffectBeUsed
+// -----------------------------------------------------------
+//
+TBool CPhoneViewController::CanTransEffectBeUsed(
+ TPhoneTransEffectType aType )
+ {
+ TBool okToUseEffect( EFalse );
+ TBool isPhoneForeground = iAppui->IsForeground();
+ TBool isIdleInForeground =
+ ForegroundApplicationWindowGroupId() == IdleWindowGroupId() ?
+ ETrue : EFalse;
+ if ( isPhoneForeground &&
+ IsOkToUseThisTypeOfEffectInsidePhoneApp( aType ) )
+ {
+ okToUseEffect = ETrue;
+ }
+ /* In case transition is from idle to dialer or to incoming call
+ show transition effects as well. */
+ else if ( isIdleInForeground &&
+ ( aType == EPhoneTransEffectDialerOpen ||
+ aType == EPhoneTransEffectCallUiAppear ) )
+ {
+ okToUseEffect = ETrue;
+ }
+ /* isPhoneForeground/isIdleInForeground are false
+ when call is created from some other then phone app for example logs or from phonebook*/
+ else if ( !isPhoneForeground &&
+ !isIdleInForeground &&
+ ( aType == EPhoneTransEffectDialerOpen ||
+ aType == EPhoneTransEffectCallUiAppear ) )
+ {
+ okToUseEffect = ETrue;
+ }
+ return okToUseEffect;
+ }
+
+// -----------------------------------------------------------
+// CPhoneViewController::IsOkToUseThisTypeOfEffectInsidePhoneApp
+// -----------------------------------------------------------
+//
+TBool CPhoneViewController::IsOkToUseThisTypeOfEffectInsidePhoneApp(
+ TPhoneTransEffectType aType )
+ {
+ TBool okToUse(EFalse);
+ switch ( aType )
+ {
+ case EPhoneTransEffectDialerCreate:
+ case EPhoneTransEffectDialerOpen:
+ okToUse = !iDialerActive;
+ break;
+ case EPhoneTransEffectAppStartFromDialer:
+ okToUse = iDialerActive;
+ break;
+ /* No need to check dialer activity below because effects are
+ common to callhandling/dialer */
+ case EPhoneTransEffectDialerClose:
+ case EPhoneTransEffectCallUiAppear:
+ case EPhoneTransEffectCallUiDisappear:
+ okToUse = ETrue;
+ break;
+ default:
+ break;
+ }
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::IsOkToUseThisTypeOfEffectInsidePhoneApp(%d)",
+ okToUse );
+ return okToUse;
+ }
+
+// -----------------------------------------------------------
+// CPhoneViewController::BeginTransEffectForAppStartFromDialerLC
+// -----------------------------------------------------------
+//
+void CPhoneViewController::BeginTransEffectForAppStartFromDialerLC(
+ const TUid& aAppUid )
+ {
+ TPhoneCmdParamTransEffect effectParam;
+ effectParam.SetType( EPhoneTransEffectAppStartFromDialer );
+ effectParam.SetAppUid( aAppUid );
+
+ ExecuteCommand( EPhoneViewBeginTransEffect, &effectParam );
+
+ TCleanupItem operation( EffectCleanup, this );
+ CleanupStack::PushL( operation );
+ }
+
+// -----------------------------------------------------------
+// CPhoneViewController::EndTransEffect
+// -----------------------------------------------------------
+//
+void CPhoneViewController::EndTransEffect()
+ {
+ CleanupStack::PopAndDestroy(); // Call EffectCleanup
+ }
+
+// -----------------------------------------------------------------------------
+// CPhoneViewController::EffectCleanup
+// -----------------------------------------------------------------------------
+//
+void CPhoneViewController::EffectCleanup(TAny* aThis )
+ {
+ TPhoneCmdParamTransEffect effectParam;
+ effectParam.SetType( EPhoneTransEffectStop );
+
+ static_cast<CPhoneViewController*>( aThis )->ExecuteCommand(
+ EPhoneViewEndTransEffect, &effectParam );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetNeedToReturnToForegroundAppAfterCall
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetNeedToReturnToForegroundAppAfterCall(
+ TPhoneCommandParam* aCommandParam )
+ {
+ TPhoneCmdParamBoolean* booleanParam = static_cast<TPhoneCmdParamBoolean*>(
+ aCommandParam );
+
+ iNeedToReturnToForegroundAppAfterCall = booleanParam->Boolean();
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SetNeedToReturnToForegroundAppAfterCall(%d)",
+ iNeedToReturnToForegroundAppAfterCall );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::GetNeedToReturnToForegroundAppAfterCallL
+// ---------------------------------------------------------------------------
+//
+TBool CPhoneViewController::GetNeedToReturnToForegroundAppAfterCallL()
+ {
+ // Check that previous app still exists. It might be for example
+ // add to contact - dialog that is allready destroyed or user has closed
+ // app using task swapper.
+ if( KErrNotFound == FindAppByWgIDL( iPrevForegroundAppWg ) )
+ {
+ iNeedToReturnToForegroundAppAfterCall = EFalse;
+ }
+ return iNeedToReturnToForegroundAppAfterCall;
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::AllowInCallBubbleInSpecialCases
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::AllowInCallBubbleInSpecialCases()
+ {
+ // this method can be used for special cases like dialer
+
+ if( iDialerActive )
+ {
+ SetIncallBubbleVisibility( ETrue );
+ }
+ else
+ {
+ SetIncallBubbleVisibility( EFalse );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SetIncallBubbleVisibility
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SetIncallBubbleVisibility( TBool aVisible )
+ {
+ __PHONELOG1( EBasic, EPhoneUIView,
+ "CPhoneViewController::SetIncallBubbleVisibility(%d)",
+ aVisible );
+
+ TRAP_IGNORE( iIncallBubble->SetIncallBubbleAllowedInUsualL( aVisible ) );
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SkinContentChanged
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SkinContentChanged()
+ {
+ __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneViewController::SkinContentChanged()" );
+ iPhoneView->DrawNow();
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SkinConfigurationChanged
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SkinConfigurationChanged( const TAknsSkinStatusConfigurationChangeReason /*aReason*/ )
+ {
+ __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneViewController::SkinConfigurationChanged()" );
+ iPhoneView->DrawNow();
+ }
+
+// ---------------------------------------------------------------------------
+// CPhoneViewController::SkinPackageChanged
+// ---------------------------------------------------------------------------
+//
+void CPhoneViewController::SkinPackageChanged( const TAknsSkinStatusPackageChangeReason /*aReason*/ )
+ {
+ __LOGMETHODSTARTEND( EPhoneUIView, "CPhoneViewController::SkinPackageChanged()" );
+ iPhoneView->DrawNow();
+ }
+// End of File