/*

* Copyright (c) 2008 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:   AlfEffectUtils contains small classes that enable layout switch and transition effects.

*

*/

#include <e32cmn.h>

#include <s32mem.h>

#include "alfeffectutils.h"

#include <akntransitionutils.h>

#include <alflogger.h>

// Delay after which first end check is performed.

const TInt KRosterFreezeEndTimeoutInMs = 100;

// Interval between end checks.

const TInt KRosterFreezeEndIntervalInMs = 50;

// Maximum amount of end checks to be performed. 

// This can be lower, should be visible enough to see, if heuristics fail.

const TInt KRosterFreezeEndAttempts = 50;

// ---------------------------------------------------------

// CAlfRosterFreezeEndTimer

// ---------------------------------------------------------

//

CAlfRosterFreezeEndTimer::CAlfRosterFreezeEndTimer( CAlfBridge& aBridge )

    :CTimer ( EPriorityStandard ),

    iBridge( aBridge )

    {   

    }

void CAlfRosterFreezeEndTimer::ConstructL()

    {

    CTimer::ConstructL();

    CActiveScheduler::Add( this );

    }

CAlfRosterFreezeEndTimer* CAlfRosterFreezeEndTimer::NewL( CAlfBridge& aBridge )

    {

    CAlfRosterFreezeEndTimer* self = new ( ELeave ) CAlfRosterFreezeEndTimer( aBridge );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CAlfRosterFreezeEndTimer::~CAlfRosterFreezeEndTimer()

    {

    Cancel();        

    }

void CAlfRosterFreezeEndTimer::Start( TTimeIntervalMicroSeconds32 aPeriod, TCallBack aCallBack  )

    {

    iCallBack = aCallBack;

    __ALFLOGSTRING("CAlfRosterFreezeEndTimer::Start");

    if (!IsActive())

        {

        iSafeCounter = 0;

        iSafeCounterDelta = Min(1, aPeriod.Int() / (KRosterFreezeEndIntervalInMs*1000));

        After( aPeriod );

        }

    }

void CAlfRosterFreezeEndTimer::RunL()

    {

    __ALFLOGSTRING("CAlfRosterFreezeEndTimer::RunL");

	TBool timeout = EFalse;

	if (iSafeCounter >= 0)	

	    {

		iSafeCounter += iSafeCounterDelta;

		if (iSafeCounter >= KRosterFreezeEndAttempts)

			{

			timeout = ETrue;

			iSafeCounter = 0;

			}

		}

    if (!iBridge.IsLayoutSwitchReady(iSafeCounter) && !timeout)

        {

        __ALFLOGSTRING("CAlfRosterFreezeEndTimer::RunL - Not ready in new orientation. waiting 50ms more");

        iSafeCounterDelta = 1;

        After( KRosterFreezeEndIntervalInMs * 1000 );

        return;

        }

    else

        {

        __ALFLOGSTRING("CAlfRosterFreezeEndTimer::RunL - Ready in new orientation.");

        iCallBack.CallBack();

        }

    }

void CAlfRosterFreezeEndTimer::DoCancel()

    {

    CTimer::DoCancel();

    }

CAlfLayoutSwitchEffectCoordinator::CAlfLayoutSwitchEffectCoordinator( CAlfBridge& aBridge ) :

    iBridge( aBridge ),

    iLayoutSwitchEffectContext(AknTransEffect::ENone),

    iCurrentState( EStateIdle )

    {

    RThread me = RThread();

    iOriginalPriority = me.Priority();    

    me.Close();

    }

CAlfLayoutSwitchEffectCoordinator::~CAlfLayoutSwitchEffectCoordinator()

    {   

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::Blank

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::Blank(TBool aEnabled)

    {

    __ALFLOGSTRING1("CAlfLayoutSwitchEffectCoordinator::Blank %d", aEnabled);

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::LowMemoryEvent

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::LowMemoryEvent()

    {

    __ALFLOGSTRING("CAlfLayoutSwitchEffectCoordinator::LowMemory");

    Event( EEventLowMemory );

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::BeginLayoutSwitch

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::BeginLayoutSwitch()

    {

    __ALFLOGSTRING("CAlfLayoutSwitchEffectCoordinator::BeginLayoutSwitch");

    Event( EEventLayoutSwitch );      

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::Event

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::Event(TEvent aEvent)

    {

    // States:

    // - EStateIdle - No layout switch effect ongoing

    // - EStateFreezeFx - Roster frozen, periodic fullscreen completeness checking

    // - EStateBlankFx - Roster frozen, expecting client to say when ready to unfreeze

    // - EStateThemeFx - Theme effect in use

    // Events:

    // - EEventBlankOn - Client requested blank on

    // - EEventBlankOff - Client requested blank off

    // - EEventLayoutSwitch - Layout switch noticed

    // - EEventLowMemory - Low memory indication

    // and implicit Finish - Effect finished

    // Transitions:

    // From EStateIdle:

    // - EEventBlankOn: EStateBlankFx

    // - EEventLayoutSwitch: If effect available, EStateThemeFx. Otherwise EStateFreezeFx.

    //

    // From EStateFreezeFx:

    // - implicit Finish - EStateIdle

    //

    // From EStateBlankFx:

    // - EEventBlankOff: EStateFreezeFx (we use freeze to ensure that result is ok)

    // - EEventLayoutSwitch: If effect available, EStateThemeFx. Otherwise EStateFreezeFx.

    //

    // From EStateThemeFx:

    // - EEventLowMemory: If blank still on, EStateBlankFx. Otherwise EStateFreezeFx.

    // - implicit Finish - EStateIdle

    //

    // There is special handling if layout switch event is received while previous

    // layout switch is ongoing.

    TState nextState = EStateIdle;

    switch ( iCurrentState )

        {    

    case EStateFreezeFx:

        nextState = NextFreezeState(aEvent);

        break;

    case EStateBlankFx:

        nextState = NextBlankState(aEvent);

        break;

    case EStateThemeFx:

        nextState = NextThemeState(aEvent);

        break;

    case EStateIdle:

    default:

        nextState = NextIdleState(aEvent);   

        break;

        }

    if ( nextState != iCurrentState )

        {

        Transition( nextState, iCurrentState );

        }

    else

        {

        // We stay in the same state, but still need special handling in a couple of scenarios

        if ( nextState == EStateFreezeFx )

            {

            HandleFreezeEvent( aEvent );

            }

        if ( nextState == EStateThemeFx )

            {

            HandleThemeEvent( aEvent );

            }                        

        }

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::HandleFreezeEvent

// Special handling for Freeze effect.

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::HandleFreezeEvent(TEvent aEvent)

    {

    if ( aEvent == EEventLayoutSwitch && iRosterFreezeEndTimer && iRosterFreezeEndTimer->IsActive() )

        {                                

        // New layout switch while previous is ongoing => restart freeze end timer.

        __ALFLOGSTRING("CAlfLayoutSwitchEffectCoordinator::HandleFreezeEvent restart timer");

        iRosterFreezeEndTimer->Cancel();

        iRosterFreezeEndTimer->Start(KRosterFreezeEndTimeoutInMs*1000, TCallBack(DoFreezeFinished, this));                

        }

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::HandleFreezeEvent

// Special handling for Theme effect.

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::HandleThemeEvent(TEvent aEvent)

    {

    if ( aEvent == EEventLayoutSwitch )

        {                                

        // If layout switch occurs while freeze end timer is ongoing, restart.

        if ( iRosterFreezeEndTimer && iRosterFreezeEndTimer->IsActive() )

            {

            __ALFLOGSTRING("CAlfLayoutSwitchEffectCoordinator::HandleThemeEvent restart timer");

            iRosterFreezeEndTimer->Cancel();

            iRosterFreezeEndTimer->Start(KRosterFreezeEndTimeoutInMs*1000, TCallBack(DoNextLayoutSwitchContext, this));                

            }

        // If layout switch occurs while theme effect is ongoing in exit phase, restart.

        if ( iLayoutSwitchEffectContext == AknTransEffect::ELayoutSwitchExit )

            {

            __ALFLOGSTRING("CAlfLayoutSwitchEffectCoordinator::HandleThemeEvent restart themefx");

            TBool oldLayoutSwitchNotCompleted = iLayoutSwitchNotCompleted;

            iLayoutSwitchNotCompleted = EFalse;

            Transition( EStateIdle, iCurrentState );

            Transition( EStateThemeFx, iCurrentState );

            if (oldLayoutSwitchNotCompleted)

                {

                iLayoutSwitchNotCompleted = ETrue;

                }  

            }

        }

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::Transition

// ---------------------------------------------------------

//

void CAlfLayoutSwitchEffectCoordinator::Transition(

        TState aNewState, TState aPreviousState)

    {

    __ALFLOGSTRING2("CAlfLayoutSwitchEffectCoordinator::Transition from: %d to: %d", aPreviousState, aNewState);

    iCurrentState = aNewState;

    // Undo previous state - don't unfreeze roster.

    switch ( aPreviousState )

        {

    case EStateFreezeFx:

        if ( iRosterFreezeEndTimer )

            {

            iRosterFreezeEndTimer->Cancel();

            }

        break;

    case EStateBlankFx:        

        iBridge.iHuiEnv->iPauseDrawing = EFalse;

        break;

    case EStateThemeFx:

        {

        RThread me = RThread();

        me.SetPriority(iOriginalPriority);    

        me.Close();

        if ( iRosterFreezeEndTimer )

            {

            iRosterFreezeEndTimer->Cancel();

            }

        SetLayoutSwitchEffect( AknTransEffect::ENone );

        }

        break;

    case EStateIdle:

    default:    

        break;

        }

    // Do next state actions

    switch ( iCurrentState )

        {    

    case EStateFreezeFx:

        {

        if (!iRosterFreezeEndTimer)

            {

            TRAP_IGNORE(iRosterFreezeEndTimer = CAlfRosterFreezeEndTimer::NewL(iBridge));

            }

        if (iRosterFreezeEndTimer)

            {

            iRosterFreezeEndTimer->Cancel();

            FreezeRoster(ETrue);

            // Remove all other effects

            iBridge.HandleGfxStopEvent( EFalse );

            iBridge.CleanAllFxVisuals();

            // Set remove freeze timer

            __ALFLOGSTRING("CAlfLayoutSwitchEffectCoordinator::Transition - Freeze timer started");

            iRosterFreezeEndTimer->Start(KRosterFreezeEndTimeoutInMs*1000, TCallBack(DoFreezeFinished, this)); 

            }

        }

        break;

    case EStateBlankFx:

        {

        // Start blanker

        iBridge.iHuiEnv->iPauseDrawing = ETrue;

        FreezeRoster(ETrue);        

        }

        break;

    case EStateThemeFx:

        {

        // Boost priority so that we are able to draw more frames for the effect

        RThread me = RThread();

        me.SetPriority(EPriorityAbsoluteHigh);    

        me.Close();

        // Freeze visual content

        iBridge.iHuiEnv->Display(0).SetDirty();

        FreezeRoster(ETrue);

        // Remove all other effects

        iBridge.HandleGfxStopEvent( EFalse );

        iBridge.CleanAllFxVisuals();

        // Set first layout switch effect 

        SetLayoutSwitchEffect(AknTransEffect::ELayoutSwitchStart);

        }

        break;

    case EStateIdle:

    default:

        {

        // Undo everything to be sure

        RThread me = RThread();

        me.SetPriority(iOriginalPriority);    

        me.Close();

        SetLayoutSwitchEffect( AknTransEffect::ENone );

        if ( iRosterFreezeEndTimer )

            {

            iRosterFreezeEndTimer->Cancel();

            }            

        iBridge.iHuiEnv->iPauseDrawing = EFalse;

        FreezeRoster(EFalse);

        iBridge.iHuiEnv->Display(0).SetDirty();

        iBridge.SetVisualTreeVisibilityChanged(ETrue);

        iBridge.AsynchRefresh();

        }

        break;

        }    

    // Inform bridge about layout switch actions

    if ( aNewState != EStateIdle && aPreviousState == EStateIdle )

        {

        iLayoutSwitchNotCompleted = ETrue;

        iBridge.LayoutSwitchStart();

        }

    if ( aNewState == EStateIdle && iLayoutSwitchNotCompleted )

        {

        iLayoutSwitchNotCompleted = EFalse;

        iBridge.LayoutSwitchComplete();

        }

    __ALFLOGSTRING("CAlfLayoutSwitchEffectCoordinator::Transition end");        

    }

// ---------------------------------------------------------

// CAlfLayoutSwitchEffectCoordinator::NextIdleState

// ---------------------------------------------------------

//

CAlfLayoutSwitchEffectCoordinator::TState 

    CAlfLayoutSwitchEffectCoordinator::NextIdleState(

        TEvent aEvent)

    {

    TState state = EStateIdle;

    switch ( aEvent )

        {

    case EEventLayoutSwitch:

        if ( IsThemeEffectEnabled() )

            {