/*

* 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( )

    {