/*

* Copyright (c) 2008-2009 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 : Class defination for preview thumbnail in list view

*

*/

#include <mglxmedialist.h>

#include <glxthumbnailcontext.h>

#include <glxfilterfactory.h>                         // For TGlxFilterFactory

#include <glxthumbnailattributeinfo.h>

#include "glxpreviewthumbnailbinding.h"

#include "glxgeneraluiutilities.h"

#include <glxuiutility.h>                               // For UiUtility instance

#include <glxtracer.h>

#include <glxlog.h>

#include <glxuistd.h>                    // Fetch context priority def'ns

const TInt KInitialThumbnailsTimeDelay(100000);

const TInt KWaitCount(5);

const TInt KThumbnailStartTimeDelay(2000000);

const TInt KThumbnailIntervalTimeDelay(2000000);

const TInt KPreviewThumbnailFetchCount(18);

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

// NewL

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

//

CGlxPreviewThumbnailBinding* CGlxPreviewThumbnailBinding::NewL(

        MPreviewTNObserver& aObserver)

	{

	TRACER("CGlxPreviewThumbnailBinding::NewL");

	CGlxPreviewThumbnailBinding* self = CGlxPreviewThumbnailBinding::NewLC(aObserver);

	CleanupStack::Pop(self);

	return self;	

	}

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

// NewLC

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

//

CGlxPreviewThumbnailBinding* CGlxPreviewThumbnailBinding::NewLC(

        MPreviewTNObserver& aObserver)

	{

	TRACER("CGlxPreviewThumbnailBinding::NewLC");

	CGlxPreviewThumbnailBinding* self = new(ELeave)CGlxPreviewThumbnailBinding(aObserver);

	CleanupStack::PushL(self);

    self->ConstructL();

	return self;

	}

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

// Constructor

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

//

CGlxPreviewThumbnailBinding::CGlxPreviewThumbnailBinding(

        MPreviewTNObserver& aObserver)

: iObserver(aObserver)

	{

	}

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

// ConstructL

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

//

void CGlxPreviewThumbnailBinding::ConstructL()

    {

    TRACER("CGlxPreviewThumbnailBinding::ConstructL");

    iTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();

    iGridIconSize = uiUtility->GetGridIconSize();

    uiUtility->Close() ;

    }

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

// Destructor

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

//

CGlxPreviewThumbnailBinding::~CGlxPreviewThumbnailBinding()

	{

	TRACER("CGlxPreviewThumbnailBinding::~CGlxPreviewThumbnailBinding");

    // close any medialist that exist

	if( iMediaList )

		{

        iMediaList->RemoveMediaListObserver( this );

        iMediaList->RemoveContext(iThumbnailContext);

        delete iThumbnailContext;

        iMediaList->Close();

        iMediaList = NULL;

		}

	// cancel any outstanding request of the timer

	if(iTimer->IsActive())

	    {

	    iTimer->Cancel();

	    }

	delete iTimer;

	iTimer = NULL;

	iPreviewItemCount.Close();

	}

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

// TimerTickedL: we need to update only when required i.e, when the thumbnail count 

// has not reached till the max limit to be shown

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

//

void CGlxPreviewThumbnailBinding::TimerTickedL()

    {

    TRACER("CGlxPreviewThumbnailBinding::TimerTickedL");

    if(iMediaList && iMediaList->Count() && iPreviewItemCount.Count() )

       	{

    	TInt thumbnailIndex = iPreviewItemCount[iProgressIndex];

    	if(thumbnailIndex < iMediaList->Count())

    	    {

            const TGlxMedia& item = iMediaList->Item(thumbnailIndex);

            TMPXAttribute thumbnailAttribute(KGlxMediaIdThumbnail, 

                GlxFullThumbnailAttributeId( ETrue,  iGridIconSize.iWidth,

                        iGridIconSize.iHeight ) );

            const CGlxThumbnailAttribute* value = item.ThumbnailAttribute(

                    thumbnailAttribute );

            if (value)

                {

                CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

                bitmap->Duplicate( value->iBitmap->Handle());

                iObserver.PreviewTNReadyL(bitmap, NULL,iProgressIndex);

                iProgressIndex++;

                if (iProgressIndex >= KPreviewThumbnailFetchCount || 

                    iProgressIndex >= iPreviewItemCount.Count() ||

                    iProgressIndex >= iMediaList->Count())

                    {

                    iProgressIndex = 0;

                    }

                }

    	    }

       	}

    else if (iPopulateListTNs && iMediaList && iMediaList->Count() == 0)

	    {

	    if (iTrial == KWaitCount)

		    {		   

		    iObserver.PreviewTNReadyL(NULL, NULL, KErrNotFound);

		    iTrial=0;

		    return;

		    }

	    iTrial++;

	    }

    else if(iMediaList && iMediaList->Count() )

    	{

		if(iProgressIndex > iMediaList->Count()-1 )

			{

			iProgressIndex = 0;

			}

		const TGlxMedia& item = iMediaList->Item(iProgressIndex);

		TMPXAttribute thumbnailAttribute(KGlxMediaIdThumbnail, 

			GlxFullThumbnailAttributeId( ETrue,  iGridIconSize.iWidth, 

			        iGridIconSize.iHeight ) );

		const CGlxThumbnailAttribute* value = item.ThumbnailAttribute( 

		        thumbnailAttribute );

		if (value)

			{

			CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

			bitmap->Duplicate( value->iBitmap->Handle());

			iObserver.PreviewTNReadyL(bitmap, NULL,iProgressIndex);

			iProgressIndex++;

			if (iProgressIndex >= KPreviewThumbnailFetchCount || 

				iProgressIndex >= iMediaList->Count())

				{

				iProgressIndex = 0;

				}

			}

		else

			{

			if (iTrialCount == KWaitCount)

				{				

				iObserver.PreviewTNReadyL(NULL, NULL, KErrNotFound);

				iTrialCount=0;

				return;

				}

			iTrialCount++;

			}

    	}   

    }

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

// IsTimeL callback function invoked when timer expires

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

//    

TInt CGlxPreviewThumbnailBinding::IsTimeL( TAny* aSelf )

    {

    TRACER("CGlxPreviewThumbnailBinding::IsTimeL");

    if (aSelf)

        {

        TRACER("CGlxPreviewThumbnailBinding::IsTimeL");

        CGlxPreviewThumbnailBinding* self = static_cast<CGlxPreviewThumbnailBinding*>(aSelf);

        if(self)

            {

            self->TimerTickedL();

           }

        }

    return KErrNone;        

    }

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

// HandleItemChangedL

// This function basically closes the old medialist if any for ex. Tags, 

// Captured.. and then opens a new medialist with teh required filter.

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

//    

void CGlxPreviewThumbnailBinding::HandleItemChangedL(const CMPXCollectionPath& aPath,

        TBool aPopulateListTNs )

    {

    TRACER("CGlxPreviewThumbnailBinding::HandleItemChangedL");

    iTimerTicked = EFalse;

    iPopulateListTNs = aPopulateListTNs;

    iProgressIndex = KErrNone;

    // remove and close old medialist   

    if( iMediaList )

	    {

	    // Reset the trial and the trialCount to 0 while deleting the medialist 

	    iTrial = 0;

	    iTrialCount = 0;

	    iMediaList->RemoveMediaListObserver( this );

        iMediaList->RemoveContext(iThumbnailContext);

        delete iThumbnailContext;

        iThumbnailContext = NULL;

        iMediaList->Close();

        iMediaList = NULL;

	    }

	// Filter that filters out any GIF, corrupted images    

    CMPXFilter* filter = NULL;

    filter = TGlxFilterFactory::CreatePreviewFilterL(); 

    CleanupStack::PushL( filter );

    // create new medialist with the required filter which filters out all DRM, GIFS and corrupt 

    // thumbnial

	iMediaList = MGlxMediaList::InstanceL( aPath ,KGlxIdNone, filter);

	iThumbnailContext = CGlxThumbnailContext::NewL( &iThumbnailIterator ); // set the thumbnail context

	iThumbnailIterator.SetRange( KPreviewThumbnailFetchCount ); // request for fifiteen thumbnails

	iThumbnailContext->SetDefaultSpec( iGridIconSize.iWidth,iGridIconSize.iHeight );

	iMediaList->AddContextL(iThumbnailContext ,KGlxFetchContextPriorityNormal );

	// adding the medialist to observ any changes or updates done

	iMediaList->AddMediaListObserverL(this);

	CleanupStack::PopAndDestroy( filter );

	//Start the timer

	StartTimer(iPopulateListTNs);

    }

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

// StartTimer - Starts the timer based on the flag populateListTN's

// where the flag will be true, when initially the first thumbnails in the list

// are populated.

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

//    

void CGlxPreviewThumbnailBinding::StartTimer(TBool aPopulateListTNs)

    {

    TRACER("CGlxPreviewThumbnailBinding::StartTimer");

    iPopulateListTNs = aPopulateListTNs;

    if (iTimer)

        {

        iTimer->Cancel();

        }

    if (iPopulateListTNs)

        {

        iTimer->Start(KInitialThumbnailsTimeDelay, KInitialThumbnailsTimeDelay, 

            TCallBack(IsTimeL,this));   

        }

    else

        {

        iTimer->Start(KThumbnailStartTimeDelay, KThumbnailIntervalTimeDelay,

            TCallBack(IsTimeL,this));               

        }

    }

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

// HasFirstThumbnail

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

// 

 TBool CGlxPreviewThumbnailBinding::HasFirstThumbnail( const RArray< TMPXAttribute >& aAttributes )

     {

     TRACER("CGlxPreviewThumbnailBinding::HasFirstThumbnail");

     TMPXAttribute thumbnailAttribute(KGlxMediaIdThumbnail, 

                                          GlxFullThumbnailAttributeId( ETrue, 

                                               iGridIconSize.iWidth,

                                                   iGridIconSize.iHeight) );

     TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );

     return ( KErrNotFound != aAttributes.Find( thumbnailAttribute, match ) );    

     }

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

// HandleItemAddedL

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

// 

void CGlxPreviewThumbnailBinding::HandleItemAddedL( TInt /*aStartIndex*/, TInt 

    /*aEndIndex*/, MGlxMediaList* /*aList*/ )

    {

    }

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

// HandleItemRemoved

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

//  

void CGlxPreviewThumbnailBinding::HandleItemRemovedL( TInt /*aStartIndex*/, TInt 

    /*aEndIndex*/, MGlxMediaList* /*aList*/ )

    {

    }

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

// HandleAttributesAvailableL

// Inside this function we are going to append the index for which we have valid 

// thumbnails and when the number of available thumbnails become equal to the 

// number of slots where thumbnail to be shown we go for updating them to visual

// item.

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

//  

void CGlxPreviewThumbnailBinding::HandleAttributesAvailableL( TInt aItemIndex, 

    const RArray<TMPXAttribute>& aAttributes, MGlxMediaList* /*aList*/ )

    {

    TRACER("CGlxPreviewThumbnailBinding::HandleAttributesAvailableL");

    TMPXAttribute thumbnailAttribute(KGlxMediaIdThumbnail, 

        GlxFullThumbnailAttributeId( ETrue,  iGridIconSize.iWidth, 

                iGridIconSize.iHeight ) );

    TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );

    if (KErrNotFound != aAttributes.Find( thumbnailAttribute, match ))

    	{

		const TGlxMedia& item = iMediaList->Item( aItemIndex );

        const CGlxThumbnailAttribute* value = item.ThumbnailAttribute( 

                thumbnailAttribute );

        if (value)

	        {

            iPreviewItemCount.AppendL( aItemIndex );

            }

        }

    }

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

// HandleFocusChangedL

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

//  

void CGlxPreviewThumbnailBinding::HandleFocusChangedL( NGlxListDefs::

    TFocusChangeType /*aType*/, TInt /*aNewIndex*/, TInt /*aOldIndex*/, 

    MGlxMediaList* /*aList*/ )

    {

    }

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

// HandleItemSelected

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

//  

void CGlxPreviewThumbnailBinding::HandleItemSelectedL(TInt /*aIndex*/, 

    TBool /*aSelected*/, MGlxMediaList* /*aList*/ )

    {

    }

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

// HandleMessageL

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

//    

 void CGlxPreviewThumbnailBinding::HandleMessageL( const CMPXMessage& /*aMessage*/, 

    MGlxMediaList* /*aList*/ )

    {

    }

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

// HandleError

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

//

void CGlxPreviewThumbnailBinding::HandleError( TInt /*aError*/ ) 

    {

    }

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

// HandleCommandCompleteL

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

//  

void CGlxPreviewThumbnailBinding::HandleCommandCompleteL( CMPXCommand* 

        /*aCommandResult*/, 

    TInt /*aError*/, MGlxMediaList* /*aList*/ )

    {

    }

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

// HandleMediaL

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

//  

void CGlxPreviewThumbnailBinding::HandleMediaL( TInt /*aListIndex*/, 

        MGlxMediaList* /*aList*/ )

    {

    }

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

// HandleItemModifiedL

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

//  

void CGlxPreviewThumbnailBinding::HandleItemModifiedL( const RArray<TInt>& 

        /*aItemIndexes*/,

    MGlxMediaList* /*aList*/ )

    {

    }