#include <alflogger.h>

const TInt KRosterFreezeEndTimeoutInMs = 100;

const TInt KFirstTimeoutForApplicationEndFullScreenInMs = 20;

const TReal KMinimumPaintedAreaBeforeForcedEffect = 0.75;

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

    iCallBack = aCallBack;

    __ALFLOGSTRING("CAlfRosterFreezeEndTimer::Start");

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

        }

    iLayoutSwitchEffectContext(AknTransEffect::ENone),

    iCurrentState( EStateIdle )

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

    }

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