/*

* Copyright (c) 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: Thumbnail manager for the social phonebook.  

*

*/

// class header

#include "CPbk2ThumbnailManager.h"

// external includes 

#include <CPbk2ImageManager.h>

#include <CVPbkContactManager.h>

#include <MVPbkStoreContact.h>

#include <MVPbkContactOperationBase.h>

#include <TPbk2ImageManagerParams.h>

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactLink.h>

#include <MVPbkFieldType.h>

#include <barsread.h>	//tresource reader

#include <gulicon.h>  

//INTERNAL

#include "CPbk2ContactViewListBox.h"

#include "CPbk2IconArray.h"

// Virtual Phonebook

#include <MVPbkBaseContact.h>

#include <MVPbkFieldType.h>

#include <CVPbkContactManager.h>

#include <TVPbkFieldTypeMapping.h>

#include <MVPbkContactViewBase.h>

//Pbk2

#include <Pbk2UIControls.rsg>

#include <Pbk2UID.h>

namespace {

// Default size for thumbnail images

#define KDefaultThumbnailSize TSize(36,36)

// icon offset. Thumbnail indexing starts from 10000 in CPbk2IconArray, so that there is 0 - 9999 indexes free for 

// phonebook's own icons

const TInt KIconIndexOffset = 10000;

// loading limit for thumbnails

const TInt KLoadingLimit = 100;

// loading queue limit

const TInt KQueueLimit = 25;

// Denotes Start Index for an item in the any Queue

const TInt KStartIndex = 0;

// Granularity of the thumbnail array

const TInt KThumbnailArrayGranularity = 200;

}

/*

 * Helper class for mapping between contact link + image + index on listbox

 */

NONSHARABLE_CLASS( CPbk2TmItem ) : public CBase

	{

public:	// constructor & destructor

	// Takes ownership of items

	static CPbk2TmItem* NewL( MVPbkContactLink* aLink, 

							  TInt aListboxIndex );

	~CPbk2TmItem();

public:	//new functions

	/*

	 * Returns contact link

	 */

	inline MVPbkContactLink* GetLink();

	/*

	 * Returns corresponding bitmap

	 */

	inline CFbsBitmap* GetBitmap();

	/*

	 * Returns index on listbox

	 */

	inline TInt	GetListboxIndex() const;

	/*

	 * Returns index on Pbk2IconArray

	 */

	inline TInt GetIconArrayIndex() const;

	/*

	 * Returns icon id

	 */

	inline const TPbk2IconId& GetIconId() const;

	/*

	 * Getter for has thumbnail flag

	 */

	inline TBool HasThumbnail();

	/*

	 * deletes link and bitmap 

	 */

	inline void DeleteBitmap();

	/*

	 * Setter for bitmap, deletes old one if set

	 */

	inline void SetBitmap( CFbsBitmap* aBitmap );

	/*

	 * Setter for listbox index

	 */

	inline void SetListboxIndex( TInt aIndex );

	/*

	 * Setter for Pbk2IconArray index

	 */

	inline void SetIconArrayIndexAndId( TInt aIndex, TPbk2IconId aId );

	/*

	 * Setter for has thumbnail flag

	 */

	inline void SetHasThumbnail( TBool aValue );

	/*

	 * Compare function for sorting

	 */

	static TInt CompareByListboxIndex( 

			const CPbk2TmItem& aItem1, const CPbk2TmItem& aItem2 );

private:	// constructor

	CPbk2TmItem( MVPbkContactLink* aLink, 

				 TInt aListboxIndex );

private:	//data

	// OWN: contact link

	MVPbkContactLink* 	iLink;

	// OWN: thumbnail

	CFbsBitmap* 		iBitmap;

	// index to listbox

	TInt				iIndexOnListbox;

	// index to icon array

	TInt				iPbkIconArrayIndex;

	// icon id

	TPbk2IconId 		iIconId;

	// informs whether the item has thumbnail image on contact database

	TBool				iHasThumbnail;

	};

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

// CPbk2TmItem::NewL

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

//

CPbk2TmItem* CPbk2TmItem::NewL( MVPbkContactLink* aLink, 

								TInt aListboxIndex )

    {

    CPbk2TmItem* self = new( ELeave )CPbk2TmItem( aLink, 

												  aListboxIndex );

    return self;	

    }

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

// CPbk2TmItem::CPbk2TmItem

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

//

CPbk2TmItem::CPbk2TmItem( MVPbkContactLink* aLink, 

						  TInt aListboxIndex ):	

    iLink( aLink ),

	iIndexOnListbox( aListboxIndex ),

	iHasThumbnail( EFalse )	

	{

	}

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

// CPbk2TmItem::~CPbk2TmItem

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

//

CPbk2TmItem::~CPbk2TmItem()

	{

	delete iLink;

	delete iBitmap;

	}

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

// CPbk2TmItem::CompareByListboxIndex

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

//

TInt CPbk2TmItem::CompareByListboxIndex( 

		const CPbk2TmItem& aItem1, const CPbk2TmItem& aItem2 )

	{

	TInt i = aItem1.GetListboxIndex();

	TInt j = aItem2.GetListboxIndex();

	return i-j;

	}

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

// CPbk2TmItem::GetLink

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

//

inline MVPbkContactLink* CPbk2TmItem::GetLink()

	{

	return iLink;

	}

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

// CPbk2TmItem::GetBitmap

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

//

inline CFbsBitmap*	CPbk2TmItem::GetBitmap()

	{

	return iBitmap;

	}

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

// CPbk2TmItem::GetListboxIndex

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

//

inline TInt CPbk2TmItem::GetListboxIndex() const

	{

	return iIndexOnListbox;

	}

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

// CPbk2TmItem::GetIconArrayIndex

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

//

inline TInt CPbk2TmItem::GetIconArrayIndex() const

	{

	return iPbkIconArrayIndex;

	}

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

// CPbk2TmItem::HasThumbnail

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

//

inline TBool CPbk2TmItem::HasThumbnail()

	{

	return iHasThumbnail;

	}

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

// CPbk2TmItem::GetIconId

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

//

inline const TPbk2IconId& CPbk2TmItem::GetIconId() const

	{

	return iIconId;

	}

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

// CPbk2TmItem::ClearValues

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

//

inline void CPbk2TmItem::DeleteBitmap( )

	{

	delete iBitmap;

	iBitmap = NULL;

	}

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

// CPbk2TmItem::SetBitmap

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

//

inline void CPbk2TmItem::SetBitmap( CFbsBitmap* aBitmap )

	{

	delete iBitmap;

	iBitmap = aBitmap;

	}

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

// CPbk2TmItem::SetListboxIndex

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

//

inline void CPbk2TmItem::SetListboxIndex( TInt aIndex )

	{

	iIndexOnListbox = aIndex;

	}

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

// CPbk2TmItem::SetIconArrayIndexAndId

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

//

inline void CPbk2TmItem::SetIconArrayIndexAndId( TInt aIndex, TPbk2IconId aId )

	{

	iPbkIconArrayIndex = aIndex;

	iIconId = aId;

	}

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

// CPbk2TmItem::SetHasThumbnail

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

//

inline void CPbk2TmItem::SetHasThumbnail( TBool aValue )

	{

	iHasThumbnail = aValue;

	}

/*********************************** THUMBNAIL MANAGER ************************************/

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

// CPbk2ThumbnailManager* CPbk2ThumbnailManager::NewL

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

//

EXPORT_C CPbk2ThumbnailManager* CPbk2ThumbnailManager::NewL( CVPbkContactManager& aContactManager )

   {

   CPbk2ThumbnailManager* self = new (ELeave) CPbk2ThumbnailManager( aContactManager );

   CleanupStack::PushL(self);

   self->ConstructL();

   CleanupStack::Pop();

   return self;

   }

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

// CPbk2ThumbnailManager::CPbk2ThumbnailManager

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

//

CPbk2ThumbnailManager::CPbk2ThumbnailManager( 

    CVPbkContactManager& aContactManager ) :

        iState( EIdle ),

        iContactThumbnails( KThumbnailArrayGranularity ),

        iContactManager( aContactManager ),

        iDefaultIconIndex( KErrNotFound )

	{

	}

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

// CPbk2ThumbnailManager::~CPbk2ThumbnailManager()

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

//

CPbk2ThumbnailManager::~CPbk2ThumbnailManager()

	{

	delete iInProgressItemToBeRemoved;

	delete iThumbOperation;

    delete iManager;

    delete iRetrieveOperation;

    delete iStoreContact;

    iContactThumbnails.ResetAndDestroy();

    iLoadingQueue.Reset();

    iPriorityArray.Reset();

    }

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

// CPbk2ThumbnailManager::ConstructL()

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

//

void CPbk2ThumbnailManager::ConstructL()

	{

	// image manager

	iManager = CPbk2ImageManager::NewL( iContactManager );

	// read file type for thumbnail field

	ReadFieldTypeL();

	}

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

// CPbk2ThumbnailManager::SetObserver()

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

//

void CPbk2ThumbnailManager::SetObserver( MPbk2ThumbnailManagerObserver& aObserver )

	{

	iObserver = &aObserver;

	}

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

// CPbk2ThumbnailManager::RemoveObserver()

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

//

void CPbk2ThumbnailManager::RemoveObserver()

	{

	iObserver = NULL;

	}

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

// CPbk2ThumbnailManager::ThumbnailCount()	

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

//

TInt CPbk2ThumbnailManager::ThumbnailCount()	

	{

	return iContactThumbnails.Count();

	}

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

// CPbk2ThumbnailManager::GetPbkIconIndexL()

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

//

TInt CPbk2ThumbnailManager::GetPbkIconIndexL( TInt aListboxIndex, const MVPbkBaseContact& aContactLink )

	{

	TInt arrIndex = iDefaultIconIndex;

	// check that requested thumbnail is allready added to thumbnail array

	if( Rng( 0, aListboxIndex, iContactThumbnails.Count() - 1 ) )

		{

		CPbk2TmItem* item = iContactThumbnails[ aListboxIndex ];

		if( !item )

		    {

            item = CPbk2TmItem::NewL( aContactLink.CreateLinkLC(), aListboxIndex );

            CleanupStack::Pop(); // link

            // set default icon index

            item->SetIconArrayIndexAndId( iDefaultIconIndex,iDefaultIconId );

            item->SetHasThumbnail( ETrue );

            iContactThumbnails[ aListboxIndex ] = item;

		    }

        // if item has a thumbnail image, but it is not loaded yet ( queue )

        if( item->HasThumbnail() && !item->GetBitmap() )

            {

            TBool reOrderItem = ETrue;

            TInt res = iLoadingQueue.Find( item );

            //remove from array if duplicate

            if( res != KErrNotFound )

                {

                // if item's position is 0 or 1, dont reorder

                if( res <= 1 )

                    {

                    reOrderItem = EFalse;

                    }

                // else remove item from the array for reordering

                else

                    {

                    iLoadingQueue.Remove( res );

                    }

                }

            // if item is to be reordered

            if( reOrderItem )

                {

                // if there are more than 2 items

                if( iLoadingQueue.Count() > 2 && iState == ELoading )

                    {

                    // insert to second position, first one is under loading

                    iLoadingQueue.Insert( item, 1 );

                    }

                // else append to first or second

                else

                    {

                    iLoadingQueue.Append( item );

                    }

                }

            //if idle, start loading

            if( iState == EIdle )

                {

                StartLoading();

                }

            }

        else

            {

            arrIndex = item->GetIconArrayIndex();

            }

		}

	return arrIndex;

	}

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

// CPbk2ThumbnailManager::SetDefaultIconId()

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

//

void CPbk2ThumbnailManager::SetDefaultIconId( TPbk2IconId aDefaultIconId )

	{

	if( iIconArray )

		{

		iDefaultIconIndex = iIconArray->FindIcon( aDefaultIconId );

		}

	iDefaultIconId = aDefaultIconId;

	}

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

// CPbk2ThumbnailManager::GetDefaultIconIndex()

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

//

const TPbk2IconId& CPbk2ThumbnailManager::GetDefaultIconId()

	{

	return iDefaultIconId;

	}

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

// CPbk2ThumbnailManager::SetPbkIconArray()

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

//

void CPbk2ThumbnailManager::SetPbkIconArray( CPbk2IconArray* aIconArray )

	{

	iIconArray = aIconArray;

	}

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

// CPbk2ThumbnailManager::RemoveIconArray()

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

//

void CPbk2ThumbnailManager::RemoveIconArray()

	{

	// no more icon array

	iIconArray = NULL;

	const TInt count = iContactThumbnails.Count();

	// set all the indexes to default because there is no items in icon array to refer to

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

		{