FCL/sf/app/phone: comparison phoneapp/phoneuiview/src/cphoneviewcontroller.cpp

equal deleted inserted replaced

-:3c221667e687
+:94dc1107e8b2
 iStatusPane->StatusPane().SetDimmed( iSecurityMode );
 iAppui = (CAknAppUi*)iEikEnv.EikAppUi();
 iCba = iEikEnv.AppUiFactory()->Cba();
-	iPhoneView = CPhoneView::NewL( aRect, *iCba, this );
+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
 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 );
 }
 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
 CPhoneViewController::~CPhoneViewController()
 {
 __LOGMETHODSTARTEND( EPhoneUIView,
 "CPhoneViewController::~CPhoneViewController()" );
 iSkinServerSession.Close();
 delete iButtonsController;
 delete iDialerController;
 delete iToolbarController;
 iKeyLock.Close();
 delete iApplicationExit;
 {
 iAppui->RemoveFromStack( iDialerView );
 }
 delete iDialerView;
 }
-	delete iEasyDialingController;
+delete iEasyDialingController;
-	delete iDtmfDialerController;
+delete iDtmfDialerController;
 delete iDialer;
 if ( iSingleItemFetch )
 {
 delete iSingleItemFetch;
 iSingleItemFetch = NULL;
 RemoveAddToContactDialog();
 //    delete iStatusPane; <-- CCoeStatic are destroyed outside application
 iApaLsSession.Close();
 delete iIncallBubble;
 }
 // ---------------------------------------------------------
 // CPhoneViewController::PhoneView
 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;
 break;
 case EPhoneViewRemovePhoneDialogs:
 RemovePhoneDialogsL();
 break;
 case EPhoneViewRemoveAllCallHeaders:
 iBubbleWrapper->RemoveAllCallHeadersL();
 break;
 case EPhoneViewMuteRingToneOnAnswer:
 break;
 case EPhoneViewStopRingTone:
 iRingingTonePlayerAO->StopPlaying();
 break;
 case EPhoneViewMuteRingTone:
 iRingingTonePlayerAO->MuteRingingTone();
 break;
 case EPhoneViewAddToConference:
 }
 case EPhoneViewHideToolbar:
 {
 iToolbarController->HideToolbar();
 }
 break;
 case EPhoneViewLaunchMultimediaSharing:
 {
 LaunchMultimediaSharingL();
 }
 // Pass the key event to number entry
 iBubbleWrapper->HandleKeyEventL( aCommandParam );
 break;
 case EPhoneViewUpdateContextMenu:
 {
 iMenuController->SetContextMenu( aCommandParam );
-} break;
+}
+break;
 case EPhoneViewGetLocalizedNumberFromEntry:
 iBubbleWrapper->GetLocalizedNumberEntryContent( aCommandParam );
 break;
 case EPhoneViewUpdateIncallIndicator:
 iMenuController->CloseMenuBar();
 iIncallIndicator->Update( aCommandParam );
 iMenuController->SetCallInProgressFlag( aCommandParam );
 iToolbarController->SetCallInProgressFlag( aCommandParam );
 break;
 case EPhoneViewStartCapturingKey:
 iKeyCaptureController->StartCapturingKey( aCommandParam );
 break;
 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 EPhoneViewSetConferenceAndWaitingVideo:
 {
 TPhoneCmdParamBoolean*  booleanParam =
 static_cast<TPhoneCmdParamBoolean*>( aCommandParam );
 iMenuController->SetConferenceAndWaitingVideoFlag( booleanParam->Boolean() );
-			}
+}
 break;
 default:
 __PHONELOG( EBasic, EPhonePhoneapp,
 "CPhoneViewController::ExecuteCommandL -> UnKnownMessage !!! " );
 break;
 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 ) );
 }
 case EPhoneViewGetTitlePaneIsVisibleStatus:
 viewResponse = iStatusPane->IsTitlePaneVisible( *this ) ?
 EPhoneViewResponseSuccess :
 EPhoneViewResponseFailed;
 break;
 case EPhoneViewIsMenuBarVisible:
 viewResponse = iMenuController->IsMenuBarVisible() ?
 EPhoneViewResponseSuccess :
 EPhoneViewResponseFailed;
 break;
 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 :
 viewResponse = iQueryController->IsDTMFQueryVisible() ?
 EPhoneViewResponseSuccess :
 EPhoneViewResponseFailed;
 }
 break;
 case EPhoneViewIsConferenceInExpandedMode:
 viewResponse = iBubbleWrapper->IsConferenceInExpandedMode() ?
 EPhoneViewResponseSuccess :
 EPhoneViewResponseFailed;
 break;
 ExecuteCommandL( EPhoneViewCreateNumberEntry, &booleanParam );
 }
 // Set Number Entry CBA
 TPhoneCmdParamInteger integerParam;
 if ( iSecurityMode )
-	{
+{
 iNoteController->DestroyNote();
 integerParam.SetInteger(
 CPhoneMainResourceResolver::Instance()->
-		ResolveResourceID( EPhoneEmergencyModeNoteCBA ) );
+ResolveResourceID( EPhoneEmergencyModeNoteCBA ) );
-	}
+}
 else
-	{
+{
-	integerParam.SetInteger(
+integerParam.SetInteger(
-		CPhoneMainResourceResolver::Instance()->
+CPhoneMainResourceResolver::Instance()->
-		ResolveResourceID( EPhoneNumberAcqCBA ) );
+ResolveResourceID( EPhoneNumberAcqCBA ) );
-	}
+}
 ExecuteCommandL( EPhoneViewUpdateCba, &integerParam );
 // Set flag to false because dialler is set to open status.
 iPhoneView->SetPhoneAppViewToDialer( EFalse );
 }
 break;
 if ( IsDtmfDialerActive() )
 {
 static_cast<MEikCommandObserver*>( CEikonEnv::Static()->EikAppUi() )
 ->ProcessCommandL( EPhoneDtmfDialerExit );
 }
 else if ( iCustomization &&
 IsCustomDialerActive() )
 {
 iCustomization->HandleCommandL(
 *this, EPhoneViewOpenCallHandling, NULL );
 }
 else
 {
 SetControltoCallHandlingL();
 case EPhoneViewShowToolbar:
 {
 iToolbarController->ShowToolbar();
 }
 break;
+case EPhoneViewIsDisplayingMenuOrDialog:
+{
+viewResponse = iEikEnv.EikAppUi()->IsDisplayingMenuOrDialog() ?
+EPhoneViewResponseSuccess :
+EPhoneViewResponseFailed;
+}
+break;
 default:
 viewResponse = EPhoneViewResponseFailed;
 __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneViewController::HandleCommandL -> UnKnownMessage !!! ");
 break;
 }
 TPhoneCommandParam* aCommandParam )
 {
 __PHONELOGVIEWMSG( aCmdId, 0 );
 TPhoneViewResponseId viewResponse = EPhoneViewResponseSuccess;
 TInt err;
 switch ( aCmdId )
 {
 case EPhoneViewSendKeyEventToNumberEntry:
 {
 // Pass the key event to the Bubble Manager (ignore key
 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(
 {
 __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 )
 {
 {
 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,
+__PHONELOG1( EBasic, EPhoneUIView,
-"CPhoneViewController::SetSecurityMode Mode = (%d)", aIsEnabled );
+"CPhoneViewController::HandleSecurityModeChanged Mode = (%d)", aIsEnabled );
-iToolbarController->DimToolbar( aIsEnabled );
-	iPhoneView->SetSecurityMode( aIsEnabled );
+TBool emergencyCallOngoing = IsEmergencyCallOngoing();
-	iMenuController->SetSecurityMode( aIsEnabled );
+// Don't undim toolbar if emergency call is ongoing
-	TBool securityModeChanged = ( iSecurityMode != aIsEnabled );
+if ( !emergencyCallOngoing )
+{
-	iSecurityMode = aIsEnabled;
+iToolbarController->DimToolbar( aIsEnabled );
+}
-	if ( iDialer )
+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 )
 {
 TRAP_IGNORE( easyDialing->SetInputL( buf ) );
 }
 }
 }
 iDialer->RelayoutAndDraw();
-// also update cba if security mode changes while dialer is open
+// Don't update cba here if emergency call is ongoing
-TPhoneCmdParamInteger integerParam;
+if ( !emergencyCallOngoing )
-if ( aIsEnabled )
+{
-{
+// also update cba if security mode changes while dialer is open
-iNoteController->DestroyNote();
+TPhoneCmdParamInteger integerParam;
-integerParam.SetInteger( CPhoneMainResourceResolver::Instance()->
+if ( aIsEnabled )
-ResolveResourceID( EPhoneEmergencyModeNoteCBA ) );
+{
-}
+iNoteController->DestroyNote();
-else
+integerParam.SetInteger( CPhoneMainResourceResolver::Instance()->
-{
+ResolveResourceID( EPhoneEmergencyModeNoteCBA ) );
-integerParam.SetInteger( CPhoneMainResourceResolver::Instance()->
+}
-ResolveResourceID( EPhoneNumberAcqCBA ) );
+else
-}
+{
-TRAP_IGNORE( ExecuteCommandL( EPhoneViewUpdateCba, &integerParam ) );
+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.SetKeyCode( EKeyApplication0 );
 appKeyCaptureParam.SetCaptureType( EPhoneKeyAllEvents );
 iKeyCaptureController->StopCapturingKey( &appKeyCaptureParam );
 }
-	}
+}
 // ---------------------------------------------------------------------------
 // CPhoneViewController::IdleAppUid
 // ---------------------------------------------------------------------------
 //
 //
 void CPhoneViewController::NumberEntryStateChanged( TBool aEntryHasText )
 {
 iMenuController->SetNumberEntryEmptyFlag( !aEntryHasText );
 iBubbleWrapper->HandleNumberEntryChanged();
-ExecuteCommandL( EPhoneViewUpdateToolbar );
+TRAP_IGNORE( ExecuteCommandL( EPhoneViewUpdateToolbar ) );
 }
 // ---------------------------------------------------------------------------
 // CPhoneViewController::GetBlockingDialogIsDisplayed
 // ---------------------------------------------------------------------------
 {
 iPrevForegroundAppWg = ForegroundApplicationWindowGroupId();
 CAknSgcClient::MoveApp( phoneApp.WgId(), ESgcMoveAppToForeground );
 __PHONELOG1( EBasic, EPhoneUIView,
 "CPhoneViewController::BringPhoneAppToForeground - Previous App WG ID: %d",
 iPrevForegroundAppWg );
 }
 }
 // ---------------------------------------------------------------------------
 // CPhoneViewController::SetTopApplicationL
 static_cast<TPhoneCmdParamInteger*>( aCommandParam );
 TInt resourceId = cbaResource->Integer();
 iCba->SetCommandSetL( resourceId );
 iCba->DrawDeferred();
 }
 // ---------------------------------------------------------------------------
 // CPhoneViewController::SetEikonNotifiersDisabled
 // ---------------------------------------------------------------------------
 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
+// Security Code query is checked because in the boot
-		// autolock status value is OFF even when it's actually
+// autolock status value is OFF even when it's actually
-		// ON so we need to do this double checking.
+// ON so we need to do this double checking.
 return EFalse;
 }
 return ETrue;
 }
 __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 );
 // ---------------------------------------------------------------------------
 // CPhoneViewController::ConvertNumberTypeFromSpeedDialFieldInfo
 // ---------------------------------------------------------------------------
 //
 TPhoneNumberType CPhoneViewController::ConvertNumberTypeFromSpeedDialFieldInfo(
-CPhCntSpeedDialMonitor::TSpdDialFieldInfo aFieldInfo )
+const CPhCntSpeedDialMonitor::TSpdDialFieldInfo& aFieldInfo )
 {
 __LOGMETHODSTARTEND(EPhoneUIView,
 "CPhoneViewController::ConvertNumberTypeFromSpeedDialFieldInfo() ");
 TPhoneNumberType retValue;
 switch( aFieldInfo.iNumberType )
 // ---------------------------------------------------------------------------
 //
 TBool CPhoneViewController::AssignSpeedDialLocationL(
 TInt aLocation )
 {
 CreateSpeedDialControllerL();
 // Assign speed dial location
 TBuf<KPhoneNumberEntryBufferSize> number;
 const TBool numberAssigned =
 //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,
 //
 void CPhoneViewController::CreateSpeedDialControllerL()
 {
 __LOGMETHODSTARTEND( EPhoneUIView,
 "CPhoneViewController::CreateSpeedDialControllerL()" );
 if( !iSpeedDialController )
 {
 iSpeedDialController = iContactController->CreateSpeedDialMonitorL();
 }
 if( !iVmbxHandler )
 // -----------------------------------------------------------
 // CPhoneViewController::SingleItemFetchType
 // -----------------------------------------------------------
 //
 TInt CPhoneViewController::SingleItemFetchType() const
 {
 __LOGMETHODSTARTEND(EPhoneUIView,
 "CPhoneViewController::SingleItemFetchType()" );
 return iSingleItemFetchType;
 }
 // ---------------------------------------------------------------------------
 // CPhoneViewController::SwitchLayoutToFlatStatusPaneL
 // ---------------------------------------------------------------------------
 //
 break;
 }
 case EPhoneTransEffectAppStartFromDialer:
 {
 GfxTransEffect::BeginFullScreen(
 AknTransEffect::EApplicationStart,
 TRect(),
 AknTransEffect::EParameterType,
 AknTransEffect::GfxTransParam( aAppUidEffectParam,
 AknTransEffect::TParameter::EActivateExplicitCancel ) );
 iEffectOngoing = ETrue;
 }
 break;
 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.
 // 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 );
 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() );
 iDialerView->DrawableWindow()->SetOrdinalPosition( -1 );
 // Update control stack
 iAppui->AddToStackL( iPhoneView );
 iAppui->RemoveFromStack( iDialerView );
 iEasyDialingController->HandleCommandL( EEasyDialingCallHandlingActivated );
 }
 }
 // ---------------------------------------------------------------------------
 // CPhoneViewController::IsDtmfDialerActive
 // ---------------------------------------------------------------------------
 //
 TBool CPhoneViewController::IsDtmfDialerActive() const
 {
 TBool ret =
 ( iDialer && iDtmfDialerController &&
 iDialer->Controller() == iDtmfDialerController );
 return ret;
 }
 // ---------------------------------------------------------------------------
 {
 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 isForeground = iAppui->IsForeground();
 // Check whether the idle is on foreground
 TBool idleInFore = ForegroundApplicationWindowGroupId() ==  IdleWindowGroupId() ?
 ETrue : EFalse;
 if ( isForeground && // Newer run effect if not at front
 ( ( aType == EPhoneTransEffectDialerCreate && !iDialerActive ) ||
 ( aType == EPhoneTransEffectDialerOpen && !iDialerActive &&
 iBubbleWrapper->IsNumberEntryUsed() ) ||
 ( aType == EPhoneTransEffectDialerClose && iDialerActive ) ) )
 {
 okToUseEffect = ETrue;
 }
 // In case transition is from idle to dialer show transition effects as well.
 else if ( idleInFore && !iDialerActive &&
 aType == EPhoneTransEffectDialerOpen )
 {
 okToUseEffect = ETrue;
 }
 else if ( isForeground && iDialerActive &&
 aType == EPhoneTransEffectAppStartFromDialer )
 {
 okToUseEffect = ETrue;
 }
 return okToUseEffect;
 }
 // -----------------------------------------------------------
 // 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::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
 // ---------------------------------------------------------------------------

branch	RCL_3
changeset 57	94dc1107e8b2
parent 44	3c221667e687
child 58	40a3f856b14d