diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/plugins/alftranseffect/alftranseffectplugin/src/wsserverdrawercontroller.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/plugins/alftranseffect/alftranseffectplugin/src/wsserverdrawercontroller.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,1114 @@ +/* +* Copyright (c) 2006 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: controls the calls that comes to the wsserverplugin by the use +* of a state machine +* +*/ + + + +#include "wsserverdrawercontroller.h" +#include "alfdrawerengine.h" +#include // for Transition effect enumerations + +#include +#include +#include +#include +#include +#include + +#include + +//#include +#ifdef WSSERVERDRAWER_TIME_LOG +_LIT(KWsServerDrawerTimeLogFile, "WsServerDrawerTimeLog.txt"); +_LIT(KWsServerDrawerTimeLogDir, "alfgfxtest"); +#endif //WSSERVERDRAWER_TIME_LOG + +const TInt KEndCheckTime(500000); //half second +const TInt KEndTimeOut(10); // 10 * KEndCheckTime + +// We use a huge timeout for tests as it seems we hit the timeout way too often +//const TInt KEndCheckTime(1000000); //1 second +//const TInt KEndTimeOut(10); // 10 * KEndCheckTime + +///////////////////////////////////////////////////////////////////////////////////////// + +/** These apps will never get fullscreen effects to or from them */ +const TUint KNoEffectApps[] = + { + 0x100059B5, // S60 autolock + 0x10207218, // akncapserver +// 0x100058B3, // phone app + 0x10281EF2, // AknNotifyServer +// 0x100056CF, // screensaver + 0x10210CB5, // MIDP, JavaLauncherExe + 0x1000594D, // IRApp, disables effect when activating IR + 0x102818E7, // VCommandManager, start in device startup + 0x100058F3, // sys app + 0x102823b5, // SendUiServiceResolver, + 0x101F8681, // VideoTelUi + 0x101F875A, // KSWInstSvrUid, prevent fullscreen effect on installing + 0x101F8543, // Voice Commands, no effects when pressing send key long + 0x10281855 // touch input server , no effects when the first time start up + // startup blocked because startup exit leaves the screen black. + // must be debugged + , 0x100058F4 // startup blocked for the time being + // Application shell is Ok, folder open and close have KAknApplicationShellViewId + // as both to and from ids. There is only one visual, so some sort of blur effect works... + //, KAknApplicationShellViewId + }; + +/** Switching between theese app pairs will also never get effects */ +const TUint KNoEffectPairs[][2] = + { + {0x0, 0x0}, + }; + +/** switch to/from these applications will never get any effects and + the current ongoing effect will be aborted */ +const TUint KCustomNoEffectApps[] = + { + 0x0, // DO NOT REMOVE 0x0! this is here for compile reasons, it will not be included in the AllowedCustomUid check + //0xUID //Add UIds of applications that shouldn't have effects here + }; + +// DISABLED! uncomment code in ConstructL that references this list to turn it on. +/** Switching between from or to theese apps should have always effects */ +/*const TUint KExceptionEffectApps[] = + { + 0x100056CF, // screensaver + }; +*/ + +/** + * Local funtion that checks if the uid is in the KCustomNoEffectApps list +*/ +LOCAL_C TBool AllowedCustomUid(const TUid& aUid) + { + for(TInt i = 1; i < sizeof(KCustomNoEffectApps) / sizeof(KCustomNoEffectApps[0]); i++) + { + if(aUid.iUid == KCustomNoEffectApps[i]) + return EFalse; + } + return ETrue; + } + +///////////////////////////////////////////////////////////////////////////////////////// + +class CPSListener : public CActive + { + public: + inline TInt Value() const; + inline TInt Key() const; + CPSListener(); + void ListenL(const TUid& aUid, TInt aKey); + ~CPSListener(); + private: + void DoCancel(); + void RunL(); + private: + RProperty iProperty; + TInt iValue; + TInt iKey; + }; + +inline TInt CPSListener::Value() const + { + return iValue; + } + +inline TInt CPSListener::Key() const + { + return iKey; + } + +CPSListener::CPSListener() : CActive(CActive::EPriorityHigh) + { + CActiveScheduler::Add(this); + } + +void CPSListener::ListenL(const TUid& aUid, TInt aKey) + { + Cancel(); + iKey = aKey; + User::LeaveIfError(iProperty.Attach(aUid, aKey)); + RunL(); //set initial value + } + + +CPSListener::~CPSListener() + { + Cancel(); + } + +void CPSListener::DoCancel() + { + iProperty.Cancel(); + } + +void CPSListener::RunL() + { + iProperty.Subscribe(iStatus); + iProperty.Get(iValue); //errors are ignored! + SetActive(); + } + + +//////////////////////////////////////////////////////////////////////////////////////// + + + +CEndCheck* CEndCheck::NewL(MEndChecker& aCallBack) + { + CEndCheck* c = new (ELeave) CEndCheck(aCallBack); + CleanupStack::PushL(c); + c->ConstructL(); + CleanupStack::Pop(); + return c; + } + +void CEndCheck::Start(/*TInt aState,*/ TInt aMul) + { + Cancel(); + iCancelled = EFalse; + After(KEndCheckTime * aMul); + } + +CEndCheck::~CEndCheck() + { + Cancel(); + } + +void CEndCheck::DoCancel() + { + CTimer::DoCancel(); + iCancelled = ETrue; + } + +void CEndCheck::RunL() + { + if(!iCancelled) + { + iCallBack.EndExpired(); + } + } + +CEndCheck::CEndCheck(MEndChecker& aCallBack) : CTimer(CActive::EPriorityStandard), +iCallBack(aCallBack) + { + CActiveScheduler::Add(this); + } + +////////////////////////////////////////////////////////////////////////////////////////// + + +LOCAL_C void GetName(RFs& aFs, TDes& aName) + { + aFs.PrivatePath(aName); + aName.Insert(0, _L("D:")); + aName.Append(_L("data.bin")); + } + + +void CAppInfoCache::ReadArrayL(RFile& aFile) + { + TPckgBuf buf; + User::LeaveIfError(aFile.Read(buf)); + const TUint count = buf(); + for(TUint i = 0; i < count; i++) + { + User::LeaveIfError(aFile.Read(buf)); + const TUint value = buf(); + User::LeaveIfError(aFile.Read(buf)); + const TUint flags = buf(); + User::LeaveIfError(aFile.Read(buf)); + const TUint aToUid = buf(); + User::LeaveIfError(aFile.Read(buf)); + const TUint root = buf(); + if(KErrNone == Append(value)) //dont allow duplicates + { + const TInt index = IndexOf(value); + iAppInfo[index].iFlags = static_cast(flags); + iAppInfo[index].iParent = TUid::Uid(aToUid); + iAppInfo[index].iRootWgId = static_cast(root); + } + } + } + +void CAppInfoCache::WriteArrayL(RFile& aFile) const + { + const TUint count = static_cast(iAppInfo.Count()); + User::LeaveIfError(aFile.Write(TPckgC(count))); + for(TUint i = 0; i < count; i++) + { + const TAppInfo& info = iAppInfo[i]; + User::LeaveIfError(aFile.Write(TPckgC(info.iUid))); + User::LeaveIfError(aFile.Write(TPckgC(info.iFlags))); + User::LeaveIfError(aFile.Write(TPckgC(info.iParent.iUid))); + User::LeaveIfError(aFile.Write(TPckgC(info.iRootWgId))); + } + } + +TInt CAppInfoCache::TAppInfo::Order(const TAppInfo& aNodeA, const TAppInfo& aNodeB) + { + if(aNodeA.iUid < aNodeB.iUid) + return 1; + if(aNodeA.iUid > aNodeB.iUid) + return -1; + return 0; + } + +TInt CAppInfoCache::Append(TUint aUid) + { + return iAppInfo.InsertInOrder(TAppInfo(aUid), TLinearOrder(TAppInfo::Order)); + } + +TInt CAppInfoCache::IndexOf(TUint aUid) const + { + return iAppInfo.FindInOrder(TAppInfo(aUid), TLinearOrder(TAppInfo::Order)); + } + + +CAppInfoCache* CAppInfoCache::NewL() + { + CAppInfoCache* f = new (ELeave) CAppInfoCache(); + CleanupStack::PushL(f); + f->ConstructL(); + CleanupStack::Pop(); + return f; + } + +CAppInfoCache::~CAppInfoCache() + { + TRAP_IGNORE(ExportL()); + iLs.Close(); + iAppInfo.Close(); + } + +void CAppInfoCache::ConstructL() + { + ImportL(); + User::LeaveIfError(iLs.Connect()); + } + +TBool CAppInfoCache::GateFound() const + { + return ETrue; + } + +void CAppInfoCache::ExportL() + { + RFs fs; + User::LeaveIfError(fs.Connect()); + CleanupClosePushL(fs); + TFileName name; + GetName(fs, name); + BaflUtils::EnsurePathExistsL(fs, name); + RFile file; + User::LeaveIfError(file.Replace(fs, name, EFileWrite)); + CleanupClosePushL(file); + + User::LeaveIfError(file.Write(TPckgC(iFocusedUid.iUid))); + + WriteArrayL(file); + CleanupStack::PopAndDestroy(2); //file, fs + } + +void CAppInfoCache::ImportL() + { + RFs fs; + User::LeaveIfError(fs.Connect()); + CleanupClosePushL(fs); + TFileName name; + GetName(fs, name); + RFile file; + const TInt err = file.Open(fs, name, EFileRead); + if(err == KErrNone) + { + TPckgBuf buf; + User::LeaveIfError(file.Read(buf)); + iFocusedUid = TUid::Uid(buf()); + + CleanupClosePushL(file); + ReadArrayL(file); + CleanupStack::PopAndDestroy(); //file + fs.Delete(name); //free up memory after import + } + CleanupStack::PopAndDestroy(); //fs + } + + +TInt CAppInfoCache::SetUid(const TUid& aUid) + { + if(aUid == KNullUid) + return KErrNone; + + TInt err = Append(aUid.iUid); + + if( err == KErrAlreadyExists ) + { + err = KErrNone; + } + + return err; + } + +void CAppInfoCache::SetAppFlags(const TUid& aUid, TUint aFlag, TBool aSet) + { + const TInt index = IndexOf(aUid.iUid); + if(index >= 0) + { + if(aSet) + iAppInfo[index].iFlags |= aFlag; + else + iAppInfo[index].iFlags &= ~aFlag; + } + } + + +TBool CAppInfoCache::GetAppFlags(const TUid& aUid, TUint aFlag) const + { + return TBool(iAppInfo[IndexOf(aUid.iUid)].iFlags & aFlag); + } + + +void CAppInfoCache::SetAvkonUid(const TUid& aUid) + { + SetAppFlags(aUid, TAppInfo::EAvkonApp, ETrue); + } + +void CAppInfoCache::RemoveAvkonUid(const TUid& aUid) + { + SetAppFlags(aUid, TAppInfo::EAvkonApp, EFalse); + } + + +TBool CAppInfoCache::AvkonUid(const TUid& aUid) const + { + TInt index = IndexOf(aUid.iUid); + if (index!=KErrNotFound) + { + return (iAppInfo[index].iFlags & TAppInfo::EAvkonApp); + } + else + { + return EFalse; + } + } + + +void CAppInfoCache::Reset(const TUid& aUid) + { + SetParent(aUid, KNullUid); + } + + +void CAppInfoCache::SetParent(const TUid& aUid, const TUid& aParentUid) + { + iAppInfo[IndexOf(aUid.iUid)].iParent = aParentUid; + } + + +TInt CAppInfoCache::SetAction(const TUid& aUid, TInt aAction) + { + if (aAction==AknTransEffect::ENone || aUid == KNullUid) + { + // previous action is more valid than this + return aAction; + } + TInt index = IndexOf(aUid.iUid); + + if (index == KErrNotFound) + { + SetUid(aUid); + index = IndexOf(aUid.iUid); + if(index == KErrNotFound) + { + __ALFFXLOGSTRING1("CAppInfoCache::SetAction - Could not add Uid 0x%x to AppInfoCache!", aUid.iUid); + return aAction; + } + } + switch(iAppInfo[index].iAction) + { + case AknTransEffect::EAppStartupBackground: + if (aAction == AknTransEffect::EApplicationExit) + { + aAction = AknTransEffect::EEmbeddedApplicationExit; + } + break; + + case AknTransEffect::EApplicationStartRect: + case AknTransEffect::EApplicationStartSwitch: + case AknTransEffect::EApplicationStartSwitchRect: + { + // these cannot be overwritten + if (aAction!=KErrNotFound) // resetting the state is allowed regardless of earlier state + { + return iAppInfo[index].iAction; + } + break; + } + } + + iAppInfo[index].iAction = aAction; + RDebug::Printf("CAppInfoCache::SetAction - Returned action %d", iAppInfo[index].iAction); + return iAppInfo[index].iAction; + } + +TInt CAppInfoCache::Action(const TUid& aUid) + { + TInt index = IndexOf(aUid.iUid); + if (index != KErrNotFound) + { + return iAppInfo[index].iAction; + } + return KErrNotFound; + } + +TBool CAppInfoCache::IsEmbedded(const TUid& aUid) const + { + return iAppInfo[IndexOf(aUid.iUid)].iParent != KNullUid; + } + + +TBool CAppInfoCache::IsSameParent(const TUid& aUid1, const TUid& aUid2) const + { + + if(aUid1 == KNullUid || aUid2 == KNullUid) + return EFalse; + + TAppInfo appInfo = iAppInfo[IndexOf(aUid1.iUid)]; + appInfo.iParent.iUid = (appInfo.iParent == KNullUid) ? appInfo.iUid : appInfo.iParent.iUid; + TAppInfo parentAppInfo = iAppInfo[IndexOf(aUid2.iUid)]; + parentAppInfo.iParent.iUid = (parentAppInfo.iParent == KNullUid) ? parentAppInfo.iUid : parentAppInfo.iParent.iUid; + + if(appInfo.iParent == parentAppInfo.iParent) // Same root? + return ETrue; + + return EFalse; + } + + +const TUid& CAppInfoCache::FocusUid() const + { + return iFocusedUid; + } + + +TBool CAppInfoCache::SetFocusUid(TInt aWgId) + { + if (aWgId) + { + for(TInt i = 0; i < iAppInfo.Count(); i++) + { + if(iAppInfo[i].iRootWgId == aWgId) + { + iFocusedUid = TUid::Uid(iAppInfo[i].iUid); + return ETrue; + } + } + } + return EFalse; + } + +void CAppInfoCache::ClearActions() + { + for (TInt i = 0; i < iAppInfo.Count(); ++i) + { + if ( iAppInfo[i].iAction != AknTransEffect::EAppStartupBackground ) + { + iAppInfo[i].iAction = KErrNotFound; + } + } + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +CWsServerDrawerController* CWsServerDrawerController::NewL(MAlfDrawerEngine* aEngine) + { + CWsServerDrawerController* self = new (ELeave) CWsServerDrawerController(aEngine); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +CWsServerDrawerController::~CWsServerDrawerController() + { +#ifdef WSSERVERDRAWER_TIME_LOG //time log + delete iLogger; +#endif //WSSERVERDRAWER_TIME_LOG + delete iAppInfoCache; + delete iEndCheck; + delete iStates; + + iPSStates.ResetAndDestroy(); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +CWsServerDrawerController::CWsServerDrawerController(MAlfDrawerEngine* aEngine) : + iEngine( aEngine ) + { + iLastAction = AknTransEffect::ENone; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::AddStateL(const TUid& aUid, TInt aKey) + { + CPSListener* s = new (ELeave) CPSListener(); + CleanupStack::PushL(s); + s->ListenL(aUid, aKey); + User::LeaveIfError(iPSStates.Append(s)); + CleanupStack::Pop(); //s + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CWsServerDrawerController::GetState(TInt aState) const + { + for(TInt i = 0; i < iPSStates.Count() ; i++) + { + const CPSListener* const ps = iPSStates[i]; + if(ps->Key() == aState) + return ps->Value(); + } + return 0; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::ConstructL() + { +#ifdef WSSERVERDRAWER_TIME_LOG + iLogger = new (ELeave)CDebugLogger(); +#endif //WSSERVERDRAWER_TIME_LOG + iAppInfoCache = CAppInfoCache::NewL(); + iEndCheck = CEndCheck::NewL(*this); + iStates = CStateHandler::NewL(iEngine); + + // Fill blocklist from the array + for(TInt i = 0; i < sizeof(KNoEffectApps) / sizeof(KNoEffectApps[0]); i++) + { + iStates->AddBlockUid(TUid::Uid( KNoEffectApps[i] )); + } + + for(TInt i = 1; i < sizeof(KNoEffectPairs) / sizeof(KNoEffectPairs[0]); i++) + { + iStates->AddBlockUidPair(TUid::Uid( KNoEffectPairs[i][0] ), TUid::Uid( KNoEffectPairs[i][1] )); + } + +/* Disabled adding to exception list, since we have no exceptions atm. + for(TInt i = 0; i < sizeof(KExceptionEffectApps) / sizeof(KExceptionEffectApps[0]); i++) + { + iStates->AddExceptionUid(TUid::Uid( KExceptionEffectApps[i] )); + } +*/ + + //AddStateL( KPSUidUikon, KUikGlobalNotesAllowed ); + AddStateL( KPSUidScreenSaver, KScreenSaverOn ); + AddStateL( KPSUidStartup, KPSStartupUiPhase ); + AddStateL( KPSUidScreenSaver, KScreenSaverPreviewMode ); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +const TUid& CWsServerDrawerController::FocusUid() + { + return iAppInfoCache->FocusUid(); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TBool CWsServerDrawerController::SetFocusUid(TInt aUid) + { + return iAppInfoCache->SetFocusUid(aUid); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::BeginFullscreen(TInt aType, const TUid aUid1, const TUid aUid2, TInt aData ) + { + TUid toUid = iEngine->ToUid(); + TUid fromUid = iEngine->FromUid(); + TInt flags = iEngine->Flags(); +#ifdef WSSERVERDRAWER_TIME_LOG //time log + if(aFromGfx) + { + iLogger->Log1(_L("CWsServerDrawerController::BeginFullscreen from Gfx time %d"), iLogger->TimeMs()); + } + else + { + iLogger->Log1(_L("CWsServerDrawerController::BeginFullscreen time %d"), iLogger->TimeMs()); + } +#endif //WSSERVERDRAWER_TIME_LOG + +///////////////////// + if(aType == AknTransEffect::EParameterAvkonInternal) + { + const TUid appuid = aUid1; + if(appuid != KNullUid) + { + iAppInfoCache->SetUid(appuid); + iAppInfoCache->SetAvkonUid(appuid); + iAppInfoCache->SetParent(appuid, aUid2); + iAppInfoCache->SetFocusUid(aData); + } + } + + // App Filter uses application uid for the unique key in the table. That causes problems as + // there can be several instances of applications in the system which have the same uid, + // e.g. stand-alone application and embedded applications. Because of this: + // - We try to prevent updating App Filter flags if the instance is embedded. + // - The existence of the parent uid do not necessarily mean that the instance is embedded. + + if ((toUid != KNullUid) && (iEngine->Action() == AknTransEffect::EEmbeddedApplicationExit)) + iAppInfoCache->SetParent(toUid, KNullUid); // Clear parent uid on exit of embedded application + + TBool isEmbeddedAppContext = + (iEngine->Action() == AknTransEffect::EEmbeddedApplicationExit) || + (iEngine->Action() == AknTransEffect::EEmbeddedApplicationStart); + + iAppInfoCache->SetUid(toUid); + iAppInfoCache->SetUid(fromUid); + + if ((toUid != KNullUid) && !isEmbeddedAppContext) + { + //the ok is always reset in the begining + if(flags & AknTransEffect::TParameter::EResetServerStats) + { //this should be called always before avkoncheck or noeffects etc for apps + iAppInfoCache->Reset(toUid); + } + + //Adding uid to block list + if(flags & AknTransEffect::TParameter::ENoEffects) + { + iStates->AddBlockUid(toUid); + } + //Removing uid from blocklist + if(flags & AknTransEffect::TParameter::EEnableEffects) + { + iStates->RemoveBlockUid(toUid); + } + } + + CStateHandler::TFullscreenType fstype = iStates->GetFullscreenType(iEngine->Action()); + CStateHandler::TFullscreenType currtype = iStates->GetCurrentFullscreenType(); + + //application has to be avkon app, therefore thise + //flag has to be set twice! + if(flags & AknTransEffect::TParameter::EAvkonCheck) + { + if(fstype == CStateHandler::EExit) //application will exit and avkon flags must be reset (otherwise + { + iAppInfoCache->RemoveAvkonUid(toUid); //repeating calls may allow check pass + } + else + { + iAppInfoCache->SetAvkonUid(toUid); + } + } + +// TODO: All control has been disabled as it seems to block too much, +// it appears that the states are not handled correctly or something else is missing + + // if we are currenly running a layoutswitch let it only be aborted by + // another layoutswitch. + if( (iStates->GetCurrentFullscreenType() == CStateHandler::ELayoutSwitch) && + (iEngine->Action() != AknTransEffect::ELayoutSwitch)) + { + return; + } + + //activation after exit is not allowed (also if exit didnt result in an effect) + if(iLastTypeTried == CStateHandler::EExit && + fstype == CStateHandler::EActivation) + { //the current uid is not valid + return; // activation not ok if exiting + } + + iLastTypeTried = fstype; + + //activation after exit is not allowed...even it was aborted + if(iExitAborted && + CStateHandler::EActivation == fstype) + { //the current uid is not valid + AbortTransition(); //if exit is aborted, we dont want either activation + return; // activation not ok if exiting + } + + //dsa apps do not have effects + //this is one reason why for activation end cannot be called immediately after begin + //we should know if its a dsa app before end can be called + if(iDSAActive) + { + return; //Do nothing if dsa active. + } + + //Special argument calls does not initiate any FS effect and is caught here. + // TODO: remove && !iEngine->WaitingForRootWgId() when appuids available from wserv + if(fstype == CStateHandler::ENone) + { + return; + } + + + //Phone is booting, stop any FS effect. + if(!StartCheck(flags)) + { + AbortTransition(); + return; + } + + // if either toUid or fromUid is in the custom list for applications + // that should be blocked then we abort all ongoing transitions. + if(!(AllowedCustomUid(toUid) && AllowedCustomUid(fromUid))) + { + AbortTransition(); + return; + } + + // No effect if a second exit effect comes in while exit effect is ongoing. + // Double exit actually looks quite nice... + // We are doing separate visuals, not screen capture, so there is no need to + // filter this out + /* + if((currtype == fstype) && currtype == CStateHandler::EExit) + { + return; + } + */ + + //Filter out anything but exit effect if start effect is running. + /* + if((currtype == CStateHandler::EStart) && (fstype != CStateHandler::EExit)) + { + return; + } + */ + + // this check is for embedded apps/operator menu case ///// This check aborts ongoing. Is this right? + // abort and skip transition if no current uid // Maybe should be added to statemachine. + // TODO: Revise when appuids available from wserv + /* + if( toUid == KNullUid ) + { + return; + } +*/ + //activation switch effects are not allowed for non avkon apps as they never will + //inform their foregound - so no transition. + if(CStateHandler::EActivation == fstype && currtype != CStateHandler::EStart && + !iAppInfoCache->AvkonUid(toUid)) + { + return; + } + + if(iEngine->Action() == AknTransEffect::ELayoutSwitch) // ELayoutSwitchOut is for two phases solution + { + if( iLastFromUid.iUid == KScreensaverUid ) //TODO: Better test needed here? + { + iEngine->Action() = 1001; // 1002: start, 1001, exit + iEngine->ToUid() = TUid::Uid(KScreensaverUid); + iEngine->FromUid() = TUid::Uid(0); + iEngine->Flags() |= AknTransEffect::TParameter::EActivateExplicitContinue; + } + else if( iLastToUid.iUid == KScreensaverUid ) //TODO: Better test needed here? + { + iEngine->Action() = 1002; // 1002: start, 1001, exit + iEngine->ToUid() = TUid::Uid(KScreensaverUid); + iEngine->FromUid() = TUid::Uid(0); + iEngine->Flags() |= AknTransEffect::TParameter::EActivateExplicitContinue; + } + else + { + switch(iLastAction) + { + case AknTransEffect::EApplicationExit: + iEngine->Action() = AknTransEffect::ELayoutSwitchExit; + break; + case AknTransEffect::EApplicationStartRect: + case AknTransEffect::EApplicationStart: + iEngine->Action() = AknTransEffect::ELayoutSwitchStart; + break; + //case AknTransEffect::EApplicationActivate: // Does it work only for application active? + default: + break; + } + } + } + + if (!iStates->IsBlocked(fromUid, toUid)) + { + iLastAction = AknTransEffect::ENone; + iLastFromUid = KNullUid; + iLastToUid = KNullUid; + iLayoutChangeActive = EFalse; + } + // Convert + + // Signal statemachine + iStates->Signal(CStateBase::EBeginFullscreen); + // Start end checker always. + if(flags & AknTransEffect::TParameter::EEndCheck) + { + StartEndChecker(); + } + else + { + StartEndChecker(KEndTimeOut); + } + } + + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// + + +TBool CWsServerDrawerController::StartCheck(TInt aFlags) const + { + if((aFlags & AknTransEffect::TParameter::EActivateExplicitContinue)) //always allow this + { + return true; + } + else if(iEngine->Action() == AknTransEffect::ELayoutSwitch) //always allow layoutswitch + { + return true; + } + else if (aFlags & AknTransEffect::TParameter::EAllowAtBoot) //allow unless screensaver is on + { + return !TBool(GetState(KScreenSaverOn)) && + !TBool(GetState(KScreenSaverPreviewMode)); //off + } + else + { + return /*TBool(GetState(KUikGlobalNotesAllowed)) //on + && */ iAppInfoCache->GateFound() + && !TBool(GetState(KScreenSaverOn)) + && !TBool(GetState(KScreenSaverPreviewMode)); //off + // && TBool(GetState(ESplashRunning)) + } + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::StartEndChecker(TInt aMultiplier) + { + iEndCheck->Start(aMultiplier); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::CancelEndChecker() + { + iEndCheck->Cancel(); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::EndExpired() + { + __ALFFXLOGSTRING("CWsServerDrawerController::EndExpired >>"); + AbortTransition(EAbortFullscreen); + iExitAborted = EFalse; //This is not valid when we have a time-out + __ALFFXLOGSTRING("CWsServerDrawerController::EndExpired <<"); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::EndFullscreen(TBool /*aFromGfx*/) + { + /* + DSA end fix + */ + if(iDSAActive) + { + AbortTransition(); + return; //Do nothing if dsa active. + } + + +#ifdef WSSERVERDRAWER_TIME_LOG //time log + iLogger->Log1(_L("CWsServerDrawerController::EndFullscreen time %d"), iLogger->TimeMs()); +#endif //WSSERVERDRAWER_TIME_LOG + + iStates->Signal(CStateBase::EEndFullscreen); + } + + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::FullscreenFinished(TInt aHandle) + { + if(aHandle == iEngine->CurrentHandle()) // Filter away stray finish signals. + { + iLastTypeTried = CStateHandler::ENone; + iStates->Signal(CStateBase::EFinishFullscreen); + } + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TInt CWsServerDrawerController::BeginControlTransition() + { + if(iDSAActive) + { + return KErrAbort; + } + + if(iLayoutChangeActive) + { + return KErrAbort; + } + // Check booting time disabling & screensaver + __ALFFXLOGSTRING2("GetState(KUikGlobalNotesAllowed) %d, GetState(KScreenSaverOn)), %d GetState(KScreenSaverPreviewMode) %d", + /*TBool(GetState(KUikGlobalNotesAllowed)),*/ + TBool(GetState(KScreenSaverOn)), + TBool(GetState(KScreenSaverPreviewMode))); + + if(/*TBool(GetState(KUikGlobalNotesAllowed))==EFalse || */ + TBool(GetState(KScreenSaverOn)) || + TBool(GetState(KScreenSaverPreviewMode))) + { + return KErrAbort; + } + + iStates->Signal(CStateBase::EBeginComponent); + + if(iStates->GetState() == CStateBase::EComponent) + { + return iEngine->CurrentHandle(); + } + else + { + return KErrAbort; + } + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::EndControlTransition(TInt aHandle) + { + if(aHandle == iEngine->CurrentHandle()) //Filter out stray endcomponent. + { + iStates->Signal(CStateBase::EFinishComponent); + } + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::ScreenModeChange(TBool aBeforeScreenModeChange) + { + if( aBeforeScreenModeChange ) + { + AbortTransition(); + iLayoutChangeActive = ETrue; + } + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::Error( TServerDrawerError /*aError*/ ) + { + AbortTransition(); + } + + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::SaveLastActionAndUid() + { + iLastAction = iEngine->Action(); + iLastFromUid = iEngine->FromUid(); + iLastToUid = iEngine->ToUid(); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::DSABegin() + { + AbortTransition(); + iDSAActive = ETrue; + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::DSAEnd() + { + iDSAActive = EFalse; + } + + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +void CWsServerDrawerController::AbortTransition(TInt aToAbort) + { + __ALFFXLOGSTRING("CWsServerDrawerController::AbortTransition >>"); + if ( aToAbort == EAbortFullscreen ) + { + iLastTypeTried = CStateHandler::ENone; + iExitAborted = iStates->GetCurrentFullscreenType() == CStateHandler::EExit; + iStates->Signal(CStateBase::EAbortFullscreen); + } + else if ( aToAbort == EAbortControl ) + { + iStates->Signal(CStateBase::EAbortComponent); + } + else if( (aToAbort & EAbortControl) && (aToAbort & EAbortFullscreen) ) + { + iLastTypeTried = CStateHandler::ENone; + iExitAborted = iStates->GetCurrentFullscreenType() == CStateHandler::EExit; + iStates->Signal(CStateBase::EAbort); + } + __ALFFXLOGSTRING("CWsServerDrawerController::AbortTransition <<"); + } + +// --------------------------------------------------------------------------- +// --------------------------------------------------------------------------- +// +TBool CWsServerDrawerController::IsBlocked( const TUid& aFromUid, const TUid& aToUid ) + { + TBool result = iStates->IsBlocked( aFromUid, aToUid ); + __ALFFXLOGSTRING1("CWsServerDrawerController::IsBlocked - return %d", result); + return result; + } +