/**

 @file

 @internalComponent

 @released

*/

#include <cntviewsortplugin.h>

#include "cntviewprivate.h"

#include "cviewcontactmanager.h"

#include <cntviewbase.h>

const TInt KContactsArrayGranularity = 100;

const TInt KUnsortedArrayGranularity = 16;

/**

@SYMPatchable

@publishedPartner

@released

Patchable constant for the number of CViewContacts to read into memory 

before merging them into a larger sorted list (via a heap sort).

When the view contacts are merged, their text fields are released from memory. 

The larger the constant the faster a View containing large numbers of items is created. 

However, a larger constant will use more RAM for large Views.

The constant can be changed at ROM build time using patchdata OBY keyword.

*/

IMPORT_C extern const TInt KNumberOfContactsToReadPerMerge;

/**

@internalComponent

@released

Number of Contacts to process per invocation of the Sorter

Local Views can't do much whilst sorting, but we want to allow other

Active Objects in the thread to run. Use to be 50 for the DBMS version, 75 here to match

performance (i.e. should occupy the server for the same amount of time).

*/    

const TInt KNumberOfContactsToReadPerChunk = 75;

/** 

Private constructor

*/

CViewContactManager::CViewContactManager(CContactLocalView& aLocalView, MLplViewIteratorManager& aLplViewMgr, TContactViewPreferences aViewPreferences, CViewContactSortPlugin* aSortPlugin)

: iLocalView(aLocalView),

  iViewSessionId(KPLViewSessionIdNull),   

  iViewContacts(NULL), 

  iUnsortedViewContacts(NULL), 

  iViewContactsBuffer(NULL), 

  iSortPluginImpl(aSortPlugin), 

  iViewPreferences(aViewPreferences),

  iLplViewItemMgr(aLplViewMgr) 

    {

    }

/** 

Destructor

*/

CViewContactManager::~CViewContactManager()

    {

    if(iViewSessionId != KPLViewSessionIdNull)

        {

    	iLplViewItemMgr.CloseView(iViewSessionId);

        }

    delete iIdleSorter;

    if(iViewContacts)

    	{

    	iViewContacts->ResetAndDestroy();

		delete iViewContacts;	

    	}	

	if (iUnsortedViewContacts)

		{

		iUnsortedViewContacts->ResetAndDestroy();

		delete iUnsortedViewContacts;	

		}	

	if(iViewContactsBuffer)

		{

		iViewContactsBuffer->ResetAndDestroy();

		delete iViewContactsBuffer;

		}

	//The class doesn't own iSortPluginImpl,so don't release it here.

    }

/** 

Static factory constructor. Uses two phase construction and 

leaves nothing on the CleanupStack.

@return A pointer to the newly created CViewContactManager object.

*/

CViewContactManager* CViewContactManager::NewL(CContactLocalView& aLocalView, MLplPersistenceLayerFactory& aFactory, const CContactTextDef& aTextDef, TContactViewPreferences aViewPreferences, CViewContactSortPlugin* aSortPlugin)

    {

    MLplViewIteratorManager& lplViewIteratorManager = aFactory.GetViewIteratorManagerL();

	CViewContactManager* self = new(ELeave) CViewContactManager(aLocalView, lplViewIteratorManager, aViewPreferences, aSortPlugin);

	CleanupStack::PushL(self);

	self->ConstructL(aFactory, aTextDef);

	CleanupStack::Pop(self);

	return self;

    }

/** 

Constructor

*/

void CViewContactManager::ConstructL(MLplPersistenceLayerFactory& aFactory, const CContactTextDef& aTextDef)

	{

	iViewContacts = new(ELeave) RPointerArray<CViewContact>(KContactsArrayGranularity);

	iUnsortedViewContacts = new(ELeave) RPointerArray<CViewContact>(KUnsortedArrayGranularity);

	// Collation method by index 0 stays the same (only changes at a reboot)

 	iCollationMethod = *Mem::CollationMethodByIndex(0);

 	iCollationMethod.iFlags |= TCollationMethod::EIgnoreNone;

	iViewSessionId = iLplViewItemMgr.OpenViewL(aTextDef, iViewPreferences);

    //Create idle thread to prepare sort asynchronisely		

	iIdleSorter = CIdleContactSorter::NewL(*this, aFactory, iViewPreferences);	

	}

/** 

Start sorting with stored sort order.

*/

void CViewContactManager::SortL()

	{

	iIdleSorter->Stop();	

	iLplViewItemMgr.BeginIterateL(iViewSessionId);

	ResetSort();

	iIdleSorter->Start();	

	}

/** 

Start sorting with given sort order/text definition.

@param aTextDef new text definition would be used for sorting.

*/

void CViewContactManager::SortL(const CContactTextDef& aTextDef)

	{

	//Stop current sorting.

	iIdleSorter->Stop();	

	iLplViewItemMgr.EndIterateL(iViewSessionId);

	iLplViewItemMgr.ChangeSortOrderL(iViewSessionId, aTextDef);

	//Restart iterating with changed sort order 

	iLplViewItemMgr.BeginIterateL(iViewSessionId);

	ResetSort();

	iIdleSorter->Start();	

	}

/** 

Start current sorting.

*/

void CViewContactManager::StopSortL()

	{

	//Stop current sorting.

	iIdleSorter->Stop();	

	//Call the lpl layer to stop iterating view contacts.

	iLplViewItemMgr.EndIterateL(iViewSessionId);

	}

/** 

Reset contact ids arrays for resort or initial sort, this is called 

when database complete restoring data or view is creating(first sort).

*/

void CViewContactManager::ResetSort()

    {

	ASSERT(iViewContacts);

    iViewContacts->ResetAndDestroy();

	ASSERT(iUnsortedViewContacts);

    iUnsortedViewContacts->ResetAndDestroy();

	if(iViewContactsBuffer)

		{

		iViewContactsBuffer->ResetAndDestroy();

		delete iViewContactsBuffer;

		iViewContactsBuffer = NULL;

		}

    }

/** 

Implementation of MContactViewSortObserver interface, this is called with:

1. TIccViewNotify_IccOnlyLocked: The view is ICCEntryOnly view and ICC store is locked.

2. TIccViewNotify_IccUnlocked: The view include ICCEntry and ICC store is unlocked 

                               (resort is needed)

@param  aIccViewNotify flag to show if ICC store is locked or not.

@return ETrue if there is still view contact in database and needs idle

        sorting asynchroniser call back again.

@leave KErrNoMemory Out of memory.

@leave KErrNotFound The view session cannot be found.

*/

void  CViewContactManager::IccViewNotifyL(TInt aIccViewNotify)

    {

    switch(aIccViewNotify)

        {

        case TIccViewNotify_IccOnlyLocked:

            iLocalView.SetState(CContactLocalView::EReady);

            break;

        case TIccViewNotify_IccUnlocked:

            iLocalView.SetState(CContactLocalView::ENotReady);

        	iLplViewItemMgr.EndIterateL(iViewSessionId);

            break;

        }

    }

/** 

Implementation of MContactViewSortObserver interface, this is called by

the idle sorting asynchroniser repeatly. 

@param  aSortErr if there is error occurs in idle sorting asynchroniser.

@return ETrue if there is still view contact in database and needs idle

        sorting asynchroniser call back again.

*/

TBool CViewContactManager::IdleSorterNotifyL(TInt aSortErr)

	{

	if(aSortErr != KErrNone)

		{

		TInt err = KErrNone;

		TRAP(err, iLplViewItemMgr.EndIterateL(iViewSessionId));

		iLocalView.SortComplete(aSortErr);

		return EFalse;

		}

	if(!iViewContactsBuffer)

		{

		//Create a temporary buffer for reading view contact objects.

		iViewContactsBuffer = new(ELeave) RPointerArray<CViewContact>(KContactsArrayGranularity);

		}

	CViewContactManager::TReadState readState = ReadInViewContactsL(*iViewContactsBuffer);

    if(readState == EReadFullChunk)

		{

		// Full chunk of view contact items have been read, so request another read.

		return ETrue;

		}

	//Reach here only when readState is EReadFullForMerge or EReadCompleted

	if (iSortPluginImpl)

		{

		// prepare View Sort plug-in

		User::LeaveIfError(iSortPluginImpl->SortStart(CViewContactSortPlugin::ESortStartFull, iViewContactsBuffer->Count()));

		}

	// sort the view contacts in buffer

	HeapSortL(*iViewContactsBuffer);

	if(iViewContacts->Count() > 0)		

		{

		//There are sorted view objects stored in iViewContacts, merging is needed.

		RPointerArray<CViewContact>* mergedArray = MergeL(*iViewContacts, *iViewContactsBuffer);	

		// all view contact objects have been merged into iViewContacts, 

		// clean up the buffer array. 

		iViewContactsBuffer->Reset();

		iViewContacts->Close();

		delete iViewContacts;

		iViewContacts = mergedArray;

		}

	else

		{

		//It's first time we get a list of sorted view contat objects

		iViewContacts->Close();

		delete iViewContacts;

		iViewContacts = iViewContactsBuffer;	

		iViewContactsBuffer = NULL;

		}

	if (iSortPluginImpl)

		{

		iSortPluginImpl->SortCompleted();

		}

	if(readState == EReadCompleted)

		{

		//Sorting is complete.

		iLplViewItemMgr.EndIterateL(iViewSessionId);

		iLocalView.SortComplete(KErrNone);

		return EFalse;

		}

	return ETrue;

	}

/** 

Fill in the given view contacts buffer by asking underlying persistence layer,

and add all unsorted view contacts into unsorted array directly.

@param  aViewContacts CViewContact objects array to fill in and sort.

@return One of enum in TReadState, see the definition in TReadState for detail

*/

CViewContactManager::TReadState CViewContactManager::ReadInViewContactsL(RPointerArray<CViewContact>& aViewContacts)

    {

	TInt total = aViewContacts.Count();

	// process a chunk of contacts

	CViewContact* contact = NULL;

	//Here to use current sorting view preference in iIdleSorter who knows

	//if we can access ICCEntry store now, therefore decides if we should read in

	//ICCEntry contacts from the database.

	TContactViewPreferences sortViewPref = iIdleSorter->SortViewPreferences();

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

		{

		contact = iLplViewItemMgr.NextItemL(iViewSessionId, sortViewPref);

		if(contact == NULL)

			{

    		return EReadCompleted;

			}

		CleanupStack::PushL(contact);

		if(IsContactSortable(*contact,iViewPreferences))

			{

			aViewContacts.AppendL(contact);

			CleanupStack::Pop(contact);

		    if(++total >= KNumberOfContactsToReadPerMerge)

		        {

		        return EReadFullForMerge;

		        }

			}

		else if(iViewPreferences & (EUnSortedAtBeginning | EUnSortedAtEnd))

			{

			// It's an unsortable contact, just append its lightweight object

			// to unsortable view contacts list.

			contact->ChangeToLightweightObject();

			iUnsortedViewContacts->AppendL(contact);

			CleanupStack::Pop(contact);

			}

		else

			{

			CleanupStack::PopAndDestroy(contact);

			}

		}

	return EReadFullChunk;

    }

/** 

Check if the contact type uid matchs the view preferences.

@param  aContactTypeUid contact type uid to check.

@param  aTypeToInclude  view preferences have flags to define which contact the view should have.

@return ETrue if the uid match or reverse.

*/

TBool CViewContactManager::ContactCorrectType(TUid aContactTypeUid, TContactViewPreferences aTypeToInclude)

	{

	TBool correctType(EFalse);

	if (aContactTypeUid==KUidContactCard || aContactTypeUid==KUidContactOwnCard)

		{

		// Ignore Unsorted Contacts flags & White Space flag

		// catch non- contact views

		// Should be EContactsOnly, EContactAndGroups & EICCEntriesAndContacts

		if (0 == ((aTypeToInclude & ~(ESingleWhiteSpaceIsEmptyField | EIgnoreUnSorted | EUnSortedAtBeginning | EUnSortedAtEnd))

				& (EGroupsOnly | EICCEntriesOnly))) // Ignore 'UnSorted' flags, exclude Groups Only & ICC Only 

			{

			correctType = ETrue;

			}

		}

	else if (aContactTypeUid == KUidContactGroup)

		{

		if (aTypeToInclude & (EGroupsOnly | EContactAndGroups))

			{

			correctType = ETrue;

			}

		}

	else if (aContactTypeUid == KUidContactICCEntry)

		{

		if (aTypeToInclude & (EICCEntriesOnly | EICCEntriesAndContacts))

			{

			correctType = ETrue;

			}

		}

	return correctType;

	}

/** 

Heap sort the give view contacts array.

@param  aContacts the array of view contacts to be sorted.

@leave  leave errors from CContactViewBase::CompareContactsAndIdsL

*/

void CViewContactManager::HeapSortL(RPointerArray<CViewContact>& aContacts)

	{

	// HeapSort (stolen from RPointerArrayBase)

	TInt ss = aContacts.Count();

	if ( ss>1 )

		{

		TInt sh = ss>>1;

		FOREVER

			{

			CViewContact* si;

			if (sh != 0)

				{

				// make heap

				--sh;

				si = aContacts[sh];

				}

			else

				{

				// sort heap

				--ss;

				si = aContacts[ss];

				aContacts[ss] = aContacts[0];

				if (ss == 1)

					{

					aContacts[0] = si;

					break;

					}

				}

			// sift down

			TInt ii = sh;

			TInt jj = sh;

			FOREVER

				{

				jj = (jj+1)<<1;

				if ((jj >= ss) || (iLocalView.CompareContactsAndIdsL(*aContacts[jj-1],*aContacts[jj]) > 0))

					{

					--jj;

					}

				if ((jj >= ss) || (iLocalView.CompareContactsAndIdsL(*aContacts[jj],*si) <= 0))

					{

					break;

					}

				aContacts[ii] = aContacts[jj];

				ii = jj;

				} //FOREVER

			aContacts[ii] = si;

			} //FOREVER

		} //if (ss > 1)

	}

/** 

Merge two view contacts array into a result array, here we always assume the items in 

aRightContacts are fulfilled objects.

@param  aLeftContacts  the left array of view contacts to be merged.

@param  aRightContacts the right array of view contacts to be merged.

@return the final merged array.

*/

RPointerArray<CViewContact>* CViewContactManager::MergeL(RPointerArray<CViewContact>& aLeftContacts, RPointerArray<CViewContact>& aRightContacts)

    {

	TInt indexLeft(0);

	TInt indexRight(0);

	const TInt KCountLeft = aLeftContacts.Count();

	RPointerArray<CViewContact>* resultContacts = new(ELeave) RPointerArray<CViewContact>(KContactsArrayGranularity);	

	CleanupStack::PushL(TCleanupItem(ResetAndDestroyRPointerArrayPointer, resultContacts));

    while(indexLeft < KCountLeft && indexRight < aRightContacts.Count())

		{

		CViewContact* firstLeftContact = static_cast<CViewContact*>(aLeftContacts[indexLeft]);

		CViewContact* firstRightContact = static_cast<CViewContact*>(aRightContacts[indexRight]);

		if(firstLeftContact->IsLightweightObject())

			{

			//The current contact in iViewContact is lightweight object, so we need to load the

			//fulfilled view contact to compare.

			CViewContact* contact = iLplViewItemMgr.ItemAtL(firstLeftContact->Id(), iViewSessionId);				

			if(contact == NULL)

				{

				//The already sorted contact is not in database!!!

				User::Leave(KErrNotFound);

				}

			CleanupStack::PushL(contact);    

			firstLeftContact->CopyL(*contact);

			CleanupStack::PopAndDestroy(contact);

			}

        TInt diff = CompareContactsAndIdsL(*firstLeftContact, *firstRightContact);

		if(diff > 0)

			{

			resultContacts->AppendL(firstRightContact);

			firstRightContact->ChangeToLightweightObject();

			++indexRight;

			}

		else

			{		

			resultContacts->AppendL(firstLeftContact);

			firstLeftContact->ChangeToLightweightObject();