diff -r 73a1feb507fb -r bc78a40cd63c mmsharing/mmshui/src/musuigeneralview.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmsharing/mmshui/src/musuigeneralview.cpp Wed Sep 01 12:31:01 2010 +0100 @@ -0,0 +1,930 @@ +/* +* Copyright (c) 2005 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: Mus Applications Event Observer Interface +* +*/ + + + +#include "musuigeneralview.h" +#include "musui.hrh" +#include "musuiappui.h" // Application UI class +#include "musuistatuspanehandler.h" +#include "musuieventcontroller.h" +#include "musuiviewcontainer.h" +#include "musuidefinitions.h" +#include "mussettings.h" +#include "mussettingskeys.h" +#include "muslogger.h" // debug logging +#include "musuiactivetimer.h" +#include "musuibackgroundviewcontainer.h" +#include +#include + +#include // Eikon enviroment +#include +#include +#include +#include +#include +#include +#include + +const TInt KBackgroundIntervalForClose = 10 * 1000 * 1000; // 10s +const TInt KMusFgBgEventFiltering = 200 * 1000; // 200 ms + +// ----------------------------------------------------------------------------- +// EPOC two-phased constructor +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::ConstructL() + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::ConstructL" ); + + BaseConstructL( R_MUSUI_VIEW ); + TInt toolbarId = R_MUS_TOOLBAR; + if (!AknLayoutUtils::PenEnabled()) + { + toolbarId = R_MUS_TOOLBAR_NONTOUCH; + } + CreateAndSetToolbarL(toolbarId); + + // check if operator specific functionality is needed + iOperatorSpecificFunctionality = + ( MultimediaSharingSettings::OperatorVariantSettingL() == + MusSettingsKeys::EOperatorSpecific ); + + iIncallBubble = CAknIncallBubble::NewL(); + iSessionEndTimer = CMusUiActiveTimer::NewL( this ); + + iFgBgTimer = CMusUiActiveTimer::NewL( this ); + + if( MUS_NO_TOOLBAR ) + { + MUS_LOG( "mus: [MUSUI ] Operator variant hides toolbar!" ); + Toolbar()->SetToolbarVisibility( EFalse ); + Toolbar()->MakeVisible(EFalse); + } + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::ConstructL" ); + } + + +// ----------------------------------------------------------------------------- +// Destructor +// ----------------------------------------------------------------------------- +// +CMusUiGeneralView::~CMusUiGeneralView() + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::~CMusUiGeneralView" ); + + delete iSessionEndTimer; + + delete iFgBgTimer; + + if ( iIncallBubble ) + { + TRAP_IGNORE( iIncallBubble->SetIncallBubbleAllowedInUsualL( ETrue ) ) + } + delete iIncallBubble; + + /* Remove and delete background container */ + if ( iBackgroundContainer ) + { + AppUi()->RemoveFromViewStack( *this, iBackgroundContainer ); + } + delete iBackgroundContainer; + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::~CMusUiGeneralView" ); + } + + +// ----------------------------------------------------------------------------- +// Fetches a pointer to the application's AppUi class ( CMusUiAppUi ) +// ----------------------------------------------------------------------------- +// +CMusUiAppUi* CMusUiGeneralView::MusAppUi() const + { + MUS_LOG( "mus: [MUSUI ] CMusUiGeneralView::MusAppUi()" ); + return static_cast( iEikonEnv->AppUi() ); + } + + + +// ----------------------------------------------------------------------------- +// To be overridden in subclasses +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::HandleKeyUpEvent( TInt /*aKeyCode*/ ) + { + // NOP + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::SetToolbarVisibility( TBool aVisible ) + { + MUS_LOG1( "mus: [MUSUI ] -> CMusUiGeneralView::SetToolbarVisibility: %d", + aVisible ); + + if( MUS_NO_TOOLBAR ) + { + MUS_LOG( "mus: [MUSUI ] Operator variant hides toolbar!" ); + Toolbar()->SetToolbarVisibility( EFalse ); + Toolbar()->MakeVisible(EFalse); + return; + } + + // Show toolbar only after established session and before of exit procedure + if ( aVisible && + EventController() && + !EventController()->ExitOccured() && + EventController()->ConnectionEstablished() ) + { + MUS_LOG( "mus: [MUSUI ] setting toolbar visible" ); + + if ( SharingContainer().WaitDialogShown() ) + { + // Cannot show toolbar at the moment as it would go over the dialog. + // Instead, request container to set visibility once dialog + // is dismissed. + SharingContainer().RequestToolbarVisibilityOnceDialogDismissed( this ); + } + else + { + Toolbar()->SetToolbarVisibility( ETrue ); + Toolbar()->MakeVisible(ETrue); + } + } + else if ( !aVisible && EventController()->ExitOccured() ) + { + Toolbar()->SetToolbarVisibility( EFalse ); + Toolbar()->MakeVisible(EFalse); + } + else + { + MUS_LOG( "mus: [MUSUI ] We do not set fixed toolbar invisible" ); + if (!AknLayoutUtils::PenEnabled()) + { + Toolbar()->SetToolbarVisibility( EFalse ); + Toolbar()->MakeVisible(EFalse); + } + + SharingContainer().RequestToolbarVisibilityOnceDialogDismissed( NULL ); + } + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::SetToolbarVisibility" ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::AsyncQueryDialogAcceptedL( TBool aAccepted ) + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::AsyncQueryDialogAcceptedL" ); + + EventControllerL().AsyncQueryDialogAcceptedL( aAccepted ); + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::AsyncQueryDialogAcceptedL" ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +TInt CMusUiGeneralView::FocusedToolbarItem() const + { + MUS_LOG( "mus: [MUSUI ] <-> CMusUiGeneralView::FocusedToolbarItem" ); + return Toolbar()->FocusedItem(); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::DynInitToolbarL( TInt /*aResourceId*/, + CAknToolbar* /*aToolbar*/ ) + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::DynInitToolbarL" ); + + Toolbar()->SetWithSliding( EFalse ); + + // Hide items according to states of speaker and microphone: + + Toolbar()->HideItem( EventControllerL().IsMicMutedL() ? + EMusuiCmdToolbarMute : + EMusuiCmdToolbarUnmute, + ETrue, + ETrue ); + + TBool loudSpeakerEnabled( EventControllerL().IsLoudSpeakerEnabled() ); + + Toolbar()->HideItem( loudSpeakerEnabled ? + EMusuiCmdToolbarSpeakerOn : + EMusuiCmdToolbarSpeakerOff, + ETrue, + ETrue ); + + // Dim audio routing button if audio routing cannot be changed + // or when some button is selected + TBool dimAudioRouting( iToolbarItemSelected || + !EventControllerL().AudioRoutingCanBeChanged() ); + + Toolbar()->SetItemDimmed( loudSpeakerEnabled ? + EMusuiCmdToolbarSpeakerOff : + EMusuiCmdToolbarSpeakerOn, + dimAudioRouting, + ETrue ); + + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::DynInitToolbarL" ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::OfferToolbarEventL( TInt aCommand ) + { + MUS_LOG1( "mus: [MUSUI ] -> CMusUiGeneralView::OfferToolbarEventL: %d", + aCommand ); + EventControllerL().OfferToolbarEventL( aCommand ); + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::OfferToolbarEventL" ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +TBool CMusUiGeneralView::ShowWaitDialogL( const TDesC& aPrompt, + TInt aTimerInSeconds, + TInt aExpirationMessageResourceId ) + { + MUS_LOG_TDESC( "mus: [MUSUI ] -> CMusUiGeneralView::ShowWaitDialogL: ", + aPrompt ); + + TBool retVal = SharingContainer().RunWaitDialogL( + aPrompt, + aTimerInSeconds, + aExpirationMessageResourceId ); + + MUS_LOG1( "mus: [MUSUI ] <- CMusUiGeneralView::ShowWaitDialogL: retVal = %d", + retVal ) + + return retVal; + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::DismissWaitDialogL( TBool aReturnValue ) + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::DismissWaitDialogL" ); + + SharingContainer().DismissWaitDialogL( aReturnValue ); + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::DismissWaitDialogL" ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::SetWaitDialogCallbackL( MProgressDialogCallback* aCallback ) + { + SharingContainer().SetWaitDialogCallbackL( aCallback ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::ShowStatusPaneTitleL() + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::ShowStatusPaneTitleL" ); + + MusAppUi()->MusStatusPane()->ActivateNaviPaneMediaL(); + + // Status Pane Title: + if ( EventControllerL().MusContactName().Length() > 0 ) + { + MusAppUi()->MusStatusPane()->SetTitleL( + EventControllerL().MusContactName() ); + } + else if ( EventControllerL().MusTelNumberValue().Length() > 0 ) + { + MusAppUi()->MusStatusPane()->SetTitleL( + EventControllerL().MusTelNumberValue() ); + } + else + { + MusAppUi()->MusStatusPane()->SetTitleFromResourceL( + R_MUS_LIVE_SHARING_VIEW_TITLE ); + } + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::ShowStatusPaneTitleL" ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::EnableMiddleSoftkeyL( TInt aResourceId ) + { + // Update Middle softkey + CEikButtonGroupContainer* cba = Cba(); + if ( cba ) + { + cba->SetCommandL( CEikButtonGroupContainer::EMiddleSoftkeyPosition, + aResourceId ); + cba->DrawDeferred(); + } + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::ActivateVolumeControlL( TInt aValue, TBool aOnlyIfVisible ) + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::ActivateVolumeControlL" ); + MusAppUi()->MusStatusPane()->ActivateVolumeControlL( aValue, aOnlyIfVisible ); + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::ActivateVolumeControlL" ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::HighlightSelectedToolbarItem( TInt aCommand ) + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::HightlightSelectedToolbarItem" ); + iToolbarItemSelected = !iToolbarItemSelected; + CAknButton* button = static_cast( Toolbar()->ControlOrNull( + aCommand ) ); + button->SetCurrentState( iToolbarItemSelected ? 1 : 0, ETrue ); + + TBool dimAudioRouting( iToolbarItemSelected || + !( EventController() && + EventController()->AudioRoutingCanBeChanged() ) ); + + for ( TInt i = EMusuiCmdToolbarVolume; i < EMusUiCmdToolbarLastIndex; i++ ) + { + // Undim audio routing buttons only if changing the routing is allowed + if ( i == EMusuiCmdToolbarSpeakerOn ) + { + Toolbar()->SetItemDimmed( + EMusuiCmdToolbarSpeakerOn, + dimAudioRouting, + ETrue ); + } + else if ( i == EMusuiCmdToolbarSpeakerOff ) + { + Toolbar()->SetItemDimmed( + EMusuiCmdToolbarSpeakerOff, + dimAudioRouting, + ETrue ); + } + else if ( i != aCommand ) + { + Toolbar()->SetItemDimmed( i, iToolbarItemSelected, ETrue ); + } + else + { + // NOP + } + } + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::HightlightSelectedToolbarItem" ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::ReplaceToolbarCommand( TInt aOldCommand, + TInt aNewCommand, + TBool aSetNewCommandFocused ) + { + MUS_LOG1( "mus: [MUSUI ] -> CMusUiGeneralView::ReplaceToolbarCommand: %d", + aNewCommand ); + + // Hide the old item: + Toolbar()->HideItem( aOldCommand, ETrue, EFalse ); + // Show new item: + Toolbar()->HideItem( aNewCommand, EFalse, ETrue ); + + TBool dimAudioRouting( iToolbarItemSelected || + !( EventController() && + EventController()->AudioRoutingCanBeChanged() ) ); + + if ( aNewCommand == EMusuiCmdToolbarSpeakerOn || + aNewCommand == EMusuiCmdToolbarSpeakerOff ) + { + // Dim audio routing button if audio routing cannot be changed + Toolbar()->SetItemDimmed( aNewCommand, + dimAudioRouting, + ETrue ); + } + + if ( aSetNewCommandFocused && + !AknLayoutUtils::PenEnabled() ) + { + TRAP_IGNORE( Toolbar()->SetFocusedItemL( aNewCommand ) ); + } + + MUS_LOG1( "mus: [MUSUI ] <- CMusUiGeneralView::ReplaceToolbarCommand: %d", + aNewCommand ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::DismissMenuBar() + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::DismissMenuBar" ); + StopDisplayingMenuBar(); + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::DismissMenuBar" ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::RefreshAudioRoutingToolbarButton() + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::RefreshAudioRoutingToolbarButton" ) + TBool loudSpeakerEnabled( EventController() && + EventController()->IsLoudSpeakerEnabled() ); + if ( MUS_NO_TOOLBAR ) + { + TRAP_IGNORE( EnableMiddleSoftkeyL( loudSpeakerEnabled ? + R_MUSUI_VIEW_OPS_MSK_IHF_OFF : + R_MUSUI_VIEW_OPS_MSK_IHF_ON ) ); + } + else if ( Toolbar()->IsShown() ) + { + // If toolbar is not shown, it will be refreshed automatically when shown. + TInt focusedItem( Toolbar()->FocusedItem() ); + TBool focusInAudioRouting( focusedItem == EMusuiCmdToolbarSpeakerOff || + focusedItem == EMusuiCmdToolbarSpeakerOn ); + + TBool loudSpeakerEnabled( EventController() && + EventController()->IsLoudSpeakerEnabled() ); + + // Hide old audio routing buttton + Toolbar()->HideItem( loudSpeakerEnabled ? + EMusuiCmdToolbarSpeakerOn : + EMusuiCmdToolbarSpeakerOff, + ETrue, + EFalse ); + + // Show new audio routing button + Toolbar()->HideItem( loudSpeakerEnabled ? + EMusuiCmdToolbarSpeakerOff : + EMusuiCmdToolbarSpeakerOn, + EFalse, + ETrue ); + + // Dim new audio routing button if audio routing cannot be changed + // or when some button is selected + TBool dimAudioRouting( iToolbarItemSelected || + !( EventController() && + EventController()->AudioRoutingCanBeChanged() ) ); + + Toolbar()->SetItemDimmed( loudSpeakerEnabled ? + EMusuiCmdToolbarSpeakerOff : + EMusuiCmdToolbarSpeakerOn, + dimAudioRouting, + ETrue ); + + // If audio routing button has been focused, focus also the new button + // if it is not dimmed + if ( focusInAudioRouting && + !dimAudioRouting && + !AknLayoutUtils::PenEnabled() ) + { + TRAP_IGNORE( Toolbar()->SetFocusedItemL( loudSpeakerEnabled ? + EMusuiCmdToolbarSpeakerOff : + EMusuiCmdToolbarSpeakerOn ) ) + } + + + } + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::RefreshAudioRoutingToolbarButton" ) + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::UpdateSessionTime( const TDesC& aSessionTime ) + { + MUS_LOG_TDESC( "mus: [MUSUI ] -> CMusUiGeneralView::UpdateSessionTime: ", + aSessionTime ); + + TRAPD( err, MusAppUi()->MusStatusPane()->SetLeftLabelL( aSessionTime ) ); + if ( err != KErrNone ) + { + EventController()->HandleError( err ); + } + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::UpdateSessionTime" ); + } + + +// ----------------------------------------------------------------------------- +// takes care of view command handling +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::HandleCommandL( TInt aCommand ) + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::HandleCommandL" ); + + EventControllerL().HandleCommandL( aCommand ); + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::HandleCommandL" ); + } + + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +CMusUiEventController& CMusUiGeneralView::EventControllerL() const + { + __ASSERT_ALWAYS( EventController(), User::Leave( KErrNotFound ) ); + + return *EventController(); + } + + +// ----------------------------------------------------------------------------- +// Called when focus event occurs. Timer is started once coming to foreground +// as often in such case we receive burst of foreground/background events. +// Timer is used to filter that burst and to determine the final condition. +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::HandleForegroundEventL( TBool aForeground, TBool aExit ) + { + MUS_LOG1( "mus: [MUSUI ] -> CMusUiGeneralView::HandleForegroundEventL: %d", + aForeground ); + + SetCurrentFgBgEvent( ( aForeground ? EMusFgEvent : EMusBgEvent ) ); + iCurrentExitSetting = aExit; + + if ( !iFgBgTimer->IsActive() ) + { + if ( aForeground ) + { + MUS_LOG( "mus: [MUSUI ] delayed to fg" ); + } + else + { + DoBackgroundEventL( iCurrentExitSetting ); + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::HandleForegroundEventL,\ +immediately to bg" ); + return; + } + } + + iFgBgTimer->After( KMusFgBgEventFiltering ); + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::HandleForegroundEventL" ); + } + + +// ----------------------------------------------------------------------------- +// From MMusUiActiveTimerObserver +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::TimerComplete( CMusUiActiveTimer* aTimer ) + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::TimerComplete" ); + + if ( aTimer == iSessionEndTimer ) + { + MUS_LOG( "mus: [MUSUI ] Close application because of going \ +in background" ); + + TRAP_IGNORE( EventControllerL().HandleExitL() ) + } + else + { + TRAP_IGNORE( CompleteForegroundEventL() ) + } + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::TimerComplete" ); + } + + +// ----------------------------------------------------------------------------- +// From MEikMenuObserver, Called by framework before constructing menupane. +// Initializes menu items common to all sharing types. +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::DynInitMenuPaneL( TInt aResourceId, + CEikMenuPane* aMenuPane ) + { + MUS_LOG1( "mus: [MUSUI ] -> CMusUiGeneralView::DynInitMenuPaneL [%d]", + aResourceId ); + + if ( aResourceId == R_MUSUI_VIEW_MENU ) + { + + // Delete Single session items: + aMenuPane->DeleteMenuItem( EMusuiCmdViewShareVideo ); + aMenuPane->DeleteMenuItem( EMusuiCmdViewShareImage ); + aMenuPane->DeleteMenuItem( EMusuiCmdViewShareLive ); + if ( MUS_NO_TOOLBAR ) + { + aMenuPane->DeleteMenuItem( EventControllerL().IsMicMutedL() ? + EMusuiCmdViewMicrophoneMute : + EMusuiCmdViewMicrophoneUnmute ); + } + else + { + aMenuPane->DeleteMenuItem( EMusuiCmdViewMicrophoneMute ); + aMenuPane->DeleteMenuItem( EMusuiCmdViewMicrophoneUnmute ); + } + + if ( !FeatureManager::FeatureSupported( KFeatureIdHelp ) ) + { + aMenuPane->DeleteMenuItem( EAknCmdHelp ); + } + } + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::DynInitMenuPaneL" ); + } + + +// ----------------------------------------------------------------------------- +// CMusUiGeneralView::DoActivateL +// From CAknView, Gets called from framework when activating this view +// ----------------------------------------------------------------------------- +void CMusUiGeneralView::DoActivateL( const TVwsViewId& /*aPrevViewId*/, + TUid /*aCustomMessageId*/, + const TDesC8& /*aCustomMessage*/ ) + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::DoActivateL()" ) + + + MusAppUi()->MusStatusPane()->ClearNaviPaneL(); + MusAppUi()->MusStatusPane()->SetTitleFromResourceL( + R_MUS_LIVE_SHARING_VIEW_TITLE ); + + iIncallBubble->SetIncallBubbleAllowedInUsualL( EFalse ); + + /* Draw the skin background in the client rectangle area.*/ + if ( !iBackgroundContainer ) + { + /* Construct background container with clientrect area and + * Ordinal position of 0 ie highest so that it draws the initial + * skin background first. + */ + iBackgroundContainer = + CMusUiBackgroundViewContainer::NewL( ClientRect(), 0 ); + /* Add container to view stack so that it get view events */ + AppUi()->AddToViewStackL( *this, iBackgroundContainer ); + } + else + { + /* Set the windows ordinal position to highest ie 0, + * so that background gets priority and drawn first. + */ + iBackgroundContainer->SetOrdinalPosition( 0 ); + } + /* Draw the skin background now */ + iBackgroundContainer->DrawNow(); + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::DoActivateL()" ) + } + + +// ----------------------------------------------------------------------------- +// CMusUiGeneralView::DoDeactivate +// From AknView, Gets called from framework when deactivating this view +// ----------------------------------------------------------------------------- +void CMusUiGeneralView::DoDeactivate() + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::DoDeactivate()" ) + if ( iBackgroundContainer ) + { + AppUi()->RemoveFromViewStack( *this, iBackgroundContainer ); + delete iBackgroundContainer; + iBackgroundContainer = NULL; + } + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::DoDeactivate()" ) + } + + +// ----------------------------------------------------------------------------- +// Asynchronous completion of last fg/bg condition. +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::CompleteForegroundEventL() + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::CompleteForegroundEventL()" ) + + if ( iCurrentFgBgEvent == EMusFgEvent ) + { + DoForegroundEventL(); + } + else if ( iCurrentFgBgEvent == EMusBgEvent && EventControllerL().IsForeground() ) + { + // Bg handling when already at bg would cause problems in state + // restoring phase when coming back to fg. Easiest to deal with that + // at this level. + DoBackgroundEventL( iCurrentExitSetting ); + } + + SetCurrentFgBgEvent( EMusFgBgEventNone ); + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::CompleteForegroundEventL()" ) + } + + +// ----------------------------------------------------------------------------- +// Complete foreground event. +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::DoForegroundEventL() + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::DoForegroundEventL()" ) + + RefreshView(); + + iSessionEndTimer->Cancel(); + + EventControllerL().HandleForegroundEventL( ETrue ); + iIncallBubble->SetIncallBubbleAllowedInUsualL( EFalse ); + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::DoForegroundEventL()" ) + } + + +// ----------------------------------------------------------------------------- +// Complete background event. +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::DoBackgroundEventL( TBool aExit ) + { + MUS_LOG( "mus: [MUSUI ] -> CMusUiGeneralView::DoBackgroundEventL()" ) + + if ( aExit ) + { + MUS_LOG( "mus: [MUSUI ] Go to background, \ + wait some seconds before closing..." ); + iSessionEndTimer->After( KBackgroundIntervalForClose ); + } + if ( !MusAppUi()->ExitValue() ) + { + MUS_LOG( "mus: [MUSUI ] Calling EventControllerL()" ); + EventControllerL().HandleForegroundEventL( EFalse ); + // If exiting, next will be called by destructor + iIncallBubble->SetIncallBubbleAllowedInUsualL( ETrue ); + } + + SetCurrentFgBgEvent( EMusFgBgEventNone ); + + MUS_LOG( "mus: [MUSUI ] <- CMusUiGeneralView::DoBackgroundEventL()" ) + } + +// ----------------------------------------------------------------------------- +// Set current fg/bg condition. +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::SetCurrentFgBgEvent( TMusFgBgEventType aEventType ) + { + MUS_LOG1( "mus: [MUSUI ] -> CMusUiGeneralView::SetCurrentFgBgEvent() event:%d", + aEventType ) + + iCurrentFgBgEvent = aEventType; + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +TBool CMusUiGeneralView::OperatorSpecificFunctionality() const + { + return iOperatorSpecificFunctionality; + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +TInt CMusUiGeneralView::ToolbarPlaceHolderHeight() const + { + TInt toolbarPlaceHolderHeight( 0 ); + CAknAppUiBase::TAppUiOrientation orientation = MusAppUi()->AppOrientation(); + if ( !Toolbar()->IsShown() && + orientation == CAknAppUiBase::EAppUiOrientationPortrait && + AknLayoutUtils::PenEnabled() ) + { + // In touch UI in portrait mode the toolbar + // fills the whole lower part of the screen + toolbarPlaceHolderHeight = Toolbar()->Size().iHeight; + } + return toolbarPlaceHolderHeight; + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +TInt CMusUiGeneralView::ToolbarPlaceHolderWidth() const + { + TInt toolbarPlaceHolderWidth( 0 ); + CAknAppUiBase::TAppUiOrientation orientation = MusAppUi()->AppOrientation(); + if ( !Toolbar()->IsShown() && + orientation == CAknAppUiBase::EAppUiOrientationLandscape && + AknLayoutUtils::PenEnabled() ) + { + // In touch UI in EAppUiOrientationLandscape mode the toolbar + // fills the whole lower part of the screen + toolbarPlaceHolderWidth = Toolbar()->Size().iWidth; + } + return toolbarPlaceHolderWidth; + } + +// ----------------------------------------------------------------------------- +// Increase/Decrease background container ordinal so that other controls +// can preceed background +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::UpdateBackgroundOrdinalPosition( TBool aUp ) + { + // If there is no background container then do not care + if ( iBackgroundContainer ) + { + iBackgroundContainer->UpdateOrdinalPositionValue( aUp ); + } + } + +// ----------------------------------------------------------------------------- +// Do refresh for background container only if display is disabled. +// Refreshing if display is enabled would cause bg container +// to draw itself on top of display area, making it invisible. +// ----------------------------------------------------------------------------- +// +void CMusUiGeneralView::RefreshBackgroundContainer() + { + if ( !iBackgroundContainer ) + { + return; + } + TBool displayEnabled( EFalse ); + if ( EventController() ) + { + TRAP_IGNORE( displayEnabled = EventController()->IsDisplayEnabledL() ) + } + + if ( !displayEnabled ) + { + MUS_LOG( "mus: [MUSUI ] <-> CMusUiGeneralView::RefreshBackgroundContainer()" ) + iBackgroundContainer->SetRect( ClientRect() ); + } + } + +// end of file + + + + + +