/*

* Copyright (c) 1997-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: 

*

*/

/**

 @file

 @internalComponent

 @released

*/

#include <cntdb.h>

#include "cntstd.h"

#include "rcntmodel.h"

#include "ccontactprivate.h"

#include "cntviewprivate.h"

const TInt KMaxItemsInTemplateCache = 8; // Maximum number of cached templates.

const TInt KInitialSortArraySize = 20; // Initial size of sort array.

/**

CTextFieldMinimal destructor.

*/

CTextFieldMinimal::~CTextFieldMinimal()

	{

	delete iText;

	}

/**

CTextFieldMinimal second phase constructor.

*/

void CTextFieldMinimal::ConstructL(const TDesC &aText, TContactItemId aId)

	{

	iText=aText.AllocL();

	iId=aId;

	}

/**

CSortArray first phase constructor.

*/

CSortArray::CSortArray()

	:

	iArray(KInitialSortArraySize)

	{

	}

/**

CSortArray destructor.

*/

CSortArray::~CSortArray()

	{

	iArray.ResetAndDestroy();

	iArray.Close();

	}

/**

Create a CTextFieldMinimal object using the given text and Contact ID and append

it to the sort array.

@param aText Text for CTextFieldMinimal object.

@param aId Contact ID for CTextFieldMinimal object.

*/

void CSortArray::AppendL(const TDesC &aText, TContactItemId aId)

	{

	CTextFieldMinimal *tm=new(ELeave) CTextFieldMinimal;

	CleanupStack::PushL(tm);

	tm->ConstructL(aText, aId);

	User::LeaveIfError(iArray.Append(tm));

	CleanupStack::Pop(); // tm

	}

/**

Sort the sort array using the given sort order.

@param aOrder EAsc for ascending order, EDesc for descending order.

*/

void CSortArray::SortL(CContactDatabase::TSortPref::TOrder aOrder)

	{

	// If nothing to sort then return immediately.

	if (iArray.Count()==0)

		{

		return;

		}

	// Sort the array in ascending sort order using the default algorithm to

	// compare the elements in the sort array.

	iArray.Sort(TLinearOrder<CTextFieldMinimal>(DefaultAlgorithmToCompareNames));

	// If descending sort order then reverse the elements in the sort array.

	if (aOrder==CContactDatabase::TSortPref::EDesc)

		{

		TInt count=Count();

		TInt end=count/2;

		TInt index2=count-1;

		for(TInt index=0;index<end;index++)

			{

			CTextFieldMinimal *tfm=(CTextFieldMinimal *)iArray[index];

			iArray[index]=iArray[index2];

			iArray[index2]=tfm;

			index2--;

			}

		}

	}

/**

Compare the text in the given CTextFieldMinimal objects.

The custom TCollation method is required to ensure that the collated comparison

will not ignore spaces and punctuation (which it does by default).

Mem::CollationMethodByIndex() is an exec call and is hence relatively expensive.

Although it is inefficient to create a collation method each time this method is

called, there is no benefit in storing TCollationMethod as a member of

CSortArray because this method must be static.

@param aName1

@param aName2

@return A positive value if text in aName1 is greater than text in aName2, a

negative value if text in aName1 is less than text in aName2 and zero if the

text in both aName1 and aName2 is the same.

*/

TInt CSortArray::DefaultAlgorithmToCompareNames(const CTextFieldMinimal& aName1, const CTextFieldMinimal& aName2)

	{

	TCollationMethod collateMethod;

	collateMethod = *Mem::CollationMethodByIndex(0);

	collateMethod.iFlags|=TCollationMethod::EIgnoreNone;

	return aName1.iText->CompareC(*aName2.iText,3,&collateMethod);

	}

/**

Get the Contact ID at the given index in the sort array.

@return The Contact ID at the given index.

*/

TContactItemId CSortArray::Id(TInt aIndex) const

	{

	return(((CTextFieldMinimal *)iArray[aIndex])->iId);

	}

/**

Get the text at the given index in the sort array.

@return The text at the given index.

*/

HBufC* CSortArray::Text(TInt aIndex) const

	{

	return(((CTextFieldMinimal *)iArray[aIndex])->iText);

	}

/**

Merge the given sort array with this sort array starting from the given position

in this sort array.

@param aDuplicates The sort array to be merged with this sort array.

@param aStartPos The starting position for the merge in this sort array.

*/

void CSortArray::Merge(CSortArray *aDuplicates,TInt aStartPos)

	{

	TInt numDuplicates=aDuplicates->Count();

	for (TInt loop=0;loop<numDuplicates;loop++)

		{

		const TInt index=aStartPos+loop;

		delete iArray[index];

		iArray[index]=aDuplicates->iArray[0];

		aDuplicates->iArray.Remove(0);

		}

	}

/**

CCntTemplateCache object factory.

@return CCntTemplateCache object.

*/

CCntTemplateCache* CCntTemplateCache::NewL(RCntModel& aCntSvr)

	{

	CCntTemplateCache* templateCache = new(ELeave) CCntTemplateCache(aCntSvr);

	return templateCache;		

	}

/**

CCntTemplateCache first phase constructor.

@param aCntSvr Client Contacts Model session object handle.

*/

CCntTemplateCache::CCntTemplateCache(RCntModel& aCntSvr)

	:

	iCache(KMaxItemsInTemplateCache),

	iCntSvr(aCntSvr),

	iTemplateId(KGoldenTemplateId)

	{

	}

/**

CCntTemplateCache destructor.

*/

CCntTemplateCache::~CCntTemplateCache()

	{

	iCache.ResetAndDestroy();

	delete iViewDef;

	delete iSystemTemplate;

	}

/**

Delete an entry from the template cache.

@param aIndex Index of entry in template cache to be deleted.

*/

void CCntTemplateCache::DeleteEntry(TInt aIndex)

	{

	delete iCache [aIndex];

	iCache.Remove(aIndex);

	}

/**

Remove a template from the template cache.

@param aId ID of the template which is to be removed from the template cache.

*/

void CCntTemplateCache::RemoveTemplate(TContactItemId aId)

	{

	for(TInt ii=iCache.Count() - 1; ii >= 0; --ii)

		{

		if (iCache[ii]->Id() == aId)

			{

			DeleteEntry(ii);	

			}

		}

	// Are we removing the system template?

	if (iSystemTemplate != NULL && iSystemTemplate->Id() == aId)	

		{

		delete iSystemTemplate;

		iSystemTemplate = NULL;	

		}

	}

/**

Get the system template.  If the system template does not yet exist then

create it (lazy initialisation).

@return CContactItem object reference for the system template.

*/

CContactItem& CCntTemplateCache::SystemTemplateL() 

	{

	if (!iSystemTemplate)

		{

		CContactItemViewDef* matchAll = CContactItemViewDef::NewLC(	CContactItemViewDef::EMaskFields,

																CContactItemViewDef::EIncludeHiddenFields);

		iSystemTemplate = static_cast<CContactItem*>(iCntSvr.ReadContactL(matchAll, KGoldenTemplateId));

		CleanupStack::PopAndDestroy(matchAll);

		}

	return *iSystemTemplate;

	}

/**

Dispose of the system template.  The next time the system template is accessed

via the SystemTemplateL() method it will be fetched from the Server.

*/

void CCntTemplateCache::ResetSystemTemplate()

	{

	delete iSystemTemplate;

	iSystemTemplate = NULL;

	}

/**

Get a template from the template cache with the given ID.

@param Contact item ID of the template.

@return CContactItem object reference for the template.

*/

CContactItem& CCntTemplateCache::TemplateL(TContactItemId aId)

	{

	if (aId == KGoldenTemplateId)

		return SystemTemplateL();

	CContactItem *retVal = NULL;

	TInt maxCount 		 = iCache.Count();

	TInt ii				 = maxCount;

	// Try to find the template in the cache.

	while(ii) 

		{

		--ii;	

		if (iCache[ii]->Id() == aId)

			{

			retVal = iCache[ii];

			break; // Stop searching

			}

		}

	if (!retVal) // Template does not exist in cache.

		{

		// Read the template from the Server.

		CContactItemViewDef* matchAll = CContactItemViewDef::NewLC(	CContactItemViewDef::EMaskFields,

										CContactItemViewDef::EIncludeHiddenFields);

		retVal = iCntSvr.ReadContactL(matchAll, aId);

		CleanupStack::PopAndDestroy(matchAll);

		if (maxCount == KMaxItemsInTemplateCache)

			{

			// Remove the first item from the cache (cache is maintained in

			// using FIFO behaviour i.e. oldest template is removed when cache

			// size is exceeded.

			DeleteEntry(0);

			}

		iCache.Append(retVal);		

		}

	return *retVal;

	}

/**

Get the default view definition for the template cache.  If the default view 

definition does not yet exist then create it (lazy initialisation).

@return CContactItemViewDef object reference.

@leave KErrNoMemory Out of memory.

*/

CContactItemViewDef& CCntTemplateCache::DefaultViewDefL()

	{

	if (!iViewDef)

		{

		iViewDef = CContactItemViewDef::NewL(CContactItemViewDef::EIncludeFields, CContactItemViewDef::EIncludeHiddenFields);

		iViewDef->AddL(KUidContactFieldMatchAll);

		}

	return *iViewDef;	

	}

/**

Merge the given Contact Item with the template used to create the Contact Item.

If no view definition is supplied then use the default view definition.

@param aContact Contact Item to be merged with template.

@param aViewDef View definition to use.

*/

void CCntTemplateCache::MergeWithTemplateL(CContactItem& aContact, const CContactItemViewDef* aViewDef)

	{

	if (aContact.TemplateRefId()!= KNullContactId && aContact.Type() != KUidContactCardTemplate)

		{

		CContactItemViewDef* viewDef = NULL;

		if(aViewDef == NULL) // Only create a viewDef if none has been given.

			{

			viewDef = &(DefaultViewDefL());

			}

		else 

			{

			viewDef = const_cast<CContactItemViewDef*>(aViewDef);	

			}

		// Restore template fields.

		if (aContact.TemplateRefId() != KNullContactId && aContact.Type() != KUidContactCardTemplate)

			{

			// Get the template ID used to create the Contact Item.

			CContactItem* contactTemplate=&(static_cast<CContactTemplate&>(TemplateL(aContact.TemplateRefId())));

			aContact.RestoreTemplateFieldsL(SystemTemplateL().CardFields(), contactTemplate->CardFields(), const_cast<CContactItemViewDef&> (*viewDef));

			}

		}

	else if (aContact.Type()==KUidContactCardTemplate)

		{

		aContact.AddLabelFieldL();

		}

	}

/**

CPrivConverter object factory.

@param aImplementationUid UID of the converter plugin.

@return CPrivConverter object.

*/

CPrivConverter* CPrivConverter::NewL(TUid aImplementationUid)

	{

	CPrivConverter* self=new(ELeave) CPrivConverter;

	CleanupStack::PushL(self);

	CVersitTlsData::VersitTlsDataL();

	self->LoadEComPluginL(aImplementationUid);

	CleanupStack::Pop(self); 

	return self;

	}

/**

CPrivConverter object factory.

Loads PBAP contact converter plug-in.

@param aImplementationUid UID of the converter plugin.

@param aContactFieldFilter Specifies contact fields to be exported.

@param aCallback Callback to client for providing intra-contact properties.

@param aVersion Denotes the vCard version for contact export.

@return CPrivConverter object.

*/

CPrivConverter* CPrivConverter::NewL(TUid aUid, TInt64 aContactFieldFilter, MConverterCallBack* aCallback, TVCardVersion aVersion, TBool aExportTel)

	{

	CPrivConverter* self = new(ELeave) CPrivConverter;

	CleanupStack::PushL(self);

	CVersitTlsData::VersitTlsDataL();

	self->LoadEComPluginL(aUid, aContactFieldFilter, aCallback, aVersion, aExportTel);

	CleanupStack::Pop(self); 

	return self;

	}

TInt64 CPrivConverter::GetPBAPFilter() const

	{

	return iPBAPFilter;

	}

TBool CPrivConverter::GetExportTel() const

	{

	return iExportTel;

	}

TVCardVersion CPrivConverter::GetCurrentVersion() const

	{

	return iVersion;

	}

/**

CPrivConverter destructor.

*/

CPrivConverter::~CPrivConverter()

	{

	delete iConverter;

	CVersitTlsData::CloseVersitTlsData();

	}

/**

Load the ECOM plugin with the given UID.

@param aUid UID of the plugin.

@param aContactFieldFilter Specifies contact fields to be exported.

@param aCallback Callback to client for providing intra-contact properties.

@param aVersion Denotes the vCard version for contact export.

*/

void CPrivConverter::LoadEComPluginL(TUid aUid, TInt64 aContactFieldFilter, MConverterCallBack* aCallback, TVCardVersion aVersion, TBool aExportTel)

	{

	if(IsImplementationAvailableL(aUid))

		{

		iVersion = aVersion;

		iPBAPFilter = aContactFieldFilter;

		iExportTel = aExportTel;

		iConverter = CContactEcomConverter::NewL(aUid, aContactFieldFilter, aCallback, aVersion, aExportTel);

		}

	__ASSERT_DEBUG(ETrue, User::Invariant());

	}

/**

Load the ECOM plugin with the given UID.

@param aUid UID of the plugin.

*/

void CPrivConverter::LoadEComPluginL(TUid aUid)

	{

	if(IsImplementationAvailableL(aUid))

		{

		iVersion = EVCard21;

		iConverter = CContactEcomConverter::NewL(aUid);	

		}

	__ASSERT_DEBUG(ETrue, User::Invariant());

	}

/**

Finds out if implementation for a given plug-in uid is present as part of vCard Interface.

@param aUid UID of the plugin.

@return TBool ETrue if implementation exists.

@leave KErrNoMemory 

@leave KErrNotConnected 

@leave KErrArgument 

*/

TBool CPrivConverter::IsImplementationAvailableL(TUid aUid)

	{

	RImplInfoPtrArray	implInfoArray;

	CleanupResetAndDestroyPushL(implInfoArray);

	REComSession::ListImplementationsL(KUidEcomCntVCardConverterInterface, implInfoArray);

	// Check that aImplementationUid is an implementation of

	// KUidEcomCnVCardConverterInterface by checking it is included in

	// implInfoArray.

	const TInt count = implInfoArray.Count();

	__ASSERT_ALWAYS( count > 0, User::Leave(KErrNotFound));

	TBool isAvailable = EFalse;