--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/taskswitcher/taskswitcherui/taskswitcherapp/src/tsappui.cpp Wed Sep 01 12:32:46 2010 +0100
@@ -0,0 +1,964 @@
+/*
+* Copyright (c) 2008 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: AppUi class
+ *
+*/
+
+
+#include "tsappui.h"
+#include "tsappview.h"
+#include "tsapplogging.h"
+#include "tsdevicestate.h"
+#include "tsuid.hrh"
+#include "tscommands.hrh"
+#include <akntitle.h>
+#include <hlplch.h>
+#include <avkon.rsg>
+#include <bautils.h>
+#include <AknUtils.h>
+#include <taskswitcher.rsg>
+#include <pslninternalcrkeys.h>
+#include <oommonitorsession.h>
+#include <hal.h>
+#include <hal_data.h>
+#include <akntranseffect.h>
+#include <UikonInternalPSKeys.h>
+#include <apgwgnam.h>
+
+
+// AknCapServer UID, used for P&S category
+const TUid KTaskswitcherStateCategory = { 0x10207218 };
+
+// Taskswitcher UI, used as P&S key
+const TInt KTaskswitcherStateKey = KTsAppUidValue;
+
+const TUid KTransitionsUid = {0x10281F90};
+
+// Values for Taskswitcher launching P&S
+const TInt KTaskswitcherBackgroundValue = 1;
+const TInt KTaskswitcherForegroundValue = KTaskswitcherBackgroundValue << 1;
+const TInt KTaskswitcherShortAppKeyPressed = KTaskswitcherForegroundValue << 1;
+const TInt KTaskswitcherLongAppKeyPressed = KTaskswitcherShortAppKeyPressed << 1;
+
+//short/long App key values
+const TInt KAppKeyTypeShort = 1;
+const TInt KAppKeyTypeLong = 2;
+
+//values for checking the OOM
+const TInt KMemoryRequestAmountInBytes = 524288;
+const TInt KMinMemoryAmountInBytes = 524288;
+
+// time to wait before sending the task to background
+// (must give time to animation)
+const TInt KWaitBeforeGoingToBackground = 200000;
+
+const TUid KTsAppUid = { KTsAppUidValue };
+
+const TUid KTsCameraUid = { 0x101F857a };
+const TUid KTsTelephoneUid = { 0x100058b3 };
+
+const TInt KTsMultimediaAppActivationDelay = 1500000;
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::ConstructL()
+// ConstructL is called by the application framework
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::ConstructL()
+ {
+ TSLOG_CONTEXT( CTsAppUi::ConstructL, TSLOG_LOCAL );
+ TSLOG_IN();
+
+#ifdef _DEBUG
+ // create log folder
+ _LIT( KLogPath, "c:\\logs\\taskswitcher\\" );
+ RFs fs;
+ if ( fs.Connect() == KErrNone )
+ {
+ fs.MkDirAll( KLogPath );
+ fs.Close();
+ }
+#endif
+
+ // Initialise app UI with standard value.
+ BaseConstructL( CAknAppUi::EAknEnableSkin |
+ CAknAppUi::EAknEnableMSK |
+ CAknAppUi::EAknSingleClickCompatible);
+ SetFullScreenApp(EFalse);
+
+#ifndef _DEBUG
+ // set as system application (in release build) so we never get closed
+ iEikonEnv->SetSystem( ETrue );
+#endif
+
+ //Initialize effects change observation
+ iThemeEffectsEnabledWatcher =
+ CTsCenrepListener::NewL( KCRUidThemes, KThemesTransitionEffects, *this );
+ CenrepChanged( KThemesTransitionEffects, iThemeEffectsEnabledWatcher->Value() );
+
+ // Hide status pane
+ StatusPane()->MakeVisible( EFalse );
+
+ // Change CBA if needed, default is non-touch in rss
+ if ( AknLayoutUtils::PenEnabled() )
+ {
+ Cba()->SetCommandSetL( R_TS_CBA_TOUCH );
+ }
+ Cba()->MakeVisible(EFalse);
+
+ // Create timer
+ iGoToBackgroundTimer = CPeriodic::NewL( CActive::EPriorityStandard );
+ iForegroundDelayTimer = CPeriodic::NewL( CActive::EPriorityStandard );
+
+ // Create commonly used instances (device state only?)
+ iDeviceState = CTsDeviceState::NewL();
+
+ // Create custom window group
+ iWg = RWindowGroup(CCoeEnv::Static()->WsSession());
+ iWg.Construct((TUint32)&iWg, ETrue);
+ iWg.EnableScreenChangeEvents();
+ CApaWindowGroupName* rootWgName = CApaWindowGroupName::NewLC( iEikonEnv->WsSession(), iEikonEnv->RootWin().Identifier() );
+ rootWgName->SetWindowGroupName( iWg );
+ CleanupStack::PopAndDestroy( rootWgName );
+
+ // Create UI
+ iAppView = CTsAppView::NewL( ApplicationRect(), *iDeviceState, iWg );
+ AddToStackL( iAppView );
+
+ //Enable effects
+ GfxTransEffect::Enable();
+ GfxTransEffect::Register(iAppView,KTransitionsUid);
+ GfxTransEffect::SetTransitionObserver(this);
+
+ // Listen for change in the value of the ts state property.
+ iPropListener = new ( ELeave ) CTsPropertyListener(
+ KTaskswitcherStateCategory, KTaskswitcherStateKey, *this );
+
+ // Listen for layout changes
+ iLayoutListener = new ( ELeave ) CTsPropertyListener(
+ KPSUidUikon, KUikLayoutState, *this );
+
+ // Initialise the application task object with the window group id of
+ // our application ( so that it represent our app )
+ //iApplicationTask.SetWgId( iCoeEnv->RootWin().Identifier() );
+ iApplicationTask.SetWgId( iWg.Identifier() );
+
+ // And finally, go to background.
+ MoveAppToBackground( ENoneTransition );
+
+ iEikonEnv->RootWin().SetOrdinalPosition(-1, ECoeWinPriorityNeverAtFront);
+ iEikonEnv->RootWin().EnableReceiptOfFocus(EFalse);
+
+ RWindowGroup& windowGroup = CCoeEnv::Static()->RootWin();
+ windowGroup.EnableGroupListChangeEvents();
+
+ iIsPopUpShown = EFalse;
+ iUiStarted = EFalse;
+ iDisableAppKeyHandling = EFalse;
+
+ // Set process priority to high to avoid being
+ // locked by heavy ui apps processing
+ iEikonEnv->WsSession().ComputeMode(RWsSession::EPriorityControlDisabled);
+ RProcess().SetPriority(EPriorityHigh);
+
+ iForegroundDelayed = EFalse;
+ iDelayedForegroundInProgress = EFalse;
+
+ TSLOG_OUT();
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::CTsAppUi()
+// Perform the first phase of two phase construction
+// -----------------------------------------------------------------------------
+//
+CTsAppUi::CTsAppUi(): iForeground( ETrue ),
+ iApplicationTask( iCoeEnv->WsSession() )
+ {
+ // no implementation required
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::~CTsAppUi()
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CTsAppUi::~CTsAppUi()
+ {
+ if( GfxTransEffect::IsRegistered( iAppView ) )
+ {
+ GfxTransEffect::Deregister(iAppView);
+
+ }
+ GfxTransEffect::SetTransitionObserver(0);
+
+ delete iGoToBackgroundTimer;
+ delete iForegroundDelayTimer;
+ delete iPropListener;
+ delete iLayoutListener;
+
+ // destroy UI first
+ if ( iAppView )
+ {
+ RemoveFromStack( iAppView );
+ delete iAppView;
+ }
+
+ delete iDeviceState;
+ delete iThemeEffectsEnabledWatcher;
+
+ iWg.Close();
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppView::EffectsEnabled
+// -----------------------------------------------------------------------------
+//
+TBool CTsAppUi::EffectsEnabled() const
+ {
+ return iEffectsEnabled;
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::StartTransion
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::StartTransion( TUint aTransitionType, TUid aNextAppUid, TInt aWgId )
+ {
+ if( !EffectsEnabled() )
+ {
+ return;
+ }
+ switch(aTransitionType)
+ {
+ case EForegroundTransition:
+ StartTransition( aTransitionType,
+ ETrue,
+ EFalse,
+ CAknTransitionUtils::EForceVisible);
+ break;
+ case EBackgroundTransition:
+ StartTransition( aTransitionType,
+ EFalse,
+ EFalse,
+ CAknTransitionUtils::EForceInvisible );
+ break;
+ case EActivationTransition:
+ StartAppActivateTransition( aNextAppUid, aWgId );
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::StartTransition
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::StartTransition( TUint aTranstionId,
+ TBool aVisibility,
+ TBool /*aLayers*/,
+ TUint aSubCom )
+ {
+ const TDesC8* ptr = reinterpret_cast<const TDesC8*>(iAppView);
+ GfxTransEffect::Abort(iAppView);
+ GfxTransEffect::Begin( iAppView, aTranstionId );
+ GfxTransEffect::SetDemarcation( iAppView, iAppView->Rect() );
+ GfxTransEffect::NotifyExternalState( ECaptureComponentsBegin, ptr );
+ iAppView->MakeVisible( aVisibility );
+ CAknTransitionUtils::MakeVisibleSubComponents(
+ iAppView,
+ static_cast<CAknTransitionUtils::TMakeVisibleSubComponentsInfo>(aSubCom) );
+ GfxTransEffect::NotifyExternalState( ECaptureComponentsEnd, ptr );
+ GfxTransEffect::End( iAppView );
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::StartAppActivateTransition
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::StartAppActivateTransition( TUid aNextAppUid, TInt aWgId )
+ {
+ // Check what type of transition will be trigerred
+ if ( aWgId == iUnderAppWgId )
+ {
+ // App under task switcher was launched
+ StartTransition( EBackgroundTransition,
+ EFalse,
+ ETrue,
+ CAknTransitionUtils::EForceInvisible );
+ }
+ else
+ {
+ // App start animation
+ const TDesC8* ptr = reinterpret_cast<const TDesC8*>(iAppView);
+ GfxTransEffect::Abort(iAppView);
+ TInt groupId = GfxTransEffect::BeginGroup();
+ GfxTransEffect::BeginFullScreen(
+ EActivationAppShowTransition, ApplicationRect(),
+ AknTransEffect::EParameterType,
+ AknTransEffect::GfxTransParam( aNextAppUid , KTsAppUid ) );
+ GfxTransEffect::Begin( iAppView, EBackgroundTransition );
+ GfxTransEffect::SetDemarcation( iAppView, iAppView->Rect() );
+ GfxTransEffect::NotifyExternalState( ECaptureComponentsBegin, ptr );
+ iAppView->MakeVisible( EFalse );
+ CAknTransitionUtils::MakeVisibleSubComponents(
+ iAppView,
+ static_cast<CAknTransitionUtils::TMakeVisibleSubComponentsInfo>(CAknTransitionUtils::EForceInvisible) );
+ GfxTransEffect::NotifyExternalState( ECaptureComponentsEnd, ptr );
+ GfxTransEffect::End( iAppView );
+ GfxTransEffect::EndFullScreen();
+ GfxTransEffect::EndGroup(groupId);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::TransitionFinished
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::TransitionFinished(const CCoeControl* /*aControl*/,
+ TUint /*aAction*/)
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::HandleCommandL()
+// Takes care of command handling.
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::HandleCommandL( TInt aCommand )
+ {
+ switch ( aCommand )
+ {
+ case EAknCmdExit:
+ case EEikCmdExit:
+ Exit();
+ break;
+
+ case EAknSoftkeyExit:
+ case EAknSoftkeyBack:
+ // RSK => just hide
+ MoveAppToBackground( EBackgroundTransition );
+ break;
+
+ case ETsCmdHelp:
+ {
+ MoveAppToBackground( EBackgroundTransition );
+ CArrayFix<TCoeHelpContext>* buf = CCoeAppUi::AppHelpContextL();
+ HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), buf );
+ }
+ break;
+
+ case EAknSoftkeySelect:
+ {
+ // select is generated by lsk and msk (see the resource file)
+ // Simulate a middle key press to the controls.
+ // Note that SimulateKeyEventL must not be used here or else it
+ // will end up in an infinite loop.
+ TKeyEvent keyEvent;
+ keyEvent.iCode = EKeyOK;
+ keyEvent.iScanCode = EStdKeyDevice3;
+ keyEvent.iModifiers = keyEvent.iRepeats = 0;
+ iAppView->OfferKeyEventL( keyEvent, EEventKeyDown );
+ iAppView->OfferKeyEventL( keyEvent, EEventKey );
+ iAppView->OfferKeyEventL( keyEvent, EEventKeyUp );
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::HandleForegroundEventL
+// Called by the system when the app is moved to foreground or background.
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::HandleForegroundEventL( TBool aForeground )
+ {
+ TSLOG_CONTEXT( HandleForegroundEventL, TSLOG_LOCAL );
+ TSLOG1_IN( "aForeground = %d", aForeground );
+
+ // These calls may be redundant but the functions will do nothing if the
+ // state has already been changed.
+ // Both this function and the 'manual' MoveAppTo functions must fire the events
+ // because in some cases only one of them will run (e.g. when bringing to foreground
+ // not with the hw key but by other means etc.)
+ iDisableAppKeyHandling = EFalse;
+ if ( !iUiStarted )
+ {
+ // Ignore foreground events if UI is starting
+ return;
+ }
+ if ( aForeground )
+ {
+ HandleSwitchToForegroundEvent();
+ }
+ // exclude cases with dialogs like power menu, memory card
+ else
+ {
+ if( !IsFaded() )
+ {
+ HandleSwitchToBackgroundEvent();
+ }
+ else
+ {
+ iDisableAppKeyHandling = ETrue;
+ }
+ }
+
+ // Call Base class method
+ CAknAppUi::HandleForegroundEventL( aForeground );
+
+ TSLOG_OUT();
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::PropertyChanged
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::PropertyChanged( TUid aCategory, TUint aKey )
+ {
+ TSLOG_CONTEXT( PropertyChanged, TSLOG_LOCAL );
+ TSLOG_IN();
+
+ TInt value( 0 );
+
+ if ( aCategory == KTaskswitcherStateCategory )
+ {
+ if ( RProperty::Get( aCategory, aKey, value ) == KErrNone )
+ {
+ if ( iForeground && (value & KTaskswitcherBackgroundValue) )
+ {
+ MoveAppToBackground( EBackgroundTransition );
+ }
+ else if ( !iForeground && (value & KTaskswitcherForegroundValue) )
+ {
+ MoveAppToForeground( EForegroundTransition );
+ }
+ else if( value & KTaskswitcherLongAppKeyPressed )
+ {
+ if(!iForeground)
+ {
+ MoveAppToBackground( EBackgroundTransition );
+ }
+ else if( !iDisableAppKeyHandling )
+ {
+ iAppView->HandleAppKey(KAppKeyTypeLong);
+ }
+ }
+ else if( value & KTaskswitcherShortAppKeyPressed && !iDisableAppKeyHandling )
+ {
+ iAppView->HandleAppKey(KAppKeyTypeShort);
+ }
+ }
+ }
+ else if ( aCategory == KPSUidUikon && iIsPopUpShown )
+ {
+ TRAP_IGNORE(
+ DisablePopUpL();
+ HandleResourceChangeL(KEikDynamicLayoutVariantSwitch) );
+ }
+
+ TSLOG_OUT();
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::HandleResourceChangeL
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::HandleResourceChangeL( TInt aType )
+ {
+ TSLOG_CONTEXT( CTsAppUi::HandleResourceChangeL, TSLOG_LOCAL );
+ TSLOG_IN();
+ // Must call base class implementation first,
+ // sizes from LayoutMetricsRect etc. will only be correct after this.
+ CAknAppUi::HandleResourceChangeL( aType );
+ if( aType == KEikDynamicLayoutVariantSwitch && iAppView && !LayoutChangeAllowed() )
+ {
+ // Keep displayed orientation
+ return;
+ }
+ // forward event
+ iDeviceState->HandleResourceChange( aType );
+ if ( iAppView )
+ {
+ iAppView->HandleResourceChange( aType );
+ }
+ TSLOG_OUT();
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::MoveAppToBackground()
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::MoveAppToBackground( TUint aTransitionType, TUid aAppUid, TInt aWgId )
+ {
+ TSLOG_CONTEXT( MoveAppToBackground, TSLOG_LOCAL );
+ TSLOG_IN();
+
+ if ( ENoneTransition == aTransitionType || !EffectsEnabled() )
+ {
+ GoToBackgroundTimerCallback( this );
+ }
+ else
+ {
+ StartTransion(aTransitionType, aAppUid, aWgId);
+ iGoToBackgroundTimer->Cancel();
+ iGoToBackgroundTimer->Start(
+ KWaitBeforeGoingToBackground,
+ 0,
+ TCallBack( GoToBackgroundTimerCallback, this ) );
+ }
+ TSLOG_OUT();
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::CenrepChanged
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::CenrepChanged( TUint32 /*aKey*/, TInt aNewValue )
+ {
+ iEffectsEnabled = !(aNewValue & AknTransEffect::EFullScreenTransitionsOff);
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::GoToBackgroundTimerCallback
+// -----------------------------------------------------------------------------
+//
+TInt CTsAppUi::GoToBackgroundTimerCallback( TAny* aParam )
+ {
+ CTsAppUi* self = static_cast<CTsAppUi*>( aParam );
+ if ( self->iGoToBackgroundTimer )
+ {
+ self->iGoToBackgroundTimer->Cancel();
+ }
+
+ // Request window server to bring our application
+ // to background
+ self->iApplicationTask.SendToBackground();
+
+ // Notify
+ self->HandleSwitchToBackgroundEvent();
+
+ return 0;
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::DelayedForegroundCallback
+// -----------------------------------------------------------------------------
+//
+TInt CTsAppUi::DelayedForegroundCallback( TAny* aParam )
+ {
+ CTsAppUi* self = static_cast<CTsAppUi*>( aParam );
+ self->iDelayedForegroundInProgress = ETrue;
+
+ if ( self->iForegroundDelayTimer )
+ {
+ self->iForegroundDelayTimer->Cancel();
+ }
+ self->iForegroundDelayed = EFalse;
+ self->HandleSwitchToForegroundEvent();
+
+ self->iDelayedForegroundInProgress = EFalse;
+
+ return 0;
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::MoveAppToForeground()
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::MoveAppToForeground( TUint /*aTransitionType*/ )
+ {
+ TSLOG_CONTEXT( MoveAppToForeground, TSLOG_LOCAL );
+ TSLOG_IN();
+
+ iUiStarted = ETrue;
+
+ // Request window server to bring our application
+ // to foreground
+ iApplicationTask.BringToForeground();
+
+ // Notify
+ TBool delayForeground(EFalse);
+ TRAP_IGNORE( delayForeground = IsUnderlyingAppMultimediaL() );
+ if ( delayForeground )
+ {
+ iForegroundDelayed = ETrue;
+ iForegroundDelayTimer->Cancel();
+ iForegroundDelayTimer->Start(
+ KTsMultimediaAppActivationDelay,
+ 0,
+ TCallBack( DelayedForegroundCallback, this ) );
+ }
+ else
+ {
+ HandleSwitchToForegroundEvent();
+ }
+
+ TSLOG_OUT();
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::HandleSwitchToBackgroundEvent
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::HandleSwitchToBackgroundEvent()
+ {
+ TSLOG_CONTEXT( HandleSwitchToBackgroundEvent, TSLOG_LOCAL );
+ TSLOG_IN();
+
+ // must not do anything if iForeground is already up-to-date
+
+
+ if( iForeground )
+ {
+ iForeground = EFalse;
+ SetTaskswitcherStateProperty( KTaskswitcherBackgroundValue );
+
+ // notify view
+ iAppView->HandleSwitchToBackgroundEvent();
+
+ iWg.SetOrdinalPosition(-1, ECoeWinPriorityNormal);
+
+ iForegroundDelayed = EFalse;
+ }
+
+ TSLOG_OUT();
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::HandleSwitchToForegroundEvent
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::HandleSwitchToForegroundEvent()
+ {
+ TSLOG_CONTEXT( HandleSwitchToForegroundEvent, TSLOG_LOCAL );
+ TSLOG_IN();
+
+ // must not do anything if iForeground is already up-to-date
+ if ( !iForeground && !iForegroundDelayed )
+ {
+ TInt freeRamMemory;
+ HAL::Get( HALData::EMemoryRAMFree, freeRamMemory );
+ if ( freeRamMemory <= KMinMemoryAmountInBytes )
+ {
+ FreeMemoryRequest();
+ }
+
+ iForeground = ETrue;
+ SetTaskswitcherStateProperty( KTaskswitcherForegroundValue );
+
+ // notify view
+ iAppView->HandleSwitchToForegroundEvent();
+
+ iWg.SetOrdinalPosition(iWg.OrdinalPosition(), ECoeWinPriorityAlwaysAtFront);
+ }
+
+ TSLOG_OUT();
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::SetTaskswitcherShowProperty
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::SetTaskswitcherStateProperty( TInt aValue )
+ {
+ TSLOG_CONTEXT( CTsAppUi::SetTaskswitcherShowProperty, TSLOG_LOCAL );
+ TSLOG_IN();
+
+ if ( RProperty::Set(
+ KTaskswitcherStateCategory, KTaskswitcherStateKey, aValue ) != KErrNone )
+ {
+ TInt error = RProperty::Define(
+ KTaskswitcherStateCategory, KTaskswitcherStateKey, RProperty::EInt );
+ if ( error != KErrNone )
+ {
+ TSLOG1( TSLOG_INFO, "RProperty::Define Error: %d", error );
+ }
+
+ error = RProperty::Set( KTaskswitcherStateCategory, KTaskswitcherStateKey, aValue );
+ if ( error != KErrNone )
+ {
+ TSLOG1( TSLOG_INFO, "RProperty::Set Error: %d", error );
+ }
+ }
+
+ TSLOG_OUT();
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::FreeMemoryRequest
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::FreeMemoryRequest()
+ {
+ TSLOG_CONTEXT( CTsAppUi::FreeMemoryRequest, TSLOG_LOCAL );
+ TSLOG_IN();
+ ROomMonitorSession oomMs;
+ TInt error = oomMs.Connect();
+ if ( error != KErrNone)
+ {
+ TSLOG1( TSLOG_INFO, "Could not connect to ROomMonitorSession, %d", error );
+ }
+ else
+ {
+ oomMs.RequestFreeMemory( KMemoryRequestAmountInBytes );
+ oomMs.Close();
+ }
+ TSLOG_OUT();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::RequestPopUpL
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::RequestPopUpL()
+ {
+ TSLOG_CONTEXT( CTsAppUi::RequestPopUpL, TSLOG_LOCAL );
+ TSLOG_IN();
+ if(!iIsPopUpShown)
+ {
+ iIsPopUpShown = ETrue;
+ TSizeMode mode = iEikonEnv->ScreenDevice()->GetCurrentScreenModeAttributes();
+ TInt isLandscape = mode.iScreenSize.iWidth > mode.iScreenSize.iHeight;
+ SetFullScreenApp(ETrue);
+ if(isLandscape)
+ {
+ SetOrientationL(EAppUiOrientationLandscape);
+ }
+ else
+ {
+ SetOrientationL(EAppUiOrientationPortrait);
+ }
+ RProcess().SetPriority(EPriorityForeground);
+ SetFullScreenApp(EFalse);
+ iEikonEnv->RootWin().SetOrdinalPosition(0, ECoeWinPriorityAlwaysAtFront);
+ }
+ TSLOG_OUT();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::DisablePopUpL
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::DisablePopUpL()
+ {
+ TSLOG_CONTEXT( CTsAppUi::DisablePopUpL, TSLOG_LOCAL );
+ TSLOG_IN();
+ if(iIsPopUpShown)
+ {
+ iIsPopUpShown = EFalse;
+ iEikonEnv->RootWin().SetOrdinalPosition(-1, ECoeWinPriorityNeverAtFront);
+ SetOrientationL(EAppUiOrientationAutomatic);
+ SetFullScreenApp(EFalse);
+ RProcess().SetPriority(EPriorityHigh);
+ }
+ TSLOG_OUT();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::LayoutCanBeChanged
+// -----------------------------------------------------------------------------
+//
+TBool CTsAppUi::LayoutChangeAllowed()
+ {
+ // Check if layout switch is necessary
+ TSizeMode mode = iEikonEnv->ScreenDevice()->GetCurrentScreenModeAttributes();
+ TBool isLandscape = mode.iScreenSize.iWidth > mode.iScreenSize.iHeight;
+ TRect appRect = ApplicationRect();
+ TBool isAppLandscape = appRect.Width() > appRect.Height();
+ TBool retVal;
+ if(isLandscape != isAppLandscape)
+ {
+ retVal = EFalse;
+ }
+ else
+ {
+ retVal = ETrue;
+ }
+ return retVal;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::HandleWsEventL
+// -----------------------------------------------------------------------------
+//
+void CTsAppUi::HandleWsEventL(const TWsEvent& aEvent,
+ CCoeControl* aDestination)
+ {
+ CAknAppUi::HandleWsEventL(aEvent, aDestination);
+ TInt eventType = aEvent.Type();
+ if ( eventType == EEventWindowGroupListChanged )
+ {
+ TInt wgId = WgIdOfUnderlyingAppL(EFalse);
+ if ( iForeground &&
+ wgId != iUnderAppWgId &&
+ !iAppView->AppCloseInProgress(iUnderAppWgId) &&
+ !iAppView->WgOnTaskList(wgId) )
+ {
+ MoveAppToBackground( ENoneTransition );
+ }
+ if ( WgIdOfUnderlyingAppL(ETrue) != iUnderAppWgId )
+ {
+ HandleResourceChangeL(KEikDynamicLayoutVariantSwitch);
+ }
+ iUnderAppWgId = wgId;
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::WgIdOfUnderlyingApp
+// -----------------------------------------------------------------------------
+//
+TInt CTsAppUi::WgIdOfUnderlyingAppL( TBool aIgnoreParentChild )
+ {
+ TInt retVal(0);
+ TInt underlyingWg = CheckForUnderlyingHiddenAppsL();
+ if ( !underlyingWg )
+ {
+ TApaTaskList taskList( iEikonEnv->WsSession() );
+ underlyingWg = taskList.FindByPos(0).WgId();
+ }
+
+ if ( aIgnoreParentChild )
+ {
+ retVal = underlyingWg;
+ }
+ else
+ {
+ TInt parentWg = GetTopParentWg( underlyingWg );
+ retVal = parentWg ? parentWg : underlyingWg;
+ }
+ return retVal;
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::GetTopParentWg
+// -----------------------------------------------------------------------------
+//
+TInt CTsAppUi::GetTopParentWg( TInt aChildWg )
+ {
+ TInt parentWg = GetParentWg( aChildWg );
+ if( parentWg )
+ {
+ TInt topParentWg = GetTopParentWg( parentWg );
+ if( topParentWg )
+ {
+ parentWg = topParentWg;
+ }
+ }
+ return parentWg;
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::GetParentWg
+// -----------------------------------------------------------------------------
+//
+TInt CTsAppUi::GetParentWg( TInt aChildWg )
+ {
+ TInt retVal(0);
+ RArray<RWsSession::TWindowGroupChainInfo> allWgIds;
+ // Ask for window group list from RWsSession
+ TInt error = iEikonEnv->WsSession().WindowGroupList( 0, &allWgIds );
+ if ( !error )
+ {
+ TInt count( allWgIds.Count() );
+ for ( TInt i( 0 ); i < count; i++ )
+ {
+ RWsSession::TWindowGroupChainInfo info = allWgIds[i];
+ if ( info.iId == aChildWg && info.iParentId > 0)
+ {
+ retVal = info.iParentId;
+ break;
+ }
+ }
+ }
+ allWgIds.Close();
+ return retVal;
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::IsForeground
+// -----------------------------------------------------------------------------
+//
+TBool CTsAppUi::IsForeground() const
+ {
+ return iForeground;
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::CheckForUnderlyingCameraL
+// -----------------------------------------------------------------------------
+//
+TInt CTsAppUi::CheckForUnderlyingHiddenAppsL()
+ {
+ TInt wgId(0);
+ RArray<RWsSession::TWindowGroupChainInfo> allWgIds;
+ CleanupClosePushL(allWgIds);
+ User::LeaveIfError(iEikonEnv->WsSession().WindowGroupList(0, &allWgIds));
+ TInt underlyingWg(allWgIds[0].iId);
+ CleanupStack::PopAndDestroy(&allWgIds);
+
+ CApaWindowGroupName* windowName =
+ CApaWindowGroupName::NewLC( iEikonEnv->WsSession(), underlyingWg );
+ TUid appUid = windowName->AppUid();
+ CleanupStack::PopAndDestroy( windowName );
+ if( appUid == KTsCameraUid ||
+ appUid == KTsTelephoneUid )
+ {
+ wgId = underlyingWg;
+ }
+ return wgId;
+ }
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::IsUnderlyingAppMultimediaL
+// -----------------------------------------------------------------------------
+//
+TBool CTsAppUi::IsUnderlyingAppMultimediaL()
+ {
+ TBool retVal(EFalse);
+
+ TApaTaskList taskList( iEikonEnv->WsSession() );
+ TInt underlyingWg = taskList.FindByPos(0).WgId();
+
+ CApaWindowGroupName* windowName =
+ CApaWindowGroupName::NewLC( iEikonEnv->WsSession(), underlyingWg );
+ TUid appUid = windowName->AppUid();
+ CleanupStack::PopAndDestroy( windowName );
+ if ( appUid == KTsCameraUid )
+ {
+ retVal = ETrue;
+ }
+
+ return retVal;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CTsAppUi::DelayedForegroundLaunched
+// -----------------------------------------------------------------------------
+//
+TBool CTsAppUi::DelayedForegroundLaunched()
+ {
+ return iDelayedForegroundInProgress;
+ }
+
+// End of file