/*

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

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

/*

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

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

	//reset thumbnail array

	iContactThumbnails.Reset();

	}

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

// 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::GetPbkIconIndex()

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

//

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

	{

	TBool reLoadThumbnail = EFalse;

	TInt arrIndex = iDefaultIconIndex;

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

	if( aListboxIndex < iContactThumbnails.Count() )

		{

		CPbk2TmItem* item = iContactThumbnails[ aListboxIndex ];

        // This is because when find is in use, the indexes are not mapped

		// directly to thumbnail managers indexes

		if( !item->GetLink()->RefersTo( aContactLink ) )

		    {

            // try to find correct one from the array based on contact link

            item = FindItem( aContactLink );

		    }

		if( item )

		    {

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

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

                {

                reLoadThumbnail = ETrue;

                }

            else

                {

                arrIndex = item->GetIconArrayIndex();

                }

		    }

		//if item and thumbnail index was not found ( queue limit ), reload thumbnail

		if( reLoadThumbnail )

			{

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

				}

			}

		}

	return arrIndex;

	}

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

// CPbk2ThumbnailManager::FindItem()

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

//

CPbk2TmItem* CPbk2ThumbnailManager::FindItem( const MVPbkBaseContact& aContactLink )

	{

	const TInt count = iContactThumbnails.Count();

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

		{

		if( iContactThumbnails[ i ]->GetLink()->RefersTo( aContactLink ) )

			{

			return iContactThumbnails[i];

			}

		}

	// shouldn't come here ever

	return NULL;

	}

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

// CPbk2ThumbnailManager::SetDefaultIconId()

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

//

void CPbk2ThumbnailManager::SetDefaultIconId( TPbk2IconId aDefaultIconId )

	{

	if( iIconArray )

		{

		iDefaultIconIndex = iIconArray->FindIcon( aDefaultIconId );

		}

	iDefaultIconId = aDefaultIconId;

	}

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

// CPbk2ThumbnailManager::GetDefaultIconIndex()

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

//

const TPbk2IconId& CPbk2ThumbnailManager::GetDefaultIconId()

	{

	return iDefaultIconId;

	}