--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AknGlobalUI/AknCapServer/src/AknEikSgcs.cpp Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,1510 @@
+/*
+* Copyright (c) 2002-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: Server side implementation of AVKON System
+* Graphics Coordinator.
+*
+*/
+
+
+#include "AknEikSgcs.h"
+#include <eikenv.h>
+#include "eiksrvsp.h"
+#include <AknSgcc.h>
+#include <aknenv.h>
+#include <AknDef.h>
+#include <aknappui.h>
+#include <e32property.h>
+#include <UikonInternalPSKeys.h>
+#include <avkondomainpskeys.h>
+#include <AknSettingCache.h>
+#include "AknCapServerEntry.h"
+#include <aknconsts.h>
+#include "winchangemonitor.h"
+#include "akncapserverdebug.h"
+#include "akncompaif.h"
+
+#include <AknsConstants.h>
+#include <AknsUtils.h>
+#include <AknIconUtils.h>
+#include <AknUtils.h>
+#include <aknlayoutscalable_avkon.cdl.h>
+#include "avkoninternalpskeys.h"
+#include <layoutmetadata.cdl.h>
+#include <AknTaskList.h>
+#ifdef RD_UI_TRANSITION_EFFECTS_LAYOUT_SWITCH
+#include <akntranseffect.h>
+#include <akntransitionutils.h>
+#endif
+
+#include <LayoutPack.cdl.h>
+#include <CdlRefs.h>
+const TInt KCdlEComInterfaceId = 0x101f8243;
+
+const TInt KLayoutChangeTimeout = 2000000; // 2s
+const TInt KWgStatesGranularity = 4;
+const TInt KRelinquishedThreadListGranularity = 4;
+const TInt KRemoveBlankDelay = 200000; // 0.2s
+// Drawing is slower when transparency is enabled. The time needs to be
+// big enough to account for slowest drawing application.
+const TInt KRemoveBlankDelayTransparency = 1500000; // 1.5s
+
+// 4s should be enough for foreground app's operations to complete.
+const TInt KRestoreThreadPriorityDelay = 4000000;
+
+// Screensaver application UID
+const TUid KScreensaverAppUid = { 0x100056CF };
+
+// Read pass policy
+_LIT_SECURITY_POLICY_PASS(KPassReadPolicy);
+
+// Policy requiring write device data capability.
+_LIT_SECURITY_POLICY_C1(KWriteDDPolicy, ECapabilityWriteDeviceData);
+
+enum TWgStateFlags
+ {
+ EWgStateFullScreen,
+ EWgStatePartialForeground,
+ EWgStateUnderstandsPartialForeground,
+ EWgStateLegacyLayout,
+ EWgStateOrientationSpecified,
+ EWgStateOrientationLandscape
+ };
+
+enum TSetLayoutBlankStep
+ {
+ ESetLayoutBlankBeforeLayoutLoad,
+ ESetLayoutBlankBetweenLayoutLoadAndScreenRotate,
+ ESetLayoutBlankAfterScreenRotate,
+ ESetLayoutBlankNever
+ };
+
+NONSHARABLE_CLASS(CAknSgcServerImpl) : public CAknSgcImpl
+ {
+public:
+ CAknSgcServerImpl(CEikSgcServer* aServer);
+ void MoveApp(TInt aAppWindowGroupId, TSgcMoveAppToWhere aWhere);
+
+private:
+ CEikSgcServer* iServer;
+ };
+
+
+class CLayoutChangeCallBack : public CActive
+ {
+public:
+ CLayoutChangeCallBack(CEikSgcServer* aSgc);
+ void ConstructL();
+ ~CLayoutChangeCallBack();
+
+ void RestartTimerL();
+
+private:
+ void DoCancel();
+ void RunL();
+
+ static TInt ThreadFunc(TAny* aStat);
+
+ static TInt TimeoutCallback(TAny* aThis);
+ void DoTimeout();
+
+private:
+ CEikSgcServer* iSgc;
+ RThread iThread;
+ TThreadId iMain;
+ CPeriodic* iTimeout;
+ };
+
+CLayoutChangeCallBack::CLayoutChangeCallBack(CEikSgcServer* aSgc)
+: CActive(CActive::EPriorityLow), iSgc(aSgc), iMain(RThread().Id())
+ {
+ CActiveScheduler::Add(this);
+ }
+
+void CLayoutChangeCallBack::ConstructL()
+ {
+ // Create the thread.
+ User::LeaveIfError(iThread.Create(KNullDesC, ThreadFunc, 0x400, NULL, this));
+ iThread.SetPriority(EPriorityAbsoluteBackground);
+
+ // Set the active status & start the thread.
+ iStatus = KRequestPending;
+ SetActive();
+ iThread.Resume();
+
+ RestartTimerL();
+ }
+
+void CLayoutChangeCallBack::RestartTimerL()
+ {
+ delete iTimeout;
+ iTimeout = NULL;
+ iTimeout = CPeriodic::NewL(CActive::EPriorityStandard);
+ iTimeout->Start(KLayoutChangeTimeout, KLayoutChangeTimeout, TCallBack(TimeoutCallback, this));
+ }
+
+CLayoutChangeCallBack::~CLayoutChangeCallBack()
+ {
+ Cancel();
+ iThread.Close();
+ delete iTimeout;
+ }
+
+void CLayoutChangeCallBack::DoCancel()
+ {
+ iThread.Terminate(0);
+
+ // Only complete the request if not yet completed by the background thread.
+ if ( iStatus == KRequestPending )
+ {
+ TRequestStatus* pStatus = &iStatus;
+ User::RequestComplete(pStatus, KErrCancel);
+ }
+ }
+
+void CLayoutChangeCallBack::RunL()
+ {
+ iSgc->HandleLayoutChangeCallBackL();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CLayoutChangeCallBack::ThreadFunc
+// Thread entry point function.
+// ---------------------------------------------------------------------------
+//
+TInt CLayoutChangeCallBack::ThreadFunc( TAny* aLayoutChangeCallBack )
+ {
+ CLayoutChangeCallBack* self =
+ static_cast<CLayoutChangeCallBack*>(aLayoutChangeCallBack);
+ RThread main;
+ if (KErrNone == main.Open(self->iMain))
+ {
+ TRequestStatus* pStatus = &self->iStatus;
+ main.RequestComplete(pStatus, KErrNone);
+ main.Close();
+ }
+ return KErrNone;
+ }
+
+TInt CLayoutChangeCallBack::TimeoutCallback( TAny* aThis )
+ {
+ static_cast<CLayoutChangeCallBack*>( aThis )->DoTimeout();
+ return EFalse;
+ }
+
+void CLayoutChangeCallBack::DoTimeout()
+ {
+ TRAP_IGNORE( iSgc->HandleLayoutChangeCallBackL() );
+ }
+
+
+CEikSgcServer::TWgState::TWgState()
+: iWgId(0), iSpLayout(0), iSpFlags(0), iAppScreenMode(KAknScreenModeUnset)
+ {
+ // Default state for window groups is full screen - handles non
+ // avkon apps.
+ iFlags.Set(EWgStateFullScreen);
+ }
+
+CEikSgcServer::TWgState::TWgState(TInt aWgId)
+: iWgId(aWgId), iSpLayout(0), iSpFlags(0), iAppScreenMode(KAknScreenModeUnset)
+ {
+ // Default state for window groups is full screen - handles non
+ // avkon apps.
+ iFlags.Set(EWgStateFullScreen);
+ }
+
+inline TInt CEikSgcServer::TWgState::WgId() const
+ {
+ return iWgId;
+ }
+
+inline void CEikSgcServer::TWgState::SetWgId(TInt aWgId)
+ {
+ iWgId = aWgId;
+ }
+
+inline TInt CEikSgcServer::TWgState::SpLayout() const
+ {
+ return iSpLayout;
+ }
+
+inline void CEikSgcServer::TWgState::SetSpLayout(TInt aSpLayout)
+ {
+ iSpLayout = aSpLayout;
+ }
+
+inline TInt CEikSgcServer::TWgState::SpFlags() const
+ {
+ return iSpFlags;
+ }
+
+inline void CEikSgcServer::TWgState::SetSpFlags(TInt aSpFlags)
+ {
+ iSpFlags = aSpFlags;
+ }
+
+inline TBool CEikSgcServer::TWgState::IsFullScreen() const
+ {
+ return iFlags[EWgStateFullScreen];
+ }
+
+inline void CEikSgcServer::TWgState::SetFullScreen(TBool aFullScreen)
+ {
+ iFlags.Assign(EWgStateFullScreen, aFullScreen);
+ }
+
+inline TBool CEikSgcServer::TWgState::IsPartialForeground() const
+ {
+ return iFlags[EWgStatePartialForeground];
+ }
+
+inline void CEikSgcServer::TWgState::SetPartialForeground(TBool aPartialForeground)
+ {
+ iFlags.Assign(EWgStatePartialForeground, aPartialForeground);
+ }
+
+inline TBool CEikSgcServer::TWgState::UnderstandsPartialForeground() const
+ {
+ return iFlags[EWgStateUnderstandsPartialForeground];
+ }
+
+inline void CEikSgcServer::TWgState::SetUnderstandsPartialForeground(TBool aPartialForeground)
+ {
+ iFlags.Assign(EWgStateUnderstandsPartialForeground, aPartialForeground);
+ }
+
+inline TBool CEikSgcServer::TWgState::IsLegacyLayout() const
+ {
+ return iFlags[EWgStateLegacyLayout];
+ }
+
+inline void CEikSgcServer::TWgState::SetLegacyLayout(TBool aLegacyLayout)
+ {
+ iFlags.Assign(EWgStateLegacyLayout, aLegacyLayout);
+ }
+
+inline TBool CEikSgcServer::TWgState::IsOrientationSpecified() const
+ {
+ return iFlags[EWgStateOrientationSpecified];
+ }
+
+inline void CEikSgcServer::TWgState::SetOrientationSpecified(TBool aOrientationSpecified)
+ {
+ iFlags.Assign(EWgStateOrientationSpecified, aOrientationSpecified);
+ }
+
+inline TBool CEikSgcServer::TWgState::IsOrientationLandscape() const
+ {
+ return iFlags[EWgStateOrientationLandscape];
+ }
+
+inline void CEikSgcServer::TWgState::SetOrientationLandscape(TBool aOrientationLandscape)
+ {
+ iFlags.Assign(EWgStateOrientationLandscape, aOrientationLandscape);
+ }
+
+inline TInt CEikSgcServer::TWgState::AppScreenMode() const
+ {
+ return iAppScreenMode;
+ }
+
+inline void CEikSgcServer::TWgState::SetAppScreenMode(TInt aAppScreenMode)
+ {
+ iAppScreenMode = aAppScreenMode;
+ }
+
+CEikSgcServer* CEikSgcServer::NewL()
+ {
+ CEikSgcServer* self = new(ELeave) CEikSgcServer();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CEikSgcServer::CEikSgcServer()
+: iWs(CEikonEnv::Static()->WsSession()),
+ iLastScreenModeSet(-1),
+ iRelinquishedThreads(KRelinquishedThreadListGranularity),
+ iSetLayoutBlankStep(ESetLayoutBlankBeforeLayoutLoad)
+ {
+ }
+
+void CEikSgcServer::ConstructL()
+ {
+ iWgStates = new(ELeave) CWgStates(KWgStatesGranularity);
+
+ TInt err = RProperty::Define(KPSUidUikon, KUikPreferredOrientation, RProperty::EInt);
+ User::LeaveIfError(err);
+
+ err = RProperty::Define(
+ KPSUidAvkonDomain,
+ KAknNotificationsInIdleAllowed,
+ RProperty::EInt,
+ KPassReadPolicy,
+ KWriteDDPolicy);
+ User::LeaveIfError(err);
+#if FADE_BITMAP
+
+ err = RProperty::Define(KPSUidAvkonInternal, KAknFadeBitmapHandle,
+ RProperty::EInt,
+ KPassReadPolicy,
+ KWriteDDPolicy);
+ User::LeaveIfError(err);
+ err = RProperty::Define(KPSUidAvkonInternal, KAknFadeMaskHandle,
+ RProperty::EInt,
+ KPassReadPolicy,
+ KWriteDDPolicy);
+ User::LeaveIfError(err);
+#endif
+
+ err = RProperty::Define(KPSUidAvkonInternal, KAknFadeColorHandle,
+ RProperty::EInt,
+ KPassReadPolicy,
+ KWriteDDPolicy);
+ User::LeaveIfError(err);
+
+ err = RProperty::Define(KPSUidAvkonInternal, KAknFadeBlackMapHandle,
+ RProperty::EInt,
+ KPassReadPolicy,
+ KWriteDDPolicy);
+ User::LeaveIfError(err);
+ err = RProperty::Define(KPSUidAvkonInternal, KAknFadeWhiteMapHandle,
+ RProperty::EInt,
+ KPassReadPolicy,
+ KWriteDDPolicy);
+ User::LeaveIfError(err);
+
+
+
+
+#ifndef TFX_USE_WCHANGE_EVENT
+ iWinChange = CWindowChangeMonitor::NewL(iWs);
+#endif
+
+ CAknSgcServerImpl* sgcImpl = new(ELeave) CAknSgcServerImpl(this);
+ // CAknSgcClient takes ownership of sgcImpl and replaces
+ // existing client impl with it.
+ CAknSgcClient::SetImpl(sgcImpl);
+
+ // Touch compatibility mode
+ iAvkonAppUiBase->MopGetObjectNoChaining(iTouchCompaModeIf);
+ iTouchCompaScreenMode = KErrNotFound;
+ if (iTouchCompaModeIf)
+ {
+ iTouchCompaScreenMode = iTouchCompaModeIf->FindCompaScreenMode();
+ }
+
+ // ECom notifier for ILD installations
+ TCallBack callback(CEikSgcServer::LayoutInstallationCallBack, this);
+ iLayoutNotifier = CEComPluginNotifier::NewL(KNullUid, callback);
+ iLayoutNotifier->Start();
+ EComPluginUtils::GetInfoArrayL(TUid::Uid(KCdlEComInterfaceId), iPrevPluginInfo);
+ }
+
+TInt CEikSgcServer::LayoutInstallationCallBack(TAny* aPtr)
+ {
+ return ((CEikSgcServer*)aPtr)->RefreshLayoutIfRequiredL();
+ }
+
+TInt CEikSgcServer::RefreshLayoutIfRequiredL()
+ {
+ REComPluginInfoArray newPlugins;
+ EComPluginUtils::GetInfoArrayL(TUid::Uid(KCdlEComInterfaceId), newPlugins);
+ REComPluginInfoArray newPluginsCopy = newPlugins;
+
+ // Remove any plugins that haven't changed from the arrays
+ TInt prevCount = iPrevPluginInfo.Count();
+ while(prevCount > 0)
+ {
+ prevCount--;
+ TUid prevUid = (iPrevPluginInfo[prevCount]).iUid;
+ TInt prevVer = (iPrevPluginInfo[prevCount]).iVersion;
+ TInt newCount = newPlugins.Count();
+ while(newCount > 0)
+ {
+ newCount--;
+ TUid newUid = (newPlugins[newCount]).iUid;
+ TInt newVer = (newPlugins[newCount]).iVersion;
+ if(prevUid == newUid && prevVer == newVer)
+ {
+ newPlugins.Remove(newCount);
+ iPrevPluginInfo.Remove(prevCount);
+ break;
+ }
+ }
+ }
+
+ TBool refreshRequired = EFalse;
+ if(iPrevPluginInfo.Count() > 0)
+ {
+ // A plugin has been removed, but we can't check what it contained.
+ refreshRequired = ETrue;
+ }
+ else
+ {
+ // Check through the changed plugins to see whether any contain layout packs
+ _LIT(KLitDllPath, "%S%08x.dll");
+ const TInt KPathLength = 14; // Drive letter + ":" + UID + ".dll"
+ for(TInt i=0; i<newPlugins.Count(); i++)
+ {
+ TEComPluginInfo imp = newPlugins[i];
+ TBuf<KPathLength> buf;
+ TDriveName drive(imp.iDrive.Name());
+ buf.Format(KLitDllPath, &drive, imp.iUid.iUid);
+
+ CCdlRefCollection* refsInFile = CdlEngine::FileContentsLC(buf);
+ CCdlRefs* refs = CCdlRefs::NewLC();
+ refs->AppendL(*refsInFile);
+ CCdlRefs* layoutsInFile = refs->SubsetByUidLC(LayoutPack::KCdlInterfaceUid);
+ TInt numLayouts = layoutsInFile->CountRefs();
+ CleanupStack::PopAndDestroy(3, refsInFile);
+
+ if(numLayouts > 0)
+ {
+ // Plugin added with layouts, refresh required
+ refreshRequired = ETrue;
+ break;
+ }
+ }
+ }
+
+ // Send the event if it's needed
+ TInt result = KErrNone;
+ if(refreshRequired)
+ {
+ RWsSession session;
+ TInt err = session.Connect();
+ if ( err == KErrNone )
+ {
+ TWsEvent event;
+ event.SetType(KAknILDInstallationLayoutSwitch);
+ result = session.SendEventToAllWindowGroups(event);
+ session.Close();
+ }
+ }
+
+ // Store the copy of the new list of plugins for next time
+ iPrevPluginInfo.Reset();
+ iPrevPluginInfo = newPluginsCopy;
+
+ return result;
+ }
+
+CEikSgcServer::~CEikSgcServer()
+ {
+ delete iFadeBitmap;
+ delete iFadeMask;
+
+ delete iWinChange;
+ delete iLayoutChangeCallBack;
+ delete iWgStates;
+ delete iRemoveBlankCallBack;
+ delete iLayoutNotifier;
+ }
+
+void CEikSgcServer::HandleWindowGroupListChangeL()
+ {
+ CWgIds* wgIds = CreateWgIdListLC();
+ if (!TestWgListOrderOk(wgIds))
+ {
+ ReOrderWgStatesL(wgIds);
+ PostChangeRecalcL();
+ UpdateNotificationsInIdleAllowedKey();
+ }
+ CleanupStack::PopAndDestroy( wgIds );
+ }
+
+void CEikSgcServer::HandleWindowGroupParamChangeL(TInt aWgId, TBitFlags aAppFlags, TInt aSpLayout,
+ TInt aSpFlags, TInt aAppScreenMode)
+ {
+ LOGTEXT0("CEikSgcServer::HandleWindowGroupParamChangeL - ENTER");
+
+ TBool understandsPartialForegroundChanged = EFalse;
+ TBool fullScreenChanged = EFalse;
+
+ TWgState& state = GetWgStateL(aWgId);
+
+ const TBool wasFullScreen = state.IsFullScreen();
+ state.SetFullScreen(aAppFlags[CAknSgcClient::EFullScreen]);
+ const TBool isFullScreen = state.IsFullScreen();
+
+ state.SetLegacyLayout(aAppFlags[CAknSgcClient::ELegacyLayout]);
+ state.SetSpLayout(aSpLayout);
+ state.SetSpFlags(aSpFlags);
+
+ // Check whether understands partial foreground is changed.
+ if (!state.UnderstandsPartialForeground())
+ {
+ understandsPartialForegroundChanged = ETrue;
+ }
+ state.SetUnderstandsPartialForeground(ETrue);
+
+ state.SetOrientationSpecified(aAppFlags[CAknSgcClient::EOrientationSpecified]);
+ state.SetOrientationLandscape(aAppFlags[CAknSgcClient::EOrientationLandscape]);
+ state.SetAppScreenMode(aAppScreenMode);
+ PostChangeRecalcL();
+
+ // Check whether full screen mode has been changed.
+ fullScreenChanged = (wasFullScreen && !isFullScreen) || (!wasFullScreen && isFullScreen);
+
+ if (understandsPartialForegroundChanged || fullScreenChanged)
+ {
+ LOGTEXT1(" understandsPartialForegroundChanged: %d", understandsPartialForegroundChanged);
+ LOGTEXT1(" fullScreenChanged: %d", fullScreenChanged);
+
+ UpdateNotificationsInIdleAllowedKey();
+ }
+
+ LOGTEXT0("CEikSgcServer::HandleWindowGroupParamChangeL - EXIT");
+ }
+
+CEikSgcServer::TWgState& CEikSgcServer::GetWgStateL(TInt aWgId)
+ {
+ TInt index = WgStateIndex(aWgId);
+ if (index == KErrNotFound)
+ {
+ iWgStates->AppendL(TWgState(aWgId));
+ index = iWgStates->Count()-1;
+ }
+ return iWgStates->At(index);
+ }
+
+TInt CEikSgcServer::WgStateIndex(TInt aWgId) const
+ {
+ TInt count = iWgStates->Count();
+ for (TInt ii=0; ii<count; ii++)
+ {
+ if (iWgStates->At(ii).WgId() == aWgId)
+ {
+ return ii;
+ }
+ }
+ return KErrNotFound;
+ }
+
+CEikSgcServer::CWgIds* CEikSgcServer::CreateWgIdListLC() const
+ {
+ CWgIds* wgIds = new(ELeave) CWgIds(1);
+ CleanupStack::PushL(wgIds);
+ iWs.WindowGroupList(wgIds);
+ return wgIds;
+ }
+
+void CEikSgcServer::ReOrderWgStatesL(CWgIds* aWgIds)
+ {
+ CWgStates* newStates = new(ELeave) CWgStates(KWgStatesGranularity);
+ CleanupStack::PushL(newStates);
+ TInt count = aWgIds->Count();
+ newStates->ResizeL(count);
+ for (TInt ii=0; ii<count; ii++)
+ {
+ newStates->At(ii) = GetWgStateL(aWgIds->At(ii));
+ }
+ CleanupStack::Pop(newStates);
+ delete iWgStates;
+ iWgStates = newStates;
+ }
+
+void CEikSgcServer::SetStatusPaneShapeAndFlagsL(TInt aSpIndex)
+ {
+ if (aSpIndex == KErrNotFound)
+ {
+ return;
+ }
+ TWgState& topState = iWgStates->At(aSpIndex);
+
+ TInt layout = topState.SpLayout();
+ if (iLayout != layout)
+ {
+ iSp->SwitchLayoutL(layout);
+ iLayout = layout;
+ }
+
+ TInt flags = topState.SpFlags();
+ if (iFlags != flags)
+ {
+ iSp->SetFlags(flags);
+ iFlags = flags;
+ }
+ }
+
+#ifndef TFX_USE_WCHANGE_EVENT
+void CEikSgcServer::ActivateEffectL()
+ {
+ if(iWinChange == NULL)
+ {
+ return; // nobody there
+ }
+
+// CWindowChangeMonitor::TWinGroupEvent event =
+// iWinChange->WinGroupEvent();
+
+ const TInt index = FocusWgIndex();
+ //WgStateIndex(iWinChange-> GetFocusWg());
+
+ const TInt focusWgIndex = index < 0 ? 0 : index;
+
+ const TInt count = iWgStates->Count();
+
+ for (TInt i = focusWgIndex; i < count; i++)
+ {
+ const TWgState& state = iWgStates->At(focusWgIndex);
+ const TInt wgId = state.WgId();
+
+ if(state.UnderstandsPartialForeground())
+ {
+ if(wgId != iFirstFullScreenWg)
+ {
+ iWinChange->WgChangeL(wgId);
+ }
+
+ // Note that exits also for non fullscreen (unlike SetPartialForegroundStatusesL).
+ return;
+ }
+ }
+ }
+#endif
+
+void CEikSgcServer::SetPartialForegroundStatusesL()
+ {
+ TInt count = iWgStates->Count();
+ TInt ii;
+ TBool partialFg = EFalse;
+ for (ii = FocusWgIndex(); ii < count; ii++)
+ {
+ TWgState& state = iWgStates->At(ii);
+ if (state.UnderstandsPartialForeground())
+ {
+ if (partialFg)
+ {
+ SetWgPartialFg(state);
+ }
+ if (!state.IsFullScreen())
+ {
+ partialFg = ETrue;
+ }
+ else
+ {
+ // Notify first full-screen app that it is topmost application though does not
+ // have kb focus.
+ if (iFirstFullScreenWg != iWgStates->At(ii).WgId() )
+ {
+ // same event instance will be recycled for both of events...
+ TWsEvent event;
+ event.SetTimeNow();
+
+ if (iFirstFullScreenWg) // notify old that it has lost its focus
+ {
+ event.SetType(KAknFullOrPartialForegroundLost);
+ iWs.SendEventToWindowGroup(iFirstFullScreenWg, event);
+ }
+
+ iFirstFullScreenWg = iWgStates->At(ii).WgId();
+ event.SetType(KAknFullOrPartialForegroundGained);
+ iWs.SendEventToWindowGroup(iFirstFullScreenWg, event);
+ }
+ break;
+ }
+ }
+ }
+ for (++ii; ii<count; ii++)
+ {
+ TWgState& state = iWgStates->At(ii);
+ if (state.UnderstandsPartialForeground())
+ {
+ ClearWgPartialFg(state);
+ }
+ }
+
+#ifndef TFX_USE_WCHANGE_EVENT
+ if(iWinChange != NULL)
+ {
+ iWinChange->SetWgL(iFirstFullScreenWg);
+ }
+#endif
+ }
+
+void CEikSgcServer::PostChangeRecalcL()
+ {
+#ifndef TFX_USE_WCHANGE_EVENT
+ ActivateEffectL();
+#endif
+
+ TInt topSp = TopSpIndex();
+ SetLayoutL(topSp);
+ SetStatusPaneShapeAndFlagsL(topSp);
+ SetPartialForegroundStatusesL();
+ }
+
+TBool CEikSgcServer::TestWgListOrderOk(CWgIds* aWgIds) const
+ {
+ TInt count = aWgIds->Count();
+ if (count != iWgStates->Count())
+ {
+ return EFalse;
+ }
+ for (TInt ii = 0; ii < count; ii++)
+ {
+ if (aWgIds->At(ii) != iWgStates->At(ii).WgId())
+ {
+ return EFalse;
+ }
+ }
+ return ETrue;
+ }
+
+TInt CEikSgcServer::FocusWgIndex() const
+ {
+ TInt index = WgStateIndex(iWs.GetFocusWindowGroup());
+ if (index == KErrNotFound)
+ {
+ index = 0;
+ }
+ return index;
+ }
+
+void CEikSgcServer::SetWgPartialFg(TWgState& aWgState)
+ {
+ if (!aWgState.IsPartialForeground())
+ {
+ aWgState.SetPartialForeground(ETrue);
+ }
+ }
+
+void CEikSgcServer::ClearWgPartialFg(TWgState& aWgState)
+ {
+ if (aWgState.IsPartialForeground())
+ {
+ aWgState.SetPartialForeground(EFalse);
+ }
+ }
+
+void CEikSgcServer::SetStatusPane(CEikServStatusPane* aSp)
+ {
+ ASSERT(aSp);
+ iSp = aSp;
+ iSpWg = aSp->WindowGroup();
+ }
+
+TInt CEikSgcServer::TopSpIndex(TInt aAfter) const
+ {
+ TInt count = iWgStates->Count();
+ for (TInt topSp=aAfter+1; topSp<count; topSp++)
+ {
+ if (iWgStates->At(topSp).SpLayout())
+ {
+ return topSp;
+ }
+ }
+ return KErrNotFound;
+ }
+
+void CEikSgcServer::PrepareForAppExitL(TInt aWgId)
+ {
+ TInt topSp = TopSpIndex();
+ if (topSp != KErrNotFound)
+ {
+ TWgState& topState = iWgStates->At(topSp);
+ if (topState.WgId() == aWgId)
+ {
+ TInt focusWg = FocusWgIndex();
+ if (focusWg != KErrNotFound && iWgStates->At(focusWg).IsPartialForeground())
+ { // we trust that wg order is valid at this point.
+ if ( focusWg < iWgStates->Count()-1 )
+ {
+ TWsEvent event;
+ event.SetType(EEventUser);
+ *(TApaSystemEvent*)(event.EventData())=EApaSystemEventBroughtToForeground;
+ event.SetTimeNow();
+ iWs.SendEventToWindowGroup(iWgStates->At(focusWg+1).WgId(), event);
+ }
+ }
+
+ // remove the status pane from the exiting wg
+ topState.SetSpLayout(0);
+
+ // Set the status pane to the shape for the app below
+ topSp = TopSpIndex(topSp);
+ SetLayoutL(topSp);
+ SetStatusPaneShapeAndFlagsL(topSp);
+ if (iSp)
+ {
+ iSp->PrepareForAppExit();
+ }
+ }
+ }
+ }
+
+#define FADE_COLOR_17 1
+//#define FADE_COLOR_TEXT 1
+
+inline TUint8 GetColorIntensity(TUint32 aColor)
+ {
+ // Separate R, G, B
+ register TUint32 r = (aColor >> 16) & 0xFF;
+ register TUint32 g = (aColor >> 8) & 0xFF;
+ register TUint32 b = (aColor) & 0xFF;
+
+ // Calculate and return intensity
+ return TUint8( (r*306 + g*601 + b*117) >> 10 );
+ }
+
+void CEikSgcServer::FadeColorGenerationL()
+ {
+ MAknsSkinInstance *skin = AknsUtils::SkinInstance();
+ bool b = false;
+#if FADE_COLOR_17
+ TAknsItemID skinid = KAknsIIDQsnOtherColors;
+ TRgb colorrgb;
+ TInt err = AknsUtils::GetCachedColor(skin, colorrgb, skinid, 19-1);
+ if (err != KErrNone)
+ {
+ colorrgb = TRgb(255,255,255,0);
+
+ CFbsBitmap *bitmap=NULL, *mask=NULL;
+ TAknsItemID skinid = KAknsIIDQsnFrPopupCenter ;
+ TRAP(err, AknsUtils::CreateIconL(skin, skinid, bitmap, mask, _L(""), -1, -1));
+ if (err == KErrNone)
+ {
+ TSize size(30,30);
+ AknIconUtils::DisableCompression(bitmap);
+ AknIconUtils::SetSize(bitmap, size, EAspectRatioNotPreserved);
+ TPoint point(15,15);
+
+ //TBuf8<4> buf;
+ //bitmap->GetScanLine(buf, point, 1, bitmap->DisplayMode());
+ //colorrgb = TRgb(buf[3], buf[2], buf[1], buf[0]);
+
+ //colorrgb.SetAlpha(buf[0]);
+ //colorrgb.SetBlue(buf[1]);
+ //colorrgb.SetGreen(buf[2]);
+ //colorrgb.SetRed(buf[3]);
+ bitmap->GetPixel(colorrgb, point);
+
+ delete bitmap;
+ delete mask;
+ b=true;
+ }
+ }
+ TRgb blackmap, whitemap;
+ TInt err1 = AknsUtils::GetCachedColor(skin, blackmap, skinid, 17-1);
+ TInt err2 = AknsUtils::GetCachedColor(skin, whitemap, skinid, 18-1);
+
+ if (err1 != KErrNone) blackmap = TRgb(0,0,0,0);
+ if (err2 != KErrNone) whitemap = TRgb(255,255,255,0);
+
+ TInt blackcolor = (blackmap.Red()<<16) + (blackmap.Green()<<8) + blackmap.Blue();
+ TInt whitecolor = (whitemap.Red()<<16) + (whitemap.Green()<<8) + whitemap.Blue();
+
+ TInt blackmapint = GetColorIntensity(blackcolor);
+ TInt whitemapint = GetColorIntensity(whitecolor);
+
+#endif
+
+#if FADE_COLOR_TEXT
+ TAknsItemID skinid = KAknsIIDQsnOtherColors;
+ TRgb colorrgb;
+ TInt err = AknsUtils::GetCachedColor(skin, colorrgb, skinid, 17);
+ if (err != KErrNone)
+ {
+
+ TAknsItemID skinid = KAknsIIDQsnTextColors ;
+ TInt err = AknsUtils::GetCachedColor(skin, colorrgb, skinid, EAknsCIQsnTextColorsCG19 );
+ }
+ TInt blackmapint = 0;
+ TInt whitemapint = 255;
+#endif
+
+ TInt color = (colorrgb.Red()<<16) + (colorrgb.Green()<<8) + colorrgb.Blue();
+
+ if (b)
+ {
+ TInt intensity = GetColorIntensity(color);
+ if (intensity < 127)
+ { // background color dark
+ blackmapint = 0;
+ whitemapint = 64;
+ color = 0xffffff;
+ }
+ else
+ {
+ blackmapint = 192;
+ whitemapint = 255;
+ color = 0xffffff;
+ }
+ }
+ RProperty::Set(KPSUidAvkonInternal, KAknFadeBlackMapHandle, blackmapint);
+ RProperty::Set(KPSUidAvkonInternal, KAknFadeWhiteMapHandle, whitemapint);
+ RProperty::Set(KPSUidAvkonInternal, KAknFadeColorHandle, color);
+
+ }
+
+void CEikSgcServer::FadeBitmapGenerationL()
+ {
+#if FADE_BITMAP
+ //
+ // Generates bitmap and mask for fade wserv plugin and
+ // publishes them in publish&subscribe.
+ //
+ delete iFadeBitmap;
+ delete iFadeMask;
+ iFadeBitmap = NULL;
+ iFadeMask = NULL;
+
+ MAknsSkinInstance *skin = AknsUtils::SkinInstance();
+
+ TInt err= KErrNone;
+ if (!Layout_Meta_Data::IsLandscapeOrientation())
+ {
+ TAknsItemID skinid = KAknsIIDQgnGrafBgDimmingPrt; // TODO
+ TRAP(err, AknsUtils::CreateIconL(skin, skinid, iFadeBitmap, iFadeMask, _L(""), -1, -1));
+ }
+ else
+ {
+ TAknsItemID skinid = KAknsIIDQgnGrafBgDimmingLsc; // TODO
+ TRAP(err, AknsUtils::CreateIconL(skin, skinid, iFadeBitmap, iFadeMask, _L(""), -1, -1));
+ }
+ if (err != KErrNone)
+ {
+ TAknsItemID skinid = KAknsIIDQgnGrafBgDimming ; // TODO
+ TRAP(err, AknsUtils::CreateIconL(skin, skinid, iFadeBitmap, iFadeMask, _L(""), -1, -1));
+ }
+
+ if (err == KErrNone)
+ { // found from skins
+
+ TRect rect = TRect(0,0,0,0);
+ TAknLayoutRect r;
+ r.LayoutRect(rect, AknLayoutScalable_Avkon::Screen().LayoutLine());
+ TSize size = r.Rect().Size();
+
+ AknIconUtils::SetSize(iFadeBitmap, size, EAspectRatioNotPreserved);
+
+
+ TInt bitmaphandle = iFadeBitmap->Handle();
+ TInt maskhandle = iFadeMask->Handle();
+ RProperty::Set(KPSUidAvkonInternal, KAknFadeBitmapHandle, bitmaphandle);
+ RProperty::Set(KPSUidAvkonInternal, KAknFadeMaskHandle, maskhandle);
+ }
+#endif
+ }
+void CEikSgcServer::SetLayoutL(TInt aSpIndex)
+ {
+ if (aSpIndex == KErrNotFound)
+ {
+ return;
+ }
+
+ TWgState& topState = iWgStates->At(aSpIndex);
+
+ CEikonEnv* eikEnv = CEikonEnv::Static();
+
+ CAknLayoutConfig::TScreenMode mode = CAknSgcClient::CalculateScreenMode(
+ ETrue,
+ topState.IsOrientationSpecified(),
+ topState.IsOrientationLandscape(),
+ topState.AppScreenMode());
+
+ TInt modeIndex = mode.ModeNumber();
+ TBool blank = iLastScreenModeSet != -1;
+ if (modeIndex != iLastScreenModeSet)
+ {
+
+ // Touch compatibility mode. Disable transition effects if compa-mode
+ // application becomes foreground. Restore back in opposite case.
+ if (iTouchCompaModeIf)
+ {
+ // Disable or restore transition
+ iTouchCompaModeIf->DisableTransEffects(
+ iTouchCompaScreenMode == modeIndex);
+ }
+
+ TBool tfxOn = EFalse;
+#ifdef RD_UI_TRANSITION_EFFECTS_LAYOUT_SWITCH
+ tfxOn = CAknTransitionUtils::TransitionsEnabled(
+ AknTransEffect::ELayoutswitchTransitionsOff );
+ if ( tfxOn )
+ {
+ iSetLayoutBlankStep = ESetLayoutBlankAfterScreenRotate;
+ }
+ else
+ {
+ iSetLayoutBlankStep = ESetLayoutBlankBeforeLayoutLoad;
+ }
+#endif
+
+ if (!tfxOn)
+ eikEnv->WsSession().ClearAllRedrawStores();
+
+ // If AknNfySrv or EikSrv is displaying a global note,
+ // the screen blanker is allowed to stay on until it times
+ // out (like when AknCapSrv is displaying a note).
+ TInt blankCnt = 1;
+ if (IsGlobalNoteForeground())
+ {
+ // For some reason, AknNfySrv and EikSrv unblank twice on target hardware.
+ // therefore blank is done 3 times to allow it to remain on until timeout.
+ blankCnt += 2;
+ }
+
+ SetLayoutBlankScreenL(blank, ESetLayoutBlankBeforeLayoutLoad,
+ blankCnt);
+
+ const TAknLayoutConfigScreenMode& modeRef = (const TAknLayoutConfigScreenMode&) mode;
+ TBool newLayoutLoaded = CAknEnv::Static()->LoadAknLayoutL(modeRef);
+
+ FadeBitmapGenerationL();
+ FadeColorGenerationL();
+ SetLayoutBlankScreenL(blank, ESetLayoutBlankBetweenLayoutLoadAndScreenRotate);
+
+ if (tfxOn)
+ eikEnv->WsSession().ClearAllRedrawStores();
+
+ // if layout change is preemptive for app change, move the app here
+ DoMoveApp();
+
+ // Set wserv screen mode
+ iLastScreenModeSet = modeIndex;
+ eikEnv->ScreenDevice()->SetScreenMode(modeIndex);
+
+ SetLayoutBlankScreenL(blank, ESetLayoutBlankAfterScreenRotate,
+ blankCnt);
+
+ // Set legacy mode in eiksrv app UI
+ iAvkonAppUiBase->SetLayoutAwareApp(!topState.IsLegacyLayout());
+
+ // Start callback for handling new layout
+ if (newLayoutLoaded)
+ {
+ // Swap the screen blanker to update the foreground app's layout
+ if (blank && iSetLayoutBlankStep < ESetLayoutBlankAfterScreenRotate)
+ {
+ iAknCapAppServerAppUi->SwapLayoutSwitchBlankScreenL();
+ }
+
+ CAknAppUi* appUi = static_cast<CAknAppUi*>(eikEnv->EikAppUi());
+ if (appUi->IsForeground())
+ {
+ for (; appUi; appUi = static_cast<CAknAppUi*>(appUi->ContainerAppUi()))
+ {
+ appUi->ReportResourceChangedToAppL(KEikDynamicLayoutVariantSwitch);
+ }
+ }
+
+ if (iLayoutChangeCallBack)
+ {
+ // Restart the app delay callback timer if another layout change has happened
+ // before it triggers.
+ iLayoutChangeCallBack->RestartTimerL();
+ }
+ else
+ {
+ iLayoutChangeCallBack = new(ELeave) CLayoutChangeCallBack(this);
+ iLayoutChangeCallBack->ConstructL();
+ }
+
+ // stop any existing timer to unblank the screen, iLayoutChangeCallBack will restart it
+ delete iRemoveBlankCallBack;
+ iRemoveBlankCallBack = NULL;
+ }
+ else
+ {
+ if (!iLayoutChangeCallBack && blank)
+ {
+ // The callback will not remove the screen blanker,
+ // so remove it now.
+ iBlankCount--;
+ iAknCapAppServerAppUi->BlankScreenL(EFalse);
+ }
+ }
+ }
+ }
+
+void CEikSgcServer::SetLayoutBlankScreenL(TBool aBlank, TInt aStep)
+ {
+ // Use a screen blanker to hide the screen change
+ if (aBlank && aStep == iSetLayoutBlankStep)
+ {
+ // blank the screen and keep track of how many times it's been blanked
+ iBlankCount++;
+ iAknCapAppServerAppUi->BlankScreenL(ETrue, ETrue);
+ }
+ }
+
+void CEikSgcServer::HandleLayoutChangeCallBackL()
+ {
+ // delete the active object
+ delete iLayoutChangeCallBack;
+ iLayoutChangeCallBack = NULL;
+
+ CEikonEnv* eikEnv = CEikonEnv::Static();
+
+ // Report the layout change to the UI controls
+ for (CEikAppUi* appUi = eikEnv->EikAppUi(); appUi; appUi = appUi->ContainerAppUi())
+ {
+ appUi->ReportResourceChangedToAppL(KEikDynamicLayoutVariantSwitch);
+ }
+
+ // if visible tasklist must be updated during layout change event
+ iAknCapAppServerAppUi->UpdateTaskListL( ETrue );
+
+ // Remove any remaining screen blanker after a delay.
+ // Normally the foreground app will have removed all blanking
+ // before this function triggers. This is really just a backup
+ // in-case the app is behaving badly, or if some unfortuante
+ // timing has caused this function to trigger before the foreground app
+ // finished its redraw. The delay should give the foreground app
+ // sufficient time.
+ iRemoveBlankCount += iBlankCount;
+ iBlankCount = 0;
+ delete iRemoveBlankCallBack;
+ iRemoveBlankCallBack = NULL;
+ iRemoveBlankCallBack = CPeriodic::NewL(CActive::EPriorityLow);
+
+ TInt removeBlankDelay = CAknEnv::Static()->TransparencyEnabled() ?
+ KRemoveBlankDelayTransparency : KRemoveBlankDelay;
+
+ if(iAknCapAppServerAppUi->IsShortTimeGlobalNoteDisplaying())
+ {
+ removeBlankDelay = KRemoveBlankDelay;
+ }
+
+ iRemoveBlankCallBack->Start(
+ removeBlankDelay,
+ removeBlankDelay,
+ TCallBack(RemoveBlankCallBack, this));
+ }
+
+void CEikSgcServer::RelinquishPriorityToForegroundAppL(const RMessage2& aMessage)
+ {
+ // get the client thread
+ SRelinquishedThread rel;
+ aMessage.ClientL(rel.iThread);
+ CleanupClosePushL(rel.iThread);
+ rel.iId = rel.iThread.Id();
+ rel.iPriority = rel.iThread.ProcessPriority();
+
+ // reset the callback timer, ensure that failure does not stop existing timer
+ CPeriodic* newCallBack = CPeriodic::NewL(CActive::EPriorityStandard);
+ delete iRelinquishedThreadCallBack;
+ iRelinquishedThreadCallBack = newCallBack;
+
+ iRelinquishedThreadCallBack->Start(
+ KRestoreThreadPriorityDelay,
+ KRestoreThreadPriorityDelay,
+ TCallBack(RestoreThreadPriorities, this));
+
+ // look for an existing thread
+ TInt count = iRelinquishedThreads.Count();
+ TInt pos;
+ for ( pos = 0; pos < count; pos++ )
+ {
+ if (iRelinquishedThreads[pos].iId == rel.iId)
+ {
+ break;
+ }
+ }
+
+ if (pos<count)
+ {
+ // thread is already recorded. Make sure it's background and stop
+ rel.iThread.SetProcessPriority(EPriorityBackground);
+ CleanupStack::PopAndDestroy(&rel.iThread);
+ }
+ else
+ {
+ // add thread to array
+ iRelinquishedThreads.AppendL(rel);
+ CleanupStack::Pop(&rel.iThread);
+ // set the thread to background priority when all recovery mechanisms are in place
+ rel.iThread.SetProcessPriority(EPriorityBackground);
+ }
+
+ aMessage.Complete(KErrNone);
+ }
+
+TInt CEikSgcServer::RestoreThreadPriorities( TAny* aThis )
+ {
+ static_cast<CEikSgcServer*>( aThis )->DoRestoreThreadPriorities();
+ return EFalse;
+ }
+
+void CEikSgcServer::DoRestoreThreadPriorities()
+ {
+ delete iRelinquishedThreadCallBack;
+ iRelinquishedThreadCallBack = NULL;
+ TInt count = iRelinquishedThreads.Count();
+ for (TInt ii=0; ii<count; ii++)
+ {
+ SRelinquishedThread& rel = iRelinquishedThreads[ii];
+ rel.iThread.SetProcessPriority(rel.iPriority);
+ rel.iThread.Close();
+ }
+ iRelinquishedThreads.Reset();
+ }
+
+void CEikSgcServer::SetAknCapAppServerAppUi(CAknCapAppServerAppUi* aAknCapAppServerAppUi)
+ {
+ iAknCapAppServerAppUi = aAknCapAppServerAppUi;
+ }
+
+void CEikSgcServer::RotateScreenL()
+ {
+ // Toggle preferred orientation
+ TInt orientation;
+ TInt err = RProperty::Get(KPSUidUikon, KUikPreferredOrientation, orientation);
+ User::LeaveIfError(err);
+
+ if (orientation == EPreferredOrientationNormal)
+ {
+ orientation = EPreferredOrientationAlternate;
+ }
+ else // alternate screen orientation
+ {
+ orientation = EPreferredOrientationNormal;
+ }
+
+ err = RProperty::Set(KPSUidUikon, KUikPreferredOrientation, orientation);
+ User::LeaveIfError(err);
+
+ CWsScreenDevice* device = CEikonEnv::Static()->ScreenDevice();
+ TInt screenMode = device->CurrentScreenMode();
+
+ CEikonEnv* eikEnv = CEikonEnv::Static();
+
+ // Update the setting cache and get SGCS to process the screen mode
+ // change, this may broadcast a screen device change to the apps,
+ // to inform them of the update
+ CAknEnv::Static()->SettingCache().Update( KAknHardwareLayoutSwitch );
+ HandleWindowGroupParamChangeL(
+ eikEnv->RootWin().Identifier(),
+ 0,
+ 0,
+ 0,
+ KAknScreenModeUnset );
+
+ if (screenMode == device->CurrentScreenMode())
+ {
+ // Apps will not have received a screen device changed event
+ // so send a KAknHardwareLayoutSwitch to the apps to ensure
+ // they get to know about the key
+ TWsEvent event;
+ event.SetType(KAknHardwareLayoutSwitch);
+ event.SetHandle(0);
+ eikEnv->WsSession().SendEventToAllWindowGroups( 0, event );
+ }
+ }
+
+void CEikSgcServer::UpdateNotificationsInIdleAllowedKey()
+ {
+ // First, get screensaver window group identifier.
+ TApaTaskList taskList(CEikonEnv::Static()->WsSession());
+ const TApaTask screensaverTask = taskList.FindApp(KScreensaverAppUid);
+ const TInt screensaverWgId = screensaverTask.WgId();
+
+ // Get also idle window group identifier.
+ TVwsViewId idleView;
+ if (AknDef::GetPhoneIdleViewId(idleView) != KErrNone)
+ {
+ return;
+ }
+
+ const TApaTask idleTask = taskList.FindApp(idleView.iAppUid);
+ const TInt idleWgId = idleTask.WgId();
+
+ // Then go through window groups skipping partial apps and screensaver -
+ // check if idleWgId follows.
+ TBool result = EFalse;
+ TBool found = EFalse;
+ const TInt wgCount = iWgStates->Count();
+ TInt ii = FocusWgIndex();
+
+ LOGTEXT0("======================================");
+ LOGTEXT1("Window groups: %d", wgCount);
+ LOGTEXT1("Idle wg id: %d", idleWgId);
+ LOGTEXT1("Screensaver wg id: %d", screensaverWgId);
+ LOGTEXT1("Focus window group: %d", ii);
+ LOGTEXT0("======================================");
+
+ // Loops window groups from top to bottom, starting from focus window group.
+ // (Index 0 contains the foreground window group.)
+ while (ii < wgCount && !found)
+ {
+ const TWgState& state = iWgStates->At(ii);
+ const TInt currentWgId = state.WgId();
+
+ LOGTEXT0("\n");
+ LOGTEXT1(" Window group id: %d", currentWgId);
+ LOGTEXT1(" UnderstandsPartialForeground: %d", state.UnderstandsPartialForeground());
+ LOGTEXT1(" IsFullScreen: %d", state.IsFullScreen());
+
+ // Ignores non-application window groups (e.g. incall bubble), partial screen
+ // applications and screensaver.
+ if (state.UnderstandsPartialForeground() &&
+ state.IsFullScreen() &&
+ currentWgId != screensaverWgId)
+ {
+ // Check if current app is idle.
+ result = (idleWgId == currentWgId);
+ found = ETrue;
+
+ LOGTEXT0("\n");
+ LOGTEXT1("Window group found. Result: %d", result);
+ }
+
+ ii++;
+ }
+
+ // Update the P&S key only if the value has been changed.
+ if ((iNotificationsInIdleAllowed && !result) || (!iNotificationsInIdleAllowed && result))
+ {
+ iNotificationsInIdleAllowed = result;
+ RProperty::Set(KPSUidAvkonDomain, KAknNotificationsInIdleAllowed, result);
+ }
+ }
+
+
+TInt CEikSgcServer::RemoveBlankCallBack( TAny* aThis )
+ {
+ static_cast<CEikSgcServer*>( aThis )->DoRemoveBlank();
+ return EFalse;
+ }
+
+void CEikSgcServer::DoRemoveBlank()
+ {
+ // remove any remaining screen blanker
+ for (; iRemoveBlankCount>0; iRemoveBlankCount--)
+ {
+ TRAP_IGNORE( iAknCapAppServerAppUi->BlankScreenL( EFalse ) );
+ }
+
+ iRemoveBlankCount = 0;
+
+ // readjust the status pane wg since we pushed it forward with the screen blanker
+ iLastTopSpWg = -1;
+
+ delete iRemoveBlankCallBack;
+ iRemoveBlankCallBack = NULL;
+ }
+
+void CEikSgcServer::SetLayoutBlankScreenL(TBool aBlank, TInt aStep,
+ TInt aCnt)
+ {
+ while(aCnt--)
+ {
+ SetLayoutBlankScreenL(aBlank, aStep);
+ }
+ }
+
+// Check if AknNfySrv or EikSrv is displaying a global note
+TBool CEikSgcServer::IsGlobalNoteForeground()
+ {
+ TBool isForeground = EFalse;
+ TThreadId threadId;
+ if (iWs.GetWindowGroupClientThreadId(iWs.GetFocusWindowGroup(),
+ threadId) == KErrNone)
+ {
+ RThread thread;
+ if (thread.Open(threadId) == KErrNone)
+ {
+ TSecureId secId = thread.SecureId();
+ thread.Close();
+ const TUid KEikSrvUid = {0x10003a4a};
+ isForeground =
+ secId.iId == KCommonNotifierAppSrvUid.iUid ||
+ secId.iId == KEikSrvUid.iUid;
+ }
+ }
+ return isForeground;
+ }
+
+void CEikSgcServer::MoveAppL(TInt aAppWindowGroupId, TSgcMoveAppToWhere aWhere)
+ {
+ CAknTaskList* taskList = CAknTaskList::NewLC(iWs);
+
+ // step 1: Find root (going to foreground) or tip (going to background) of
+ // aAppWindowGroupId's window group chain
+ TInt wgId = aAppWindowGroupId;
+ for (TInt next=wgId; next;)
+ {
+ wgId = next;
+ next = (aWhere == ESgcMoveAppToForeground) ?
+ taskList->FindParentWgId(wgId) :
+ taskList->FindChildWgId(wgId);
+ }
+
+ // step 2: Move whole window group chain
+ while (wgId)
+ {
+ // move the window group
+ TInt index = WgStateIndex(wgId);
+ if (index >= 0)
+ {
+ TWgState state = iWgStates->At(index);
+ iWgStates->Delete(index);
+ if (aWhere == ESgcMoveAppToForeground)
+ iWgStates->InsertL(0, state);
+ else
+ iWgStates->AppendL(state);
+ }
+
+ // get the next window group in the chain
+ wgId = (aWhere == ESgcMoveAppToForeground) ?
+ taskList->FindChildWgId(wgId) :
+ taskList->FindParentWgId(wgId);
+ }
+
+ CleanupStack::PopAndDestroy(taskList);
+
+ // Step 3: do screen rotation and move app
+ iMoveAppWdId = aAppWindowGroupId;
+ iMoveAppWhere = aWhere;
+
+ PostChangeRecalcL();
+
+ // if no layout switch occured, move app here
+ DoMoveApp();
+ }
+
+void CEikSgcServer::DoMoveApp()
+ {
+ if (iMoveAppWdId)
+ {
+ TApaTask task(iWs);
+ task.SetWgId(iMoveAppWdId);
+ if (iMoveAppWhere == ESgcMoveAppToForeground)
+ task.BringToForeground();
+ else
+ task.SendToBackground();
+ iMoveAppWdId = 0;
+ }
+ }
+
+
+//
+// CAknSgcServerImpl
+//
+CAknSgcServerImpl::CAknSgcServerImpl(CEikSgcServer* aServer)
+: iServer(aServer)
+ {
+ }
+
+void CAknSgcServerImpl::MoveApp(TInt aAppWindowGroupId, TSgcMoveAppToWhere aWhere)
+ {
+ TRAP_IGNORE(iServer->MoveAppL(aAppWindowGroupId, aWhere));
+ }
+
+// End of file