/*

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

const TInt KRosterFreezeEndTimeoutInMs = 100;

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

// 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;

        After( aPeriod );

        }

    }

void CAlfRosterFreezeEndTimer::RunL()

    {

    __ALFLOGSTRING("CAlfRosterFreezeEndTimer::RunL");

	TBool timeout = EFalse;

	if (iSafeCounter >= 0)	

	    {

		iSafeCounter++;

		if (iSafeCounter == 100) // can be lower, 100 should be visible enough to see, if heuristics fail

			{

			timeout = ETrue;

			iSafeCounter = 0;

			}

		}

    if (!iBridge.IsFullScreenDrawn(0) && !timeout)

        {

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

        After( 50000 );

        return;

        }

    else

        {

        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);

    iBlankEnabled = aEnabled;

    Event( aEnabled ? EEventBlankOn : EEventBlankOff );

    }

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

// 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:

    // - EEventBlankOn: EStateBlankFx

    // - implicit Finish - EStateIdle

    //

    // From EStateBlankFx:

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

    // - EEventLayoutSwitch: If effect available, EStateThemeFx.

    //

    // From EStateThemeFx:

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

    // - implicit Finish - EStateIdle

    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 );

        }

    }

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

// CAlfLayoutSwitchEffectCoordinator::Transition

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

//

void CAlfLayoutSwitchEffectCoordinator::Transition(

        TState aNewState, TState aPreviousState)

    {

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

    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.RemoveAllTemporaryPresenterVisuals();

            // 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.RemoveAllTemporaryPresenterVisuals();

        // 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);

        }

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

            {

            state = EStateThemeFx;

            }

        else

            {

            state = EStateFreezeFx;

            }

        break;

    case EEventBlankOn:

        state = EStateBlankFx;

        break;

    case EEventBlankOff:

    case EEventLowMemory:

    default:

        break;     

        }

    return state;

    }

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

// CAlfLayoutSwitchEffectCoordinator::NextFreezeState

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

//

CAlfLayoutSwitchEffectCoordinator::TState 

    CAlfLayoutSwitchEffectCoordinator::NextFreezeState(

        TEvent aEvent)

    {

    TState state = EStateFreezeFx;

    switch ( aEvent )

        {

    case EEventBlankOn:

        state = EStateBlankFx;

        break;

    case EEventLayoutSwitch:    

    case EEventBlankOff:

    case EEventLowMemory:

    default:

        break;     

        }

    return state;

    }

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

// CAlfLayoutSwitchEffectCoordinator::NextBlankState

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

//

CAlfLayoutSwitchEffectCoordinator::TState 

    CAlfLayoutSwitchEffectCoordinator::NextBlankState(

        TEvent aEvent)

    {

    TState state = EStateBlankFx;

    switch ( aEvent )

        {

    case EEventLayoutSwitch:

        if ( IsThemeEffectEnabled() )

            {

            state = EStateThemeFx;

            }

        break;

    case EEventBlankOff:

        state = EStateFreezeFx;

        break;

    case EEventBlankOn:        

    case EEventLowMemory:

    default:

        break;     

        }

    return state;

    }

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

// CAlfLayoutSwitchEffectCoordinator::NextThemeState

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

//

CAlfLayoutSwitchEffectCoordinator::TState 

    CAlfLayoutSwitchEffectCoordinator::NextThemeState(

        TEvent aEvent)       

    {

    TState state = EStateThemeFx;

    switch ( aEvent )

        {

    case EEventLowMemory:

        state = iBlankEnabled ? EStateBlankFx : EStateFreezeFx;

        break;

    case EEventLayoutSwitch:    

    case EEventBlankOn:

    case EEventBlankOff:

    default:

        break;     

        }

    return state;

    }

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

// CAlfLayoutSwitchEffectCoordinator::FreezeFinished

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

//

void CAlfLayoutSwitchEffectCoordinator::FreezeFinished()

    {

    Transition(EStateIdle, iCurrentState);

    }

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

// CAlfLayoutSwitchEffectCoordinator::SetLayoutSwitchEffectL

//

// This method sets correct effect based on the given 

// layout switch context.

//

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

//

void CAlfLayoutSwitchEffectCoordinator::SetLayoutSwitchEffect(AknTransEffect::TContext aContext)

    {

    MHuiEffectable* effectable = iBridge.iHuiEnv->Display(0).Roster().Effectable();

    CHuiFxEffect* effect = NULL;

    CHuiFxEngine* engine = iBridge.iHuiEnv->EffectsEngine();

    if (!effectable || !engine)

        {

        return;

        }    

    // Update current context

    iLayoutSwitchEffectContext = aContext;           

    if (aContext == AknTransEffect::ENone)

        {