/*

* 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.