src/screensaverengine.cpp
changeset 0 040fcad49f44
child 10 25957ccd51ab
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/screensaverengine.cpp	Thu Dec 17 08:46:04 2009 +0200
@@ -0,0 +1,768 @@
+/*
+* 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 <activitymanager.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"
+
+
+// Minimum plugin suspension time
+const TInt KMinPluginSuspensionTime = 500000; // 0.5 sec
+
+// Inactivity timeout in seconds when keys locked
+const TInt KTimeoutShort = 5;
+
+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( )
+    {
+    StopActivityMonitoring( iActivityManagerScreensaver );
+    StopActivityMonitoring( iActivityManagerScreensaverShort );
+    DisableSharedDataAndMonitor();
+    delete iIndicatorArray;
+    KillTimer( iPreviewTimer );
+    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()");
+
+    // Ignore start while in preview to avoid double-start lock
+    if ( iScreenSaverIsPreviewing )
+        {
+        // Reset user activity so that screensaver is enabled after
+        // preview even if no user activity happens any more
+        // Note that this puts on backlight but it should be on at this
+        // time anyway (unless a plugin set it off, but what the hey)
+        User::ResetInactivityTime();
+        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 )
+            {
+            // 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.
+            iAknUiServer.ConnectAndSendAppsKeySuppress(ETrue);
+            iScreenSaverIsOn = ETrue;
+
+            // Report whether started from Idle BEFORE bringing to foreground
+            iSharedDataI->SetSSStartedFromIdleStatus();
+
+            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();
+            
+            DisplayObject();
+            }
+        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");
+
+    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 ;
+
+        View()->HideDisplayObject();
+        }
+
+
+    if( iScreenSaverIsPreviewing )
+        {
+        iSharedDataI->SetScreensaverPreviewMode( KNoPreview );
+
+        iScreenSaverIsPreviewing = EFalse;
+
+        View()->HideDisplayObject();
+
+        // Update preview progress
+        iSharedDataI->SetScreensaverPreviewState( EScreenSaverPreviewEnd );
+        iSharedDataI->SetScreensaverPreviewState( EScreenSaverPreviewNone );
+
+        KillTimer( iPreviewTimer );
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// 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();
+
+    View()->ShowDisplayObject();
+    
+    iSharedDataI->SetScreensaverPreviewState( EScreenSaverPreviewStart );
+
+    ScreensaverUtility::BringToForeground();
+    }
+
+// -----------------------------------------------------------------------------
+// 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 );
+        }
+
+    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();
+//        }
+    }
+
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::CScreensaverEngine
+// -----------------------------------------------------------------------------
+//
+CScreensaverEngine::CScreensaverEngine()
+    {
+
+    }
+
+// -----------------------------------------------------------------------------
+// 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
+        = CUserActivityManager::NewL( CActive::EPriorityStandard );
+        iActivityManagerScreensaver->Start( Timeout(), 
+            TCallBack( HandleInactiveEventL,this ),
+            TCallBack( HandleActiveEventL, this ) );
+
+    // Start monitoring activity for screensaver, short timeout
+    iActivityManagerScreensaverShort
+        = CUserActivityManager::NewL( CActive::EPriorityStandard );
+    
+        iActivityManagerScreensaverShort->Start( KTimeoutShort, 
+            TCallBack( HandleInactiveEventShortL, this ), 
+            TCallBack( HandleActiveEventShortL, this ) );
+    }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::StopActivityMonitoring
+// -----------------------------------------------------------------------------
+//
+void CScreensaverEngine::StopActivityMonitoring( CUserActivityManager*& 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::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::HandleActiveEventL
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::HandleActiveEventL( TAny* /* aPtr */)
+    {
+    SCRLOGGER_WRITE("HandleActiveEventL(), do nothing");
+    // We can be pretty sure the short timeout has passed and its
+    // active event handler stops the saver
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::HandleInactiveEventL
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::HandleInactiveEventL( TAny* aPtr )
+    {
+    SCRLOGGER_WRITE("HandleInactiveEventL(), starting screensaver");
+
+    CScreensaverEngine* _this= STATIC_CAST(CScreensaverEngine*, aPtr);
+    
+    // Double-start is OK, it will be checked in StartScreenSaver()
+    _this->StartScreenSaver( );
+
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::HandleActiveEventShortL
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::HandleActiveEventShortL( TAny* aPtr )
+    {
+    SCRLOGGER_WRITE("HandleActiveEventShortL(), stopping saver");
+    STATIC_CAST(CScreensaverEngine*, aPtr)->StopScreenSaver();
+    return KErrNone;
+    }
+
+// -----------------------------------------------------------------------------
+// CScreensaverEngine::HandleInactiveEventShortL
+// -----------------------------------------------------------------------------
+//
+TInt CScreensaverEngine::HandleInactiveEventShortL( TAny* aPtr )
+    {
+    SCRLOGGER_WRITE("HandleInactiveEventShortL()");
+    // Start, if keys are locked and short timeout in use
+    CScreensaverEngine* _this= STATIC_CAST(CScreensaverEngine*, aPtr);
+    
+    if ( _this->iSharedDataI->IsKeyguardOn() )
+        {
+        SCRLOGGER_WRITE("HandleInactiveEventShortL() starting saver");
+        _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::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();
+    }
+// End of file.