--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/screensaverengine.cpp Wed Sep 01 12:30:40 2010 +0100
@@ -0,0 +1,897 @@
+/*
+* Copyright (c) 2003 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: Screensaver engine class definition.
+*
+*/
+
+
+
+#include <barsread.h>
+#include <featmgr.h>
+#include <PUAcodes.hrh>
+#include <Profile.hrh>
+#include <screensaver.rsg>
+#include <AknUtils.h>
+
+#include "screensaverengine.h"
+#include "screensaverctrlmovingtext.h"
+#include "screensavershareddatai.h"
+#include "screensavershareddatamonitor.h"
+#include "screensaverappui.h"
+#include "ScreensaverUtils.h"
+#include "screensaverutility.h"
+#include "screensaveractivitymanager.h"
+
+// Minimum plugin suspension time
+const TInt KMinPluginSuspensionTime = 500000; // 0.5 sec
+
+// Inactivity timeout in seconds when keys locked
+const TInt KTimeoutShort = 5000000;
+const TInt KTimeoutPreviewLocked = 2000000;
+
+const TInt KNoPreview = 0;
+
+const TInt KPreviewTimeout = 10000000; // 10 sec
+
+const TText KSilentProfileInd= KPuaCodeSilentSymbol;
+const TText KSilentVibraInd= KPuaCodeAprofSilentVibra;
+const TText KSoundVibraInd= KPuaCodeAprofSoundVibra;
+const TText KSoundInd= KPuaCodeAprofSound;
+
+// Class CScreensaverEngine
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::NewL
+// -----------------------------------------------------------------------------
+//
+CScreensaverEngine* CScreensaverEngine::NewL()
+ {
+ CScreensaverEngine* self = new (ELeave) CScreensaverEngine();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop(); //self
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::~CScreensaverEngine
+// -----------------------------------------------------------------------------
+//
+CScreensaverEngine::~CScreensaverEngine( )
+ {
+ iAsyncCb.Cancel();
+ StopActivityMonitoring( iActivityManagerScreensaver );
+ DisableSharedDataAndMonitor();
+ delete iIndicatorArray;
+ KillTimer( iPreviewTimer );
+ KillTimer( iExpiryTimer );
+ iAknUiServer.Close();
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::SharedDataInterface
+// -----------------------------------------------------------------------------
+//
+CScreensaverSharedDataI* CScreensaverEngine::SharedDataInterface( ) const
+ {
+ return iSharedDataI;
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::ResetInactivityTimeout
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::ResetInactivityTimeout()
+ {
+ if ( iActivityManagerScreensaver )
+ {
+ SCRLOGGER_WRITEF(_L("SCR: Model: Setting inac timeout to %d secs"),
+ Timeout());
+ iActivityManagerScreensaver->SetInactivityTimeout( Timeout( ) );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::ScreenSaverIsOn
+// -----------------------------------------------------------------------------
+//
+TBool CScreensaverEngine::ScreenSaverIsOn( ) const
+ {
+ return iScreenSaverIsOn;
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::ScreenSaverIsPreviewing
+// -----------------------------------------------------------------------------
+//
+TBool CScreensaverEngine::ScreenSaverIsPreviewing( ) const
+ {
+ return iScreenSaverIsPreviewing;
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::StartScreenSaver
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::StartScreenSaver( )
+ {
+ SCRLOGGER_WRITE("Model: StartScreenSaver()");
+
+ // Stop if previewing. If keylock was activated, the pause timer will
+ // be started and the selected (not necessarily previewed) screensaver
+ // will start
+ if ( iScreenSaverIsPreviewing )
+ {
+ StopScreenSaver();
+ return;
+ }
+
+ // if (DisplayFlag() == 1) then screensaver can be activated
+ // else screensaver can't come during phone call.
+ // Also not OK to start until system startup has been completed
+ if ( ( !DisplayFlag() ) && ( iSharedDataI->IsSystemStartupComplete() ) )
+ {
+ if ( !iScreenSaverIsOn )
+ {
+ // Activating is done asynchronously to prevent screensaver from
+ // flashing quickly in some cases. This flashing happens e.g. when
+ // a call is missed and a note is showed about it.
+ iAsyncCb.CallBack();
+ }
+ else
+ {
+ SCRLOGGER_WRITE("Model: StartScreenSaver(): already on, ignore");
+ }
+ }
+ else
+ {
+ SCRLOGGER_WRITE("Model: SS not displaying, not allowed.");
+ ResetInactivityTimeout( );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::StopScreenSaver
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::StopScreenSaver()
+ {
+ SCRLOGGER_WRITE("Stopping Screensaver");
+ iAsyncCb.Cancel();
+
+ if ( iSharedDataI->IsKeyguardOn() || iScreenSaverIsPreviewing )
+ {
+ StartPauseTimer();
+ }
+
+ if( iScreenSaverIsOn )
+ {
+ // disconnect in StopScreenSaver, It makes sure other applications could
+ // receive application key event when screensaver is disactivated.
+ iAknUiServer.ConnectAndSendAppsKeySuppress(EFalse);
+ // Indicate we've stopped
+ iSharedDataI->SetScreensaverStatus( EFalse );
+
+ iScreenSaverIsOn = EFalse ;
+
+ KillTimer( iExpiryTimer );
+
+ View()->HideDisplayObject();
+ }
+
+ if( iScreenSaverIsPreviewing )
+ {
+ iSharedDataI->SetScreensaverPreviewMode( KNoPreview );
+
+ iScreenSaverIsPreviewing = EFalse;
+
+ View()->HideDisplayObject();
+
+ // Update preview progress
+ iSharedDataI->SetScreensaverPreviewState( EScreenSaverPreviewEnd );
+ iSharedDataI->SetScreensaverPreviewState( EScreenSaverPreviewNone );
+
+ KillTimer( iPreviewTimer );
+ ResetInactivityTimeout();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::StartPreviewModeL
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::StartPreviewModeL( )
+ {
+ SCRLOGGER_WRITEF(_L("SCR: Inside CScreensaverEngine::StartPreviewModeL()") );
+
+ iScreenSaverIsPreviewing = ETrue;
+ // Change the display object into what's being previewed
+ View()->CreatePreviewDisplayObjectL();
+
+ if( iSharedDataI->ScreensaverPreviewState() == EScreenSaverPreviewError )
+ {
+ iScreenSaverIsPreviewing = EFalse;
+ return;
+ }
+
+ StartPreviewTimer();
+
+ UpdateIndicatorAttributes();
+
+ if ( !View()->IsContentlessScreensaver() )
+ {
+ ScreensaverUtility::BringToForeground();
+ }
+
+ View()->ShowDisplayObject();
+
+ iSharedDataI->SetScreensaverPreviewState( EScreenSaverPreviewStart );
+
+ iActivityManagerScreensaver->SetInactivityTimeout(0);
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::DisplayObject
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::DisplayObject()
+ {
+ SCRLOGGER_WRITEF(_L("SCR: Inside CScreensaverEngine::DisplayObject()") );
+ //if the display object type is plugin, we should recreate the object
+ //cause when plugin is suspend status, it will be changed to the default
+ //type
+ if ( iSharedDataI->DisplayObjectType() == EDisplayPlugin )
+ {
+ View()->SetDisplayObject( EDisplayPlugin );
+ SetExpiryTimerTimeout( KDefaultScreenSaverTimeout );
+ }
+
+ UpdateIndicatorAttributes();
+
+ View()->ShowDisplayObject();
+
+ iSharedDataI->SetScreensaverStatus( ETrue );
+ }
+
+// ----------------------------------------------------------------------------
+// CScreensaverEngine::StartSuspendTimer
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::StartSuspendTimer( TInt aSec )
+ {
+ KillTimer( iSuspendTimer );
+
+ // Let's keep this operation reasonable.
+ TInt realTime = ( aSec > KMinPluginSuspensionTime )
+ ? aSec : KMinPluginSuspensionTime;
+
+ TRAP_IGNORE( iSuspendTimer = CPeriodic::NewL( CActive::EPriorityStandard ) );
+
+ iSuspendTimer->Start( realTime, realTime, TCallBack(
+ HandleSuspendTimerExpiry, this ) );
+
+ SCRLOGGER_WRITEF(_L("SCR: iSuspendTimer->Start(%d, %d, HandleSuspensionTimerTimeout)"),
+ realTime, realTime);
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::IndicatorArray
+// -----------------------------------------------------------------------------
+//
+CScreensaverIndicatorArray& CScreensaverEngine::IndicatorArray() const
+ {
+ return *iIndicatorArray;
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::GetColorModel
+// -----------------------------------------------------------------------------
+//
+const TScreensaverColorModel& CScreensaverEngine::GetColorModel() const
+ {
+ SCRLOGGER_WRITE("Host / Own use: GetColorModel()");
+
+ return iColorModel;
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::AddPartialModeLevel
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::AddPartialModeLevel( TInt aBpp,
+ TScreensaverPartialModeType aType )
+ {
+ TInt i;
+ for (i = 0; i < iColorModel.iNumberOfPartialModes; i++ )
+ {
+ if ( (iColorModel.iPartialModes[i].iBpp == aBpp)
+ && (iColorModel.iPartialModes[i].iType == aType) )
+ {
+ break;
+ }
+ }
+ if ( i >= iColorModel.iNumberOfPartialModes )
+ {
+ iColorModel.iPartialModes[iColorModel.iNumberOfPartialModes].iBpp
+ = aBpp;
+ iColorModel.iPartialModes[iColorModel.iNumberOfPartialModes].iType
+ = aType;
+ iColorModel.iNumberOfPartialModes++;
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::UpdateIndicatorAttributes
+// This method is for updating screensaver indicator
+// attributes (payloads and dependencies). This is where indicator
+// payload values are connected to real values.
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::UpdateIndicatorAttributes()
+ {
+ SCRLOGGER_WRITEF(_L("SCR: Inside CScreensaverView::UpdateIndicatorAttributes()"));
+
+ TIndicatorPayload payload;
+
+ // First integer types.
+ payload.iType = EPayloadTypeInteger;
+
+ // Missed calls.
+ payload.iInteger = iSharedDataI->NewMissedCalls();
+ iIndicatorArray->SetIndicatorPayload( ESsMissedCallsInd, payload );
+ // Missed calls indicator depends on status of new contacts note.
+ iIndicatorArray->SetDependencyStatus( ESsMissedCallsInd,
+ !iSharedDataI->IsNCNActive() );
+
+ // Unread messages
+ payload.iInteger = iSharedDataI->UnreadMessagesNumber();
+ iIndicatorArray->SetIndicatorPayload( ESsNewMessagesInd, payload );
+ iIndicatorArray->SetDependencyStatus( ESsNewMessagesInd, (payload.iInteger > 0
+ ? EFalse : ETrue) );
+
+ // Then string types.
+ payload.iType = EPayloadTypeText;
+
+ // Profile information
+ TBool nameDisplayed = (iSharedDataI->ActiveProfile() == EProfileGeneralId) ? EFalse : ETrue;
+ TBool isSilent = iSharedDataI->IsSilentMode();
+ payload.iText.Zero( );
+
+ if ( nameDisplayed || isSilent || iShowExtendedProfileInd )
+ {
+ // append alert type indicator
+ if ( iShowExtendedProfileInd )
+ {
+ TBool isVibra = iSharedDataI->IsVibraMode( );
+ if ( isSilent )
+ {
+ payload.iText.Append( isVibra ? KSilentVibraInd
+ : KSilentProfileInd );
+ }
+ else
+ {
+ payload.iText.Append( isVibra ? KSoundVibraInd : KSoundInd );
+ }
+ }
+ else
+ {
+ // Check if this is silent mode and we have to add indicator
+ // character to string.
+ if ( isSilent )
+ {
+ payload.iText.Append( KSilentProfileInd );
+ }
+ }
+
+ if ( nameDisplayed )
+ {
+ const TDesC& profile = iSharedDataI->ProfileName( );
+ // Don't panic if profile name is too long, 'less than' ensures
+ // the 1 free space used for silent/vibra
+ if ( profile.Length( ) < KMaxPayloadTextLength )
+ {
+ // append profile name
+ payload.iText.Append( profile );
+ }
+ }
+
+ // Profile indicator shown
+ iIndicatorArray->SetDependencyStatus( ESsProfileInd, EFalse );
+ }
+ else
+ {
+ // Profile indicator not shown
+ iIndicatorArray->SetDependencyStatus( ESsProfileInd, ETrue );
+ }
+
+ iIndicatorArray->SetIndicatorPayload( ESsProfileInd, payload );
+
+ // AM/PM indicator is text but it is updated with every draw
+ // in screensaver control, so that it changes properly even if
+ // time rolls over between draws. Note that Am/Pm information is
+ // maintained by screensaver display object, not shareddatainterface.
+ if ( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )
+ {
+ // Am/Pm indicator depends on 12-hour clock
+ iIndicatorArray->SetDependencyStatus( ESsAmPmInd, !ScreensaverUtility::Query12HourClock( ) );
+ }
+ else
+ {
+ // Make sure it's not shown
+ iIndicatorArray->SetDependencyStatus( ESsAmPmInd, ETrue );
+ }
+
+
+ // Key lock indicator depends on status of key guard.
+ iIndicatorArray->SetDependencyStatus( ESsKeyLockInd, !iSharedDataI->IsKeyguardOn() );
+
+ // Instant messaging indicator depends on existence of unseen IMs
+ iIndicatorArray->SetDependencyStatus( ESsImInd, !iSharedDataI->IsHaveNewInstantMessages() );
+
+ // Mail indicator depends on existence of unseen mails
+ iIndicatorArray->SetDependencyStatus( ESsMailInd, !iSharedDataI->IsHaveNewEmail() );
+
+ // Voicemail indicator depends on existence of unseen voicemail messages
+ iIndicatorArray->SetDependencyStatus( ESsVoicemailInd, !iSharedDataI->IsHaveNewVoicemail() );
+
+ //Set visibility for indicators if selected screensaver is a plugin
+ //which overides standard indicators
+ //TODO: Convert the iControlType to the iSettingType
+// if ( (iSharedDataI->ScreensaverObjectType() == EDisplayPlugin ) &&
+// ( AppUi()->ScreensaverView()->PluginFlags() & CScreensaverView::EPluginFlagOverrideIndicators ) )
+// {
+ iIndicatorArray->SetVisibilityForIndicators();
+// }
+ }
+
+
+// -----------------------------------------------------------------------------
+// Start screensaver expiry timer. When the timer expires the screensaver will
+// be stopped and hided.
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::SetExpiryTimerTimeout( TInt aTimeout )
+ {
+ SCRLOGGER_WRITEF( _L( "SCR:CScreensaverEngine::SetExpiryTimerTimeout(%d) start" ), aTimeout );
+ KillTimer( iExpiryTimer );
+
+ if ( 0 < aTimeout )
+ {
+ TRAP_IGNORE(
+ iExpiryTimer = CPeriodic::NewL( CActive::EPriorityStandard );
+ iExpiryTimer->Start( aTimeout , aTimeout ,
+ TCallBack( HandleExpiryTimerExpiry, this ) );
+ )
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::CScreensaverEngine
+// -----------------------------------------------------------------------------
+//
+CScreensaverEngine::CScreensaverEngine() : iAsyncCb( CActive::EPriorityLow )
+ {
+ TCallBack callbackFunc( StartSaverCb, this );
+ iAsyncCb.Set( callbackFunc );
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::ConstructL( )
+ {
+ SetupColorModelL();
+
+ EnableSharedDataAndMonitorL();
+
+ iIndicatorArray = CScreensaverIndicatorArray::NewL( iSharedDataI->IsInvertedColors() );
+
+ StartActivityMonitoringL();
+
+ FeatureManager::InitializeLibL();
+ iShowExtendedProfileInd
+ = FeatureManager::FeatureSupported( KFeatureIdProtocolCdma );
+ FeatureManager::UnInitializeLib();
+
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::EnableSharedDataAndMonitorL
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::EnableSharedDataAndMonitorL()
+ {
+ iSharedDataI = CScreensaverSharedDataI::NewL();
+
+ iSharedDataMonitor = CScreensaverSharedDataMonitor::NewL( iSharedDataI );
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::DisableSharedDataAndMonitor
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::DisableSharedDataAndMonitor( )
+ {
+ delete iSharedDataMonitor;
+ iSharedDataMonitor = NULL;
+
+ delete iSharedDataI;
+ iSharedDataI = NULL;
+
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::StartActivityMonitoringL
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::StartActivityMonitoringL( )
+ {
+ // Actually screensaver is the last exe to be launch at the startup,
+ // so when it is being launched the elapsed time(User::InactivityTime())
+ // is greater than the interval (15 sec) which screensaver pass to start
+ // activitymanager for inactivitycallback.
+ // So it has to do to reset inactivitytime (User::ResetInactivityTime() )
+ // once in the screensaver constructor so that the inactivity callback
+ // called after the interval time expired.
+ User::ResetInactivityTime();
+
+ // Start monitoring activity for screensaver
+ iActivityManagerScreensaver
+ = CScreensaverActivityManager::NewL( CActive::EPriorityUserInput );
+ iActivityManagerScreensaver->Start( Timeout(),
+ TCallBack( HandleInactiveEventL,this ),
+ TCallBack( HandleActiveEventL, this ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::StopActivityMonitoring
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::StopActivityMonitoring( CScreensaverActivityManager*& aActivityManager )
+ {
+ if ( aActivityManager )
+ {
+ aActivityManager->Cancel();
+ delete aActivityManager;
+ aActivityManager = NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::SetupColorModelL
+// THIS IS TEMPORARY VERSION OF SetupColorModelL function. It is used until
+// new version of LcdPartialMode module is integrated.
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::SetupColorModelL()
+ {
+ SCRLOGGER_WRITEF(_L("SCR: Inside CScreensaverEngine::SetupColorModelL()") );
+ TResourceReader reader;
+ TInt i, ctmp;
+
+ TInt suggestedDrawingMode;
+
+ CEikonEnv::Static()->CreateResourceReaderLC( reader, R_SCREENSAVER_COLOR_MODEL );
+ suggestedDrawingMode = reader.ReadInt32( );
+
+ //
+ // Let's find out how many partial modes hardware
+ // actually supports.
+ //
+ AddPartialModeLevel( (TInt)3,
+ (TScreensaverPartialModeType)EPartialModeTypeMostPowerSaving );
+ AddPartialModeLevel( (TInt)3,
+ (TScreensaverPartialModeType)EPartialModeTypeDefault );
+ AddPartialModeLevel( (TInt)16,
+ (TScreensaverPartialModeType)EPartialModeTypeFull );
+
+ if ( suggestedDrawingMode == ESsColorModel3BitMode )
+ {
+ // This can always be done, just set default partial mode to
+ // most power saving. First try 'most power saving' and if not supported
+ // then try default. if default isn't supported leave with error code.
+ iColorModel.iSystemPartialMode.iBpp = 3;
+ iColorModel.iSystemPartialMode.iType
+ = EPartialModeTypeMostPowerSaving;
+ }
+
+ // Read color indices for 3-bit mode.
+ reader.Read( iColorModel.iColors, 8 * sizeof(TInt16) );
+
+ // Read rgb values for gradient effect.
+ for (i = 0; i < 6; i++ )
+ {
+ ctmp = reader.ReadInt32( );
+ iColorModel.iDarkGradient[i] = TRgb( ctmp );
+ }
+
+ for (i = 0; i < 6; i++ )
+ {
+ ctmp = reader.ReadInt32( );
+ iColorModel.iLightGradient[i] = TRgb( ctmp );
+ }
+
+ CleanupStack::PopAndDestroy( ); // reader
+ }
+
+// ----------------------------------------------------------------------------
+// CScreensaverEngine::StartPreviewTimer
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::StartPreviewTimer()
+ {
+ SCRLOGGER_WRITEF(_L("SCR: Inside CScreensaverEngine::StartPreviewTimer()") );
+
+ KillTimer( iPreviewTimer );
+
+ TRAP_IGNORE( iPreviewTimer = CPeriodic::NewL( CActive::EPriorityHigh ) );
+
+ iPreviewTimer->Start( KPreviewTimeout, KPreviewTimeout, TCallBack(
+ HandlePreviewTimerExpiry, this ) );
+
+ SCRLOGGER_WRITEF(_L("SCR: iPreviewTimer->Start(%d, %d, HandlePreviewTimerTimeout)"),
+ KPreviewTimeout,KPreviewTimeout);
+ }
+
+// ----------------------------------------------------------------------------
+// CScreensaverEngine::StartPauseTimer
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::StartPauseTimer()
+ {
+ if ( iScreenSaverIsPreviewing )
+ {
+ iPauseTimerStartedAfterPreview = ETrue;
+ }
+
+ TInt timeout = ( iScreenSaverIsPreviewing )? KTimeoutPreviewLocked :
+ KTimeoutShort;
+
+ KillTimer( iPauseTimer );
+
+ TRAP_IGNORE( iPauseTimer = CPeriodic::NewL( CActive::EPriorityHigh ) );
+
+ if ( !iPauseTimer )
+ {
+ HandlePauseTimerExpiry( this );
+ return;
+ }
+
+ iPauseTimer->Start( timeout, timeout, TCallBack(
+ HandlePauseTimerExpiry, this ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::KillTimer
+// Stops and deletes a timer
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::KillTimer( CPeriodic*& aTimer )
+ {
+ if ( aTimer )
+ {
+ aTimer->Cancel( );
+ delete aTimer;
+ aTimer = NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::HandlePreviewTimerExpiry
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::HandlePreviewTimerExpiry( TAny* aPtr )
+ {
+ CScreensaverEngine* Engine = STATIC_CAST(CScreensaverEngine*, aPtr);
+ SCRLOGGER_WRITEF(_L("SCR: Inside CScreensaverView::HandlePreviewTimerTimeout()"));
+
+ Engine->KillTimer( Engine->iPreviewTimer );
+ Engine->StopScreenSaver();
+
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// CScreensaverEngine::HandlePauseTimerExpiry
+// ---------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::HandlePauseTimerExpiry( TAny* aPtr )
+ {
+ CScreensaverEngine* _this= STATIC_CAST(CScreensaverEngine*, aPtr);
+ _this->KillTimer( _this->iPauseTimer );
+ _this->iPauseTimerStartedAfterPreview = EFalse;
+
+ if ( _this->iSharedDataI->IsKeyguardOn() )
+ {
+ SCRLOGGER_WRITE("HandleInactiveEventShortL() starting saver");
+ _this->StartScreenSaver( );
+ }
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::HandleActiveEventL
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::HandleActiveEventL( TAny* aPtr )
+ {
+ SCRLOGGER_WRITE("HandleActiveEventL(), stop if previewing");
+ CScreensaverEngine* _this= STATIC_CAST(CScreensaverEngine*, aPtr);
+ if ( !_this->iSharedDataI->IsKeyguardOn() )
+ {
+ _this->StopScreenSaver();
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::HandleInactiveEventL
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::HandleInactiveEventL( TAny* aPtr )
+ {
+ SCRLOGGER_WRITE("HandleInactiveEventL(), starting screensaver");
+
+ CScreensaverEngine* _this= STATIC_CAST(CScreensaverEngine*, aPtr);
+ // Inactivity is detected immediately when preview starts
+ if ( _this->iScreenSaverIsPreviewing )
+ {
+ _this->ResetInactivityTimeout();
+ return KErrNone;
+ }
+ // Double-start is OK, it will be checked in StartScreenSaver()
+ // This will be trigged by keylock activation after keyguard
+ // timeout, or if keylock is disabled
+ if ( !_this->iSharedDataI->IsOngoingCall() )
+ {
+ _this->StartScreenSaver( );
+ }
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::HandleSuspendTimerExpiry
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::HandleSuspendTimerExpiry( TAny* aPtr )
+ {
+ CScreensaverEngine* control= STATIC_CAST(CScreensaverEngine*, aPtr);
+ SCRLOGGER_WRITEF(_L("SCR: Inside CScreensaverEngine::HandleSuspendTimerExpiry()"));
+
+ control->KillTimer( control->iSuspendTimer );
+
+ control->View()->SetDisplayObject( EDisplayPlugin );
+ control->View()->ShowDisplayObject();
+
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// CScreensaverEngine::HandleKeyguardStateChanged
+// ---------------------------------------------------------------------------
+//
+void CScreensaverEngine::HandleKeyguardStateChanged( TBool aEnabled )
+ {
+ if ( aEnabled )
+ {
+ // Keys locked - if screensaver is running, this was caused by
+ // automatic keyguard and screensaver should refresh the view
+ // to show the keylock indicator
+ if ( iScreenSaverIsOn && !iScreenSaverIsPreviewing )
+ {
+ View()->UpdateAndRefresh();
+ }
+ if ( !( iPauseTimerStartedAfterPreview &&
+ iPauseTimer && iPauseTimer->IsActive() ) )
+ {
+ StartScreenSaver();
+ }
+ }
+ else
+ {
+ StopScreenSaver();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::View
+// -----------------------------------------------------------------------------
+//
+CScreensaverView* CScreensaverEngine::View() const
+ {
+ return STATIC_CAST( CScreensaverAppUi*, CCoeEnv::Static()->AppUi() )->ScreensaverView();
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::Timeout
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::Timeout( )
+ {
+ return iSharedDataI->ScreensaverTimeout( );
+ }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::DisplayFlag
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::DisplayFlag( )
+ {
+ return iSharedDataI->IsScreenSaverAllowed();
+ }
+
+
+// -----------------------------------------------------------------------------
+// Handles expire timer timeout
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::HandleExpiryTimerExpiry( TAny* aPtr )
+ {
+ SCRLOGGER_WRITEF( _L( "SCR:CScreensaverEngine::HandleExpiryTimerExpiry(%d) start" ), aPtr );
+ CScreensaverEngine *control = STATIC_CAST( CScreensaverEngine*, aPtr );
+
+ if ( control )
+ {
+ control->KillTimer( control->iExpiryTimer );
+ // Revert to default screensaver.
+ control->View()->SetDisplayObject(
+ control->SharedDataInterface()->DefaultScreensaverType() );
+ control->View()->ShowDisplayObject();
+ }
+
+ return KErrNone;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Callback to do the screensaver starting.
+// ---------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::StartSaverCb( TAny* aPtr )
+ {
+ CScreensaverEngine* self = static_cast<CScreensaverEngine*>( aPtr );
+ // connect in StartScreenSaver, intercept and capture application
+ // key event. It makes sure this event will not be received
+ // by other applictions when screensaver is activated.
+ self->iAknUiServer.ConnectAndSendAppsKeySuppress(ETrue);
+ self->iScreenSaverIsOn = ETrue;
+
+ // Report whether started from Idle BEFORE bringing to foreground
+ self->iSharedDataI->SetSSStartedFromIdleStatus();
+
+ if ( !self->View()->IsContentlessScreensaver() )
+ {
+ ScreensaverUtility::BringToForeground();
+ }
+
+ SCRLOGGER_WRITE("Model: SS is displaying (BringToForeground)");
+
+ // Compress heap while displaying. No longer possible to
+ // compress all heaps (User::CompressAllHeaps() is a no-op)
+ User::Heap().Compress();
+
+ self->iSharedDataI->SetDisplayObjChanged( EFalse );
+
+ self->DisplayObject();
+
+ return KErrNone;
+ }
+
+
+// End of file.