/*

* 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:    Utility that contains HUI related slideshow code

 *

*/

// INCLUDES

#include "shwthumbnailloader.h"

// DEPENDENCIES

#include <mpxattributespecs.h>

#include <mpxmediadrmdefs.h>

#include <glxlog.h>

#include <glxtracer.h>

#include <glxmedialistiterator.h>

#include <mglxmedialistobserver.h>

#include <mglxmedialist.h>

#include <glxthumbnailcontext.h>

#include <glxattributecontext.h>

#include <glxmediageneraldefs.h>

#include <glxattributeretriever.h>

#include "shwslideshowenginepanic.h"

#include "shwthumbnailcontext.h"

#include "shwcallback.h"

#include "shwconstants.h"   // for context priorities

using namespace NShwSlideshow;

/**

 * CShwThumbnailLoaderImpl

 * Implementation dependencies for the thumbnail loading

 */

NONSHARABLE_CLASS( CShwThumbnailLoader::CShwThumbnailLoaderImpl )

	: public CBase,

	public MGlxMediaListObserver

	{

	public:

		/**

		 * Constructor

		 * inlined as only ever called inside this cpp

		 * @param aMedialist the media list

		 */

		inline CShwThumbnailLoaderImpl( 

			MGlxMediaList& aMedialist, 

			MShwThumbnailLoadObserver& aErrorHandler );

		/**

		 * Destructor. 

		 * inlined as only ever called inside this cpp

		 */

		inline ~CShwThumbnailLoaderImpl();

		/**

		 * 2nd phase constructor

		 * inlined as only ever called inside this cpp

		 */

		inline void ConstructL();

		/** 

		 * @ref CShwThumbnailLoader::LoadAndNotifyL

		 * inlined as only ever called inside this cpp

		 */

		inline void LoadAndNotifyL( TInt aIndex, TSize aSize );

		/** 

		 * @ref CShwThumbnailLoader::Unload

		 * inlined as only ever called inside this cpp

		 */

		inline void Unload( TInt aIndex );

		/** 

		 * @ref CShwThumbnailLoader::ImageSizeL

		 * inlined as only ever called inside this cpp

		 */

		inline TSize ImageSizeL( TInt aIndex );

	public: // from MGlxMediaListObserver

		/// @ref MGlxMediaListObserver::HandleItemAddedL

		void HandleItemAddedL( 

			TInt aStartIndex, TInt aEndIndex, MGlxMediaList* aList );

		/// @ref MGlxMediaListObserver::HandleMediaL

		void HandleMediaL( 

			TInt aListIndex, MGlxMediaList* aList );

		/// @ref MGlxMediaListObserver::HandleItemRemovedL

		void HandleItemRemovedL( 

			TInt aStartIndex, TInt aEndIndex, MGlxMediaList* aList );

		/// @ref MGlxMediaListObserver::HandleItemModifiedL

		void HandleItemModifiedL( 

			const RArray<TInt>& aItemIndexes, MGlxMediaList* aList );	

		/// @ref MGlxMediaListObserver::HandleAttributesAvailableL

		void HandleAttributesAvailableL(

			TInt aItemIndex, 

			const RArray<TMPXAttribute>& aAttributes, 

			MGlxMediaList* aList );

		/// @ref MGlxMediaListObserver::HandleFocusChangedL

		void HandleFocusChangedL( 

			NGlxListDefs::TFocusChangeType aType, 

			TInt aNewIndex, 

			TInt aOldIndex, 

			MGlxMediaList* aList );

		/// @ref MGlxMediaListObserver::HandleItemSelectedL

		void HandleItemSelectedL( 

			TInt aIndex, TBool aSelected, MGlxMediaList* aList );

		/// @ref MGlxMediaListObserver::HandleMessageL

		void HandleMessageL( 

			const CMPXMessage& aMessage, MGlxMediaList* aList );

		/// @ref MGlxMediaListObserver::HandleError

		void HandleError( TInt aError );

	private: // Implementation

        // implementation of the error handler

        inline void DoHandleErrorL();

		// Helper functions to find an element in the array given an index

		// used in three places, load, unload and handleattributes available

		// @param the index of the element to find

		// @return the index of the element in the array, KErrNotFound otherwise

		inline TInt Find( TInt aIndex );		

		// @return the context if found, NULL otherwise

		inline CShwThumbnailContext* FindContext( TInt aIndex );

		// Helper function to create the size context

		inline void AddSizeContextL();

        /// Helper function to notify client of successfull or failed thumbnail load

        inline void NofifyClientIfInterestedL( TInt aIndex, TBool aSuccess );

		// Helper function to remove high quality context from given index

		inline void RemoveHighQualityContext( TInt aIndex );

	public: // TCallBack API

		// Helper function to notify thumbnail completion asynchronously

		inline TInt CompletedNotifyL();

		// Helper function to notify thumbnail failure asynchronously

		inline TInt ErrorNotifyL();

		// Helper function to handle the error

		inline TInt AsyncErrorHandleL();

	private:	// Implementation & Data

		/// Ref: the media list

		MGlxMediaList& iMedialist;

		/// Ref: the error handler

		MShwThumbnailLoadObserver& iThumbnailObserver;

		/// Own: the array for the thumbnail notifications

		RArray< TInt > iNotificationIndexes;

		/// Own: the array for already completed indexes

		RArray< TInt > iCompletedIndexes;

		/// Own: the array for already faulty indexes

		RArray< TInt > iErrorIndexes;

		/// Own: the array of high quality contexts

		RPointerArray< CShwThumbnailContext > iHighQualityContexts;

		/// Own: the size context

		CGlxDefaultAttributeContext* iSizeContext;

		/// Own: async callback needed in case image is already loaded

		CAsyncCallBack* iCompletedCallBack;

		/// Own: async callback needed in case image had already an error

		CAsyncCallBack* iErrorCallBack;

		/// Own: async callback for showing the out of memory system dialog

		CAsyncCallBack* iErrorHandlerCallBack;

		/// Own: the error code

		TInt iError;

	};

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

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

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

inline CShwThumbnailLoader::CShwThumbnailLoader()

	{

	}

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

// NewL. Static construction

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

CShwThumbnailLoader* CShwThumbnailLoader::NewL(

	MGlxMediaList& aMedialist, MShwThumbnailLoadObserver& aErrorHandler )

	{

	TRACER("CShwThumbnailLoader::NewLs");

	CShwThumbnailLoader* self = new( ELeave ) CShwThumbnailLoader;

	CleanupStack::PushL( self );

// 2nd phase >>

	// create implementation

	self->iImpl = 

		new( ELeave ) CShwThumbnailLoaderImpl( aMedialist, aErrorHandler );

	// call 2nd phase

	self->iImpl->ConstructL();

// << 2nd phase

	// pop the stack

	CleanupStack::Pop( self );

	return self;

	}

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

// Destructor

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

CShwThumbnailLoader::~CShwThumbnailLoader()

	{

	TRACER("CShwThumbnailLoader::~CShwThumbnailLoader");

	delete iImpl;

	}

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

// LoadThumbnailAndNotifyL.

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

void CShwThumbnailLoader::LoadAndNotifyL( TInt aIndex, TSize aSize )

	{

	TRACER("CShwThumbnailLoader::LoadAndNotifyL");

	// forward

	iImpl->LoadAndNotifyL( aIndex, aSize );

	}

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

// Unload.

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

void CShwThumbnailLoader::Unload( TInt aIndex )

	{

	TRACER("CShwThumbnailLoader::Unload");

	// forward

	iImpl->Unload( aIndex );

	}

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

// CShwThumbnailLoaderImpl::ImageSizeL.

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

TSize CShwThumbnailLoader::ImageSizeL( TInt aIndex )

	{

	TRACER("CShwThumbnailLoader::ImageSizeL");

	// forward

	return iImpl->ImageSizeL( aIndex );

	}

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

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

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

inline CShwThumbnailLoader::CShwThumbnailLoaderImpl::CShwThumbnailLoaderImpl(

	MGlxMediaList& aMedialist, MShwThumbnailLoadObserver& aErrorHandler )

	: iMedialist( aMedialist ),

	iThumbnailObserver( aErrorHandler )

	{

	TRACER("CShwThumbnailLoader::CShwThumbnailLoaderImpl::CShwThumbnailLoaderImpl()");

	}

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

// CShwThumbnailLoaderImpl::Destructor.

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

inline CShwThumbnailLoader::CShwThumbnailLoaderImpl::~CShwThumbnailLoaderImpl()

    {

    TRACER("CShwThumbnailLoader::CShwThumbnailLoaderImpl::~CShwThumbnailLoaderImpl()");

    // delete asynch callbacks, delete also cancels them

    delete iCompletedCallBack;

    delete iErrorCallBack;

    delete iErrorHandlerCallBack;

    // size context, remove NULL does nothing

    iMedialist.RemoveContext( iSizeContext );

    delete iSizeContext;

    // Remove all contexts from the media list

    TInt count = iHighQualityContexts.Count();

    while ( count-- > 0 )

        {

        // get the fetch context so that we can remove it from the media list

        MGlxFetchContext* context = iHighQualityContexts[ count ]->Context();

        // high quality context, remove NULL does nothing

        iMedialist.RemoveContext( context );

        };

    // delete the contexts array, this deletes the CShwThumbnailContexts

    iHighQualityContexts.ResetAndDestroy();

    // remove us from media list observers

    iMedialist.RemoveMediaListObserver( this );

    // close notification indexes array

    iNotificationIndexes.Close();

    // close also the already completed indexes array

    iCompletedIndexes.Close();

    // close also the errornous indexes array

    iErrorIndexes.Close();

    }

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

// CShwThumbnailLoaderImpl::ConstructL

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

inline void CShwThumbnailLoader::CShwThumbnailLoaderImpl::ConstructL()

    {

    TRACER("CShwThumbnailLoader::CShwThumbnailLoaderImpl::ConstructL");

    // retrieve the size of images with own context

    AddSizeContextL();

    // add us as media list observer

    iMedialist.AddMediaListObserverL( this );

    // create async callback object to give 

    // callbacks once scheduler runs, give this high priority so that it 

    // is faster than the timers we have

    iCompletedCallBack = new( ELeave ) CAsyncCallBack( CActive::EPriorityHigh );

    // set the callback

    iCompletedCallBack->Set(TShwCallBack<CShwThumbnailLoaderImpl,

            &CShwThumbnailLoaderImpl::CompletedNotifyL> (this));

    // create async callback to give error callbacks once scheduler runs

    iErrorCallBack = new( ELeave ) CAsyncCallBack( CActive::EPriorityHigh );

    // set the callback

    iErrorCallBack->Set(TShwCallBack<CShwThumbnailLoaderImpl,

            &CShwThumbnailLoaderImpl::ErrorNotifyL> (this));

    // create async callback to give callback once we run onto errors

    iErrorHandlerCallBack = new( ELeave ) CAsyncCallBack( CActive::EPriorityHigh );

    // set the callback

    iErrorHandlerCallBack->Set(TShwCallBack<CShwThumbnailLoaderImpl,

            &CShwThumbnailLoaderImpl::AsyncErrorHandleL> (this));

    }

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

// CShwThumbnailLoaderImpl::ImageSizeL.

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

inline TSize CShwThumbnailLoader::CShwThumbnailLoaderImpl::ImageSizeL( 

	TInt aIndex )

    {

    TRACER("CShwThumbnailLoader::CShwThumbnailLoaderImpl::ImageSizeL");

    GLX_LOG_INFO1( "CShwThumbnailLoader::ImageSizeL for index %d", aIndex );

	// default to KErrNotFound

	TSize size( KErrNotFound, KErrNotFound );

    // get the media item

    TGlxMedia item = iMedialist.Item( aIndex );

    // get its dimensions, if they are not available, size is not modified

    // if size is not available, GetDimensions returns EFalse

    if( !item.GetDimensions( size ) )

        {

        // size was not available so try to fetch it with attribute retriever

        (void)GlxAttributeRetriever::RetrieveL(

            *iSizeContext, iMedialist, 

            EFalse /*aShowDialog*/ );

        // get the media item again since its just a copy and the old one

        // might not have had the CGlxMedia* set

        item = iMedialist.Item( aIndex );

        // cast to (void) tells the compiler we ignore

        // the fetcher error as there is nothing to do if the fetch fails

        // in that case the size will be (KErrNotFound,KErrNotFound)

        // try getting the dimensions again

        (void)item.GetDimensions( size );

        }

    GLX_LOG_INFO2( 

        "CShwThumbnailLoader::ImageSizeL (%d,%d)", size.iWidth, size.iHeight );

    return size;

    }

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

// CShwThumbnailLoaderImpl::LoadAndNotifyL.

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

inline void CShwThumbnailLoader::CShwThumbnailLoaderImpl::LoadAndNotifyL( 

	TInt aIndex, TSize aSize )

	{

	TRACER("CShwThumbnailLoader::CShwThumbnailLoaderImpl::LoadAndNotifyL");

	GLX_LOG_INFO1( "CShwThumbnailLoader::LoadAndNotifyL %d", aIndex );

	// check whether a context already exists for this index

	CShwThumbnailContext* context = FindContext( aIndex );

	if( !context )

		{

		// create new context for the index with the given size

		iHighQualityContexts.AppendL( context );

		CleanupStack::Pop( context );

		// add the context to the medialist with priority

		iMedialist.AddContextL( 

			context->Context(), KHighQualityContextPriority );

		}

    // add the index to notifications array so that we know to give 

    // either success or error notification once for the request

	// Note that we can have multiple requests for same index

	iNotificationIndexes.InsertInOrderAllowRepeatsL( aIndex );

	// need to check if the thumbnail is already loaded

	// when request count is zero (KErrNone) the thumbnail is fully loaded

	TInt requestCount = context->RequestCountL( &iMedialist );

	if( requestCount == KErrNone )

		{

		// thumbnail is already there

		// we cant give the callback right away as the client is expecting

		// this method to be always asynchronous

		GLX_LOG_INFO1( 

			"CShwThumbnailLoader::Thumbnail already loaded %d", aIndex );

    	// insert index to completed array

    	// Note that we can have multiple requests for same index

    	iCompletedIndexes.InsertInOrderAllowRepeatsL( aIndex );

		// cancel the old callback

		iCompletedCallBack->Cancel();

		// make the callback

		iCompletedCallBack->CallBack();

		}

	else if ( requestCount < KErrNone )

		{

		// thumbnail had already and error

		GLX_LOG_INFO2( 

			"CShwThumbnailLoader::Thumbnail error %d at index, %d", 

			    requestCount, aIndex );

		// we cant give the callback right away as the client is expecting

		// this method to be always asynchronous

    	// Note that we can have multiple requests for same index

    	iErrorIndexes.InsertInOrderAllowRepeatsL( aIndex );

		// cancel the old callback

		iErrorCallBack->Cancel();

		// make the callback

		iErrorCallBack->CallBack();

		}

	}

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

// CShwThumbnailLoaderImpl::Unload

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

inline void CShwThumbnailLoader::CShwThumbnailLoaderImpl::Unload( TInt aIndex )

	{

	TRACER("CShwThumbnailLoader::CShwThumbnailLoaderImpl::Unload");

	GLX_LOG_INFO1( "CShwThumbnailLoader::Unload %d", aIndex );

    // client is no longer interested on this indes so remove it from the

    // notifications

	TInt index;

	while( ( index = iNotificationIndexes.Find( aIndex ) ) != KErrNotFound )

		{

		// remove the index from array

		iNotificationIndexes.Remove( index );

		}

    // remove context for this index

    RemoveHighQualityContext( aIndex );

	}

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

// CShwThumbnailLoaderImpl::HandleItemAddedL.

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

void CShwThumbnailLoader::CShwThumbnailLoaderImpl::HandleItemAddedL(

	TInt /*aStartIndex*/, TInt /*aEndIndex*/, MGlxMediaList* /*aList*/ )

	{

	}

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

// CShwThumbnailLoaderImpl::HandleMediaL.

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

void CShwThumbnailLoader::CShwThumbnailLoaderImpl::HandleMediaL(

	TInt /*aListIndex*/, MGlxMediaList* /*aList*/ )

	{

	}

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

// CShwThumbnailLoaderImpl::HandleItemRemovedL.

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

void CShwThumbnailLoader::CShwThumbnailLoaderImpl::HandleItemRemovedL(

	TInt /*aStartIndex*/, TInt /*aEndIndex*/, MGlxMediaList* /*aList*/ )

	{

	TRACER("CShwThumbnailLoader::CShwThumbnailLoaderImpl::HandleItemRemovedL");

	// check if we still got some items to show

	if( iMedialist.Count() < 1 )

	    {

		// the media list is empty so call our error handler

		iThumbnailObserver.HandleMediaListEmpty();

	    }

	}

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

// CShwThumbnailLoaderImpl::HandleItemModifiedL.

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

void CShwThumbnailLoader::CShwThumbnailLoaderImpl::HandleItemModifiedL( 

	const RArray<TInt>& /*aItemIndexes*/, MGlxMediaList* /*aList*/ )

	{

	}

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

// CShwThumbnailLoaderImpl::HandleAttributesAvailableL.

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

void CShwThumbnailLoader::CShwThumbnailLoaderImpl::HandleAttributesAvailableL(

	TInt aItemIndex, const RArray<TMPXAttribute>& aAttributes/**/, 

	MGlxMediaList* /*aList*/ )

	{

	TRACER("CShwThumbnailLoader::CShwThumbnailLoaderImpl::HandleAttributesAvailableL");

	//done to verify context availability

	TInt attributeCount = aAttributes.Count();

	for(TInt i = 0; i < attributeCount; i++ )

		{

		TMPXAttribute attr = aAttributes[i];	

		}

	GLX_LOG_INFO1( 

	    "CShwThumbnailLoader::HandleAttributesAvailableL %d", aItemIndex );

	// check if the thumbnail was fully loaded, first find the related context

	CShwThumbnailContext* context = FindContext( aItemIndex );

	if( context )

		{

		// Check if there was an error

		TInt requestCount = context->RequestCountL( &iMedialist );

		if ( requestCount == KErrNone )

			{

			// no error, notify client

			GLX_LOG_INFO1( 

				"CShwThumbnailLoader::Thumbnail loaded %d", aItemIndex );

			// notidy client of success if it is interested on this index

			NofifyClientIfInterestedL( aItemIndex, ETrue );

			}

		else if ( requestCount < 0 )

			{

			GLX_LOG_INFO1( 

				"CShwThumbnailLoader::Thumbnail load failed %d", aItemIndex );

    		// remove the context since there is an error in loading it