/*

* 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 <glxuiutility.h>                               // For UiUtility instance

#include <glxtracer.h>

#include <glxlog.h>

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

#include <mglxcache.h> 

#include <ganes/HgDoubleGraphicList.h>

const TInt KPreviewThumbnailFetchCount(1);

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

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

    // Filter that filters out any GIF, corrupted images     

    iThumbnailIterator.SetRange(KPreviewThumbnailFetchCount);

    iThumbnailContext = new (ELeave) CGlxAttributeContext(&iThumbnailIterator); 

    TMPXAttribute tnAttr( KGlxMediaIdThumbnail,

                        GlxFullThumbnailAttributeId(ETrue,

                            iGridIconSize.iWidth,iGridIconSize.iHeight) );

    iThumbnailContext->SetDefaultSpec(iGridIconSize.iWidth,

                                                iGridIconSize.iHeight);

    iThumbnailContext->AddAttributeL(tnAttr);

    }

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

// Destructor

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

//

CGlxPreviewThumbnailBinding::~CGlxPreviewThumbnailBinding()

	{

	TRACER("CGlxPreviewThumbnailBinding::~CGlxPreviewThumbnailBinding");

    // close any medialist that exist

	if( iMediaList )

		{

        iMediaList->RemoveMediaListObserver( this );

        iMediaList->RemoveContext(iThumbnailContext);

        iMediaList->Close();

        iMediaList = NULL;

		}

    delete iThumbnailContext;

    delete iPreviewFilter;

	// cancel any outstanding request of the timer

	if(iTimer->IsActive())

	    {

	    iTimer->Cancel();

	    }

	delete iTimer;

	}

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

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

            const CGlxThumbnailAttribute* value = item.ThumbnailAttribute(

            if (value)

                {

                CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

                ScaleBitmapToListSizeL(value->iBitmap, bitmap);

                }

    }

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

// 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, TBool  aIsRefreshNeeded, TBool aBackwardNavigation)

    {

    TRACER("CGlxPreviewThumbnailBinding::HandleItemChangedL");

    iTimerTicked = EFalse;

    iPopulateListTNs = aPopulateListTNs;

    iIsRefreshNeeded = aIsRefreshNeeded;

    // remove and close old medialist   

    if( iMediaList )

	    {

	    iTrialCount = 0;

	    iMediaList->RemoveMediaListObserver( this );

        iMediaList->RemoveContext(iThumbnailContext);

        iMediaList->Close();

        iMediaList = NULL;

	    }

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

    iMediaList->AddContextL(iThumbnailContext, KGlxFetchContextPriorityNormal);

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

	iMediaList->AddMediaListObserverL(this);

	if(aBackwardNavigation)

	    {

	    //On backward navigation start the timer manually, since we do not  

        //get the attribute callback.

        }

    }

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

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

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

//    

    {

    TRACER("CGlxPreviewThumbnailBinding::StartTimer");

    if (iTimer)

        {

        iTimer->Cancel();

        }

    if (iPopulateListTNs)

        {

        }

     }

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

// StopTimer - Stop the timer

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

//    

void CGlxPreviewThumbnailBinding::StopTimer()

    {

    TRACER("CGlxPreviewThumbnailBinding::StopTimer");

    if (iTimer && iTimer->IsActive())

        {

        iTimer->Cancel();

        }

    }

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

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

	        {

            // sometimes we get HandleAttributesAvailableL callback after some delay

            // when we do cache cleanup. 

            if(!iPopulateListTNs)

            	{

            	iPopulateListTNs = ETrue;

            	} 

            }

        }

    }

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

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

    {

    }

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

// HandlePopulatedL

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

//

void CGlxPreviewThumbnailBinding::HandlePopulatedL( MGlxMediaList* /*aList*/ )

    {

	TRACER("CGlxPreviewThumbnailBinding::HandlePopulatedL()");

	// Do cache cleanup. If iIsRefreshNeeded is set,

	// then clean up the item at 0th index 

	if (iPopulateListTNs && iIsRefreshNeeded)

		{

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

			{

			GLX_LOG_INFO("**** Cache Cleanup ****");

			MGlxCache* cacheManager = MGlxCache::InstanceL();

			cacheManager->ForceCleanupMedia(iMediaList->IdSpaceId(0),

					iMediaList->Item(0).Id());

			cacheManager->Close();

			}

		}

	//Start the timer

	}

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

// ScaleBitmapToListSizeL

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

//

void CGlxPreviewThumbnailBinding::ScaleBitmapToListSizeL(

        CFbsBitmap* aSrcBitmap, CFbsBitmap* aDestBitmap)

    {

    TRACER("CGlxPreviewThumbnailBinding::ScaleBitmapToListSizeL()");

    TSize destSize = CHgDoubleGraphicList::PreferredImageSize();

    TSize srcSize = aSrcBitmap->SizeInPixels();

    if (destSize.iHeight * srcSize.iWidth < destSize.iWidth * srcSize.iHeight)

        {

        // Source has taller aspect than target so reduce target width

        destSize.iWidth = ((destSize.iHeight * srcSize.iWidth)

                / (srcSize.iHeight));

        }

    else

        {

        // Source has wider aspect than target so reduce target height

        destSize.iHeight = (destSize.iWidth * srcSize.iHeight)

                / srcSize.iWidth;

        }

    aDestBitmap->Create(destSize, aSrcBitmap->DisplayMode());

    CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(aDestBitmap);

    CleanupStack::PushL(bitmapDevice);

    CFbsBitGc* bitmapGc = CFbsBitGc::NewL();

    CleanupStack::PushL(bitmapGc);

    bitmapGc->Activate(bitmapDevice);

    bitmapGc->DrawBitmap(TRect(destSize), aSrcBitmap);

    CleanupStack::PopAndDestroy(bitmapGc);

    CleanupStack::PopAndDestroy(bitmapDevice);

    }