/*

* Copyright (c) 2007-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:    The effect control for the slideshow

 *

*/

// CLASS HEADER

#include "shweffectcontrol.h"

// EXTERNAL INCLUDES

#include <mglxvisuallist.h>

#include <mglxmedialist.h>

#include <glxlog.h>

#include <glxtracer.h>

#include <AknUtils.h>

// INTERNAL INCLUDES

#include "shweffectmanager.h"

#include "shweffect.h"

#include "shwthumbnailloader.h"

#include "shwslideshowenginepanic.h"

#include "shwcallback.h"

#include "shwtimer.h"

#include "shwconstants.h"

using namespace NShwSlideshow;

// LOCAL NAMESPACE

namespace

    {

    // local constants, the visual list range

    const TInt KRangeLeftFromFocus = -1;

    const TInt KRangeRightFromFocus = 1;

    }

// LOCAL FUNCTIONS AND CONSTANTS

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

// C++ Constructor. Save a few bits of rom with inlining

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

inline CShwEffectControl::CShwEffectControl(

        MShwEffectManager& aEffectManager, 

        MGlxVisualList& aVisualList,

        MGlxMediaList& aMediaList,

        TSize aScreenSize )

    : iEffectManager( aEffectManager ),

    iVisualList( aVisualList ),

    iMediaList( aMediaList ),

	iEffectLoopRestarted( EFalse ),

	iFailedThumbnailIndex( KErrNotFound ),

	iHDMIFirstDecoded(EFalse),

	iTNReadyReceived(EFalse)

    {

    // initialize the default layout chain

    iDefaultIconLayout.SetOpacity( KMaxOpacity, 0 );

    iDefaultIconLayout.SetSize( aScreenSize.iWidth, aScreenSize.iHeight, 0 );

    // initialise the not visible layout

    iNotVisibleLayout.SetOpacity(KMinOpacity,0);

    iNotVisibleLayout.SetSize( 0, 0, 0 );

   iSplitter.SetDefaultLayout(&iNotVisibleLayout);

    // initialise the paused layout

    iPausedLayout.SetOpacity( KMaxOpacity, 0);

    iPausedLayout.SetSize( aScreenSize.iWidth, aScreenSize.iHeight, 0 );    

    }

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

// NewL. Static construction

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

CShwEffectControl* CShwEffectControl::NewL(

    MShwEffectManager& aEffectManager, 

    MGlxVisualList& aVisualList,

    MGlxMediaList& aMediaList,

    TSize aScreenSize )

    {

    TRACER("CShwEffectControl* CShwEffectControl::NewL");

    GLX_LOG_INFO( "CShwEffectControl::NewL" );

    CShwEffectControl* self = 

        new( ELeave ) CShwEffectControl(

            aEffectManager, 

            aVisualList,

            aMediaList,

            aScreenSize );

    // 2nd phase construct

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

CShwEffectControl::~CShwEffectControl()

    {

    TRACER("CShwEffectControl::~CShwEffectControl()");

    GLX_LOG_INFO( "CShwEffectControl::~CShwEffectControl" );

    iPausedVisuals.Close();   

    // stop observing the visual list

    iVisualList.RemoveObserver( this );

    // delete timer, it cancels itself

    delete iTransitionTimer;

    // remove viewing context

    iVisualList.RemoveContext( iContextId );

    // delete the thumbnail loader

    delete iThumbnailLoader;

    }

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

// ConstructL.

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

void CShwEffectControl::ConstructL()

    {

    TRACER("CShwEffectControl::ConstructL()");

    GLX_LOG_INFO( "CShwEffectControl::ConstructL" );

    // create thumbnail loader for the medialist

    iThumbnailLoader  = CShwThumbnailLoader::NewL( iMediaList, *this );

    // create the timer to end the transition phase

    iTransitionTimer = CShwTimer::NewL( CActive::EPriorityStandard );

    // add us as visual list observer

    iVisualList.AddObserverL( this );

    // specify viewing range for the visual list

    iContextId = iVisualList.AddContextL(

        KRangeLeftFromFocus, KRangeRightFromFocus );

    // initialize splitter

    iSplitter.SetVisualListL( &iVisualList );

    // add the splitter layout on the bottom

    //subhasis commented 1 line

	//API depricated in visual list manager

    iVisualList.AddLayoutL( &iSplitter );

    }

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

// SendTransitionReadyL.

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

TInt CShwEffectControl::SendTransitionReadyL()

    {

    TRACER("CShwEffectControl::SendTransitionReadyL()");

    GLX_LOG_INFO( "CShwEffectControl::SendTransitionReadyL" );

    // cancel the timer

    iTransitionTimer->Cancel();

    // we need to remove the high quality thumbnails we dont plan

    // to show in near future, so focus minus range to left 

    // is the first to unload

    TInt indexToUnloadBackwards = NextListIndex( KRangeLeftFromFocus );

    // check that this index is not in focus or next from focus

    // this can happen if the list to play is really short

    TInt focusIndex = iMediaList.FocusIndex();

    if( ( indexToUnloadBackwards != focusIndex )&&

        ( indexToUnloadBackwards != NextListIndex( KNavigateForwards ) ) )

        {

        // ok, not visible so can unload

        iThumbnailLoader->Unload( indexToUnloadBackwards );

        }

    // send the event

    TShwEventTransitionReady transitionReady;

    SendEventL( &transitionReady );

    // return KErrNone, return value is ignored by CPeriodic

    return KErrNone;

    }

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

// NotifyL.

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

void CShwEffectControl::NotifyL( MShwEvent* aEvent )

    {

    TRACER("CShwEffectControl::NotifyL");

    // we got an event

    // is it initialize

    TShwEventInitialize* init = 

        dynamic_cast<TShwEventInitialize*>( aEvent );

    // is it start view

    TShwEventStartView* viewEvent = 

        dynamic_cast<TShwEventStartView*>( aEvent );

    // is it start transition

    TShwEventStartTransition* transEvent = 

        dynamic_cast<TShwEventStartTransition*>( aEvent );

    // was it a pause or resume event

    TShwEventPause* pauseEvent = 

        dynamic_cast<TShwEventPause*>( aEvent );

    TShwEventResume* resumeEvent = 

        dynamic_cast<TShwEventResume*>( aEvent );

    // or was it a navigation event

    TShwEventNextImage* nextImageEvent = 

        dynamic_cast< TShwEventNextImage* >( aEvent );

    TShwEventPreviousImage* previousImageEvent =

        dynamic_cast< TShwEventPreviousImage* >( aEvent );

    TShwEventToggleControlUi* toggleControlUiEvent = 

        dynamic_cast< TShwEventToggleControlUi* >( aEvent );

    TShwEventHDMIDisConnected* hdmiDisConnectEvent = 

    dynamic_cast< TShwEventHDMIDisConnected* >( aEvent );

    TShwEventHDMIFirstImageDecodingCompleted* hdmiDecodeImageEvent = 

    dynamic_cast< TShwEventHDMIFirstImageDecodingCompleted* >( aEvent );        

    // process init event

    if( init )

        {

        // prepare the first effect and load the correct size thumbnail

        // thumbnail loader ensures that the size attribute is available

        PrepareAndLoadImageToViewL();

        }

    // process start view event

    else if( viewEvent )

        {

        HandleStartViewEventL( *viewEvent );

        }

    // process start transition event

    else if( transEvent )

        {

        HandleStartTransitionEventL( *transEvent );

        }

    // process pause event

    else if( pauseEvent )

        {

        HandlePauseEventL();

        }

    // process resume event

    else if( resumeEvent )

        {

        HandleResumeEventL();

        }

    // process user navigate to next

    else if( nextImageEvent )

        {

        HandleNextImageEventL();

        }

    // process toggling UI by pressing selection key

    else if( toggleControlUiEvent )

        {

        HandleToggleControlUiEventL();

        }

    // process user navigate to previous

    else if ( previousImageEvent )

        {

        HandlePreviousImageEventL();

        }

    else if(hdmiDecodeImageEvent || hdmiDisConnectEvent)

    	{

    	iHDMIFirstDecoded = ETrue;

    	if(iTNReadyReceived)

    		{

            TShwEventReadyToView readyToView;

            SendEventL(&readyToView);    		

    		}

    	}    	

    // no other events are interesting for us

    }

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

// HandleFocusChangedL.

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

void CShwEffectControl::HandleFocusChangedL(

    TInt aFocusIndex, TReal32 /*aItemsPerSecond*/, MGlxVisualList* /*aList*/,

    NGlxListDefs::TFocusChangeType /*aType*/ )

    {

    TRACER("CShwEffectControl::HandleFocusChangedL");

    GLX_LOG_INFO1( "CShwEffectControl::HandleFocusChangedL %d", aFocusIndex );

    // set current as previous

    iPreviousVisual = iCurrentVisual;

    // take new current

    iCurrentVisual = iVisualList.Visual( aFocusIndex );

    // we need to remove the high quality thumbnails we dont plan

    // to show in near future, so focus minus range to left minus one

    // is the first to unload

    TInt indexToUnloadBackwards = NextListIndex( KRangeLeftFromFocus - 1 );

    // check that this index is not in focus or next from focus

    // this can happen if the list to play is really short

    if( ( indexToUnloadBackwards != aFocusIndex )&&

        ( indexToUnloadBackwards != NextListIndex( KNavigateForwards ) ) )

        {

        // ok, not visible so can unload

        iThumbnailLoader->Unload( indexToUnloadBackwards );

        }

    // unload also range + 1 as user might navigate backwards fast

    TInt indexToUnloadForwards = NextListIndex( KRangeRightFromFocus + 1 );

    // check that this index is not in focus or next from focus

    // this can happen if the list to play is really short

    if( ( indexToUnloadForwards != aFocusIndex )&&

        ( indexToUnloadForwards != NextListIndex( KNavigateForwards ) ) )

        {

        // ok, not visible so can unload

        iThumbnailLoader->Unload( indexToUnloadForwards );

        }

    }

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

// HandleSizeChanged.

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

void CShwEffectControl::HandleSizeChanged(

    const TSize& /*aSize*/, MGlxVisualList* /*aList*/ )

    {

    // nothing to be done

    }

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

// HandleToggleControlUiEventL.

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

void CShwEffectControl::HandleToggleControlUiEventL()

    {

    // nothing to be done

    }

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

// HandleVisualRemoved.

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

void CShwEffectControl::HandleVisualRemoved(

    const CAlfVisual* aVisual, MGlxVisualList* /*aList*/ )

    {

    TRACER("CShwEffectControl::HandleVisualRemoved");

    GLX_LOG_INFO( "CShwEffectControl::HandleVisualRemoved" );

    // remove the layout for this visual just to make sure we dont use it

    //subhasis commented 1 line

	//API depricated in visual list manager

    iSplitter.RemoveLayout( aVisual );

    }

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

// HandleVisualAddedL.

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

void CShwEffectControl::HandleVisualAddedL(

    CAlfVisual* /*aVisual*/, TInt /*aIndex*/, MGlxVisualList* /*aList*/ )

    {

    // nothing to be done

    }

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

// HandleThumbnailLoadedL.

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

void CShwEffectControl::HandleThumbnailLoadedL( TInt aIndex )

    {

    TRACER("CShwEffectControl::HandleThumbnailLoadedL");

    TInt focus = iVisualList.FocusIndex();

    GLX_LOG_INFO2( 

        "CShwEffectControl::HandleThumbnailLoadedL %d, focus %d", aIndex, focus );

    // check the index

    // was it on focus, we cannot check the state as it can be either

    // view or transition because of user navigation

    if( aIndex == focus )

        {

        GLX_LOG_INFO( 

            "HandleThumbnailLoadedL - sending TShwEventReadyToView" );

        iTNReadyReceived = ETrue;

        // its focus index so lets send ready to view

        // send ready to view event

        if(iHDMIFirstDecoded)

        	{

            TShwEventReadyToView readyToView;

            SendEventL( &readyToView );              	

        	}

        }

    // is it next from focus

    else if( aIndex == NextListIndex( KNavigateForwards ) )

        {

        GLX_LOG_INFO( 

            "HandleThumbnailLoadedL - sending TShwEventReadyToAdvance" );

        // send ready to advance command, 

        // it tells the observers that we are ready to advance to next image

        TShwEventReadyToAdvance readyToAdvance;

        SendEventL( &readyToAdvance );

        }

    }

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

// HandleThumbnailLoadFailureL.

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

void CShwEffectControl::HandleThumbnailLoadFailureL( TInt aIndex )

    {

    TRACER("CShwEffectControl::HandleThumbnailLoadFailureL");

    GLX_LOG_INFO1( "CShwEffectControl::HandleThumbnailLoadFailureL %d", aIndex );

    // We cant remove the errornous item from the medialist so 

    // at the moment we just proceed as normal

    // user will then see a broken icon for a while

    // we need to remember this index however as we dont want to start the

    // effect for it

    iFailedThumbnailIndex = aIndex;

    TInt focus = iVisualList.FocusIndex();

    if (aIndex == focus)

    	{

        iHDMIFirstDecoded = ETrue;    	

    	}

    HandleThumbnailLoadedL( aIndex );

    }

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

// HandleMediaListEmpty

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

void CShwEffectControl::HandleMediaListEmpty()

    {

    TRACER("CShwEffectControl::HandleMediaListEmpty");

    GLX_LOG_INFO( "CShwEffectControl::HandleMediaListEmpty" );

    // need to remove the contexts from medialist as closing down will 

    // take a while

    // stop observing the visual list

    iVisualList.RemoveObserver( this );

    // delete the thumbnail loader

    delete iThumbnailLoader;

    // set to NULL to prevent double delete

    iThumbnailLoader = NULL;

    // send fatal error message

    TShwEventFatalError errmessage;

    // need to TRAP as we cannot leave

    TRAPD( error, SendEventL( &errmessage ) );

    // was there an error

    if( error != KErrNone )

        {

        // panic engine as nothing else can be done

        NShwEngine::Panic( NShwEngine::EEngineFatalError );

        }

    }

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

// PrepareAndLoadImageToViewL

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

void CShwEffectControl::PrepareAndLoadImageToViewL()

    {

    TRACER("CShwEffectControl::PrepareAndLoadImageToViewL");

    // get current index

    TInt currentIndex = iVisualList.FocusIndex();

    // get current effect

    MShwEffect* currentEffect = iEffectManager.CurrentEffect();

    __ASSERT_ALWAYS( 

        currentEffect, NShwEngine::Panic( NShwEngine::ENullCurrentEffect ) );

    // set the current visual, since on first time there has not been navigation

    iCurrentVisual = iVisualList.Visual( currentIndex );

    /// get the image size from thumbnail loader

    TSize imgSize = iThumbnailLoader->ImageSizeL( currentIndex );

    // tell the effect to prepare for viewing current visual

    // thumbnail size is returned

    TSize thumbnailSize = 

        currentEffect->PrepareViewL( iCurrentVisual, imgSize );

    // ask the thumbnail loader to load the thumbnail

    // once the thumbnail is loaded, we get a callback

    iThumbnailLoader->LoadAndNotifyL(

        currentIndex, thumbnailSize );

    }

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

// HandleStartViewEventL.

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

void CShwEffectControl::HandleStartViewEventL( TShwEventStartView& aEvent )

    {

    TRACER("CShwEffectControl::HandleStartViewEventL");

    GLX_LOG_INFO( "CShwEffectControl::HandleStartViewEventL" );

    // remember the current view length, it is packaged into the event

    iViewDuration = aEvent.Parameter();

    // update the state

    iState = EShwEffectStateInView;

	//following code commented to remove layout dependency

	//! to be refactored

	// get the focus index

	TInt currentIndex = iVisualList.FocusIndex();

    // tell effect to exit transition

    // if we got view event and loop is already started

   if( iEffectLoopRestarted )

        {

        // exit transition for the previous effect and visual

        // this is done first since the next effect may be same

        // as previous

        iPreviousEffect->ExitTransition( iPreviousVisual );

        // remove layout from splitter

        iSplitter.RemoveLayout( iPreviousVisual );

        }

    else

        {

        // get the current effect

        MShwEffect* currentEffect = iEffectManager.CurrentEffect();

        // remove the old layout

        iSplitter.RemoveLayout( iCurrentVisual );

        // check if this thumbnail was succesfully loaded

		if ( iFailedThumbnailIndex == currentIndex )

		    {

        	// set the temporary layout for default icon

        	iSplitter.SetLayoutL( &iDefaultIconLayout, iCurrentVisual );

		    }

		else

		    {

	            // enter the view mode for visual

	            // ask the layout chain and set that to the current visual

	            // set also effect fade-in

	        		iSplitter.SetLayoutL( 

	    			currentEffect->EnterViewL( 

	    				iCurrentVisual, 

	    				iViewDuration, 

	    				KFirstEffectFadeInDuration ), 

	    			iCurrentVisual );

		    }

		// bring the focus visual to the front

		iCurrentVisual->MoveToFront();    

		}

	//parts of the code commented to remove layout dependency

	//! to be refactored

    // get next index forwards

    TInt nextIndex = NextListIndex( KNavigateForwards );

    // need to tell the next effect to prepare for the view

    // get next effect

    MShwEffect* nextEffect = iEffectManager.Effect( KNavigateForwards );

    // get next visual

    CAlfVisual* nextVisual = iVisualList.Visual( nextIndex );

    // get the real size of the image

    TSize imgSize = iThumbnailLoader->ImageSizeL( nextIndex );

    // tell the effect to prepare to view the next visual

    // thumbnail size is returned

    TSize thumbnailSize = 

       nextEffect->PrepareViewL( nextVisual, imgSize );

    // ask the thumbnail loader to load next thumbnail

    iThumbnailLoader->LoadAndNotifyL( nextIndex, thumbnailSize );

    }