/*

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

*

*/

// INCLUDES

#include <SyncMLTransportProperties.h>

#include <featmgr.h>   // FeatureManager

#include "AspProfile.h"

#include "AspResHandler.h"

#include "AspDialogUtil.h"

#include "AspDebug.h"

#include "AspSchedule.h"

#include <centralrepository.h> //CRepository

/*******************************************************************************

 * class TAspProviderItem

 *******************************************************************************/

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

// TAspProviderItem::CompareItems

//

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

//

TInt TAspProviderItem::CompareItems(const TAspProviderItem& aFirst, const TAspProviderItem& aSecond)

	{

	const TInt KNegative = -1;

	const TInt KPositive = 1;

	TInt firstOrder = SortOrder(aFirst.iDataProviderId);

	TInt secondOrder = SortOrder(aSecond.iDataProviderId);

	if (firstOrder > secondOrder)

		{

		return KNegative;

		}

	else if (secondOrder > firstOrder)

		{

		return KPositive;

		}

	else

		{

		return 0;

		}

	}

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

// TAspProviderItem::CompareItems

//

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

//

TInt TAspProviderItem::SortOrder(TInt aDataProviderId)

	{

	TInt ret = EOrderOther;

	if (aDataProviderId == KUidNSmlAdapterContact.iUid)

		{

		ret = EOrderContact;

		}

	else if (aDataProviderId == KUidNSmlAdapterCalendar.iUid)

		{

		ret = EOrderCalendar;

		}

	else if (aDataProviderId == KUidNSmlAdapterNote.iUid)

		{

		ret = EOrderNotes;

		}

	else if (aDataProviderId == KUidNSmlAdapterEMail.iUid)

		{

		ret = EOrderEmail;

		}

	return ret;

	}

/*******************************************************************************

 * class CAspContentList

 *******************************************************************************/

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

// CAspContentList::NewLC

//

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

//

CAspContentList* CAspContentList::NewLC(const TAspParam& aParam)

    {

   	FLOG( _L("CAspContentList::NewLC START") );

    CAspContentList* self = new (ELeave) CAspContentList(aParam);

	CleanupStack::PushL(self);

	self->ConstructL();

    FLOG( _L("CAspContentList::NewLC END") );

	return self;

    }

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

// CAspContentList::NewL

//

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

//

CAspContentList* CAspContentList::NewL(const TAspParam& aParam)

    {

   	FLOG( _L("CAspContentList::NewL START") );

    CAspContentList* self = new (ELeave) CAspContentList(aParam);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

    FLOG( _L("CAspContentList::NewL END") );

	return self;

    }

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

// Destructor

//

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

//

CAspContentList::~CAspContentList()

    {

	iProviderList.Close();

	iTaskList.Close();

    }

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

// CAspContentList::ConstructL

//

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

//

void CAspContentList::ConstructL(void)

    {

	if (iListMode == EInitDataProviders)

		{

        InitDataProvidersL();

		}

	else if (iListMode == EInitTasks)

		{

		__ASSERT_ALWAYS(iProfile, TUtil::Panic(KErrGeneral));

        InitAllTasksL();

		}

	else 

		{

		__ASSERT_ALWAYS(iProfile, TUtil::Panic(KErrGeneral));

		InitDataProvidersL();

		InitAllTasksL();

		}

    }

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

// CAspContentList::CAspContentList

//

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

//

CAspContentList::CAspContentList(const TAspParam& aParam)

	{

	iSyncSession = aParam.iSyncSession;

	iProfile = aParam.iProfile;

	iListMode = aParam.iMode;

	iApplicationId = aParam.iApplicationId;

	__ASSERT_ALWAYS(iSyncSession, TUtil::Panic(KErrGeneral));

	}

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

// CAspContentList::SetProfile

//

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

//

void CAspContentList::SetProfile(CAspProfile* aProfile)

	{

	if (aProfile)

		{

	    __ASSERT_ALWAYS(iProfile == NULL, TUtil::Panic(KErrGeneral));

		}

	iProfile = aProfile;

	}

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

// CAspContentList::IsLocked

//

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

//

TBool CAspContentList::IsLocked()

	{

	if (iProfile)

		{

		return ETrue;

		}

	return EFalse;

	}

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

// CAspContentList::ProviderCount

//

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

//

TInt CAspContentList::ProviderCount()

	{

	return iProviderList.Count();

	}

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

// CAspContentList::ProviderItem

// 

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

//

TAspProviderItem& CAspContentList::ProviderItem(TInt aIndex)

	{

	if (aIndex < 0 || aIndex >= ProviderCount())

	    {

		TUtil::Panic(KErrArgument);

	    }

	return iProviderList[aIndex];

	}

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

// CAspContentList::FindProviderIndex

//

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

//

TInt CAspContentList::FindProviderIndex(TInt aId)

	{

	TInt count = iProviderList.Count();

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

		{

		TAspProviderItem& item = iProviderList[i];

		if (item.iDataProviderId == aId)

			{

			return i;

			}

		}

	return KErrNotFound;

	}

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

// CAspContentList::FindProviderIndexForTask

//

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

//

TInt CAspContentList::FindProviderIndexForTask(TInt aId)

	{

	TInt index = FindTaskIndex(aId);

	if (index == KErrNotFound)

		{

		return KErrNotFound;

		}

	TAspTaskItem& item = TaskItem(index);

	return FindProviderIndex(item.iDataProviderId);

	}

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

// CAspContentList::TaskCount

//

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

//

TInt CAspContentList::TaskCount()

	{

	return iTaskList.Count();

	}

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

// CAspContentList::TaskItem

// 

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

//

TAspTaskItem& CAspContentList::TaskItem(TInt aIndex)

	{

	if ((aIndex < 0) || (aIndex >= TaskCount()))

	    {

		TUtil::Panic(KErrArgument);

	    }

	return iTaskList[aIndex];

	}

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

// CAspContentList::FindTaskIndex

//

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

//

TInt CAspContentList::FindTaskIndex(TInt aId)

	{

	TInt count = iTaskList.Count();

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

		{

		TAspTaskItem& task = iTaskList[i];

		if (task.iTaskId == aId)

			{

			return i;

			}

		}

	return KErrNotFound;

	}

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

// CAspContentList::FindTaskIndexForProvider

//

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

//

TInt CAspContentList::FindTaskIndexForProvider(TInt aId)

	{

	TInt count = iTaskList.Count();

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

		{

		TAspTaskItem& item = iTaskList[i];

		if (item.iDataProviderId == aId)

			{

			return i;

			}

		}

	return KErrNotFound;

	}

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

// CAspContentList::FindTaskIdForProvider

//

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

//

TInt CAspContentList::FindTaskIdForProvider(TInt aId)

	{

	TInt index = FindTaskIndexForProvider(aId);

	if (index == KErrNotFound)

		{

		return KErrNotFound;

		}

	TAspTaskItem& item = iTaskList[index];

	return item.iTaskId;

	}

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

// CAspContentList::DoInitDataProvidersL

// 

// Initialize data provider list.

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

//

void CAspContentList::DoInitDataProvidersL()

	{

	FLOG( _L("CAspContentList::DoInitDataProvidersL START") );

	iProviderList.Reset();

	RArray<TSmlDataProviderId> arr;

	Session().ListDataProvidersL(arr);

	CleanupClosePushL(arr);

	TInt count = arr.Count();

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

		{

		RSyncMLDataProvider provider;

		TInt id = arr[i];

		TRAPD(err, provider.OpenL(Session(), id));

		if (err == KErrNone)

			{

    		CleanupClosePushL(provider);

	    	TAspProviderItem item;

		    ReadDataProviderItemL(provider, item);

            item.iIsIncludedInSync = EFalse;

		    if (TUtil::IsEmpty(item.iDisplayName))

		    	{

		    	// providers must have display name

		    	CleanupStack::PopAndDestroy(&provider);

		    	FTRACE( RDebug::Print(_L("### provider has no display name (id=%x) ###"), item.iDataProviderId) );

		    	continue;

		    	}

		    User::LeaveIfError(iProviderList.Append(item));

	        CleanupStack::PopAndDestroy(&provider);

		    }

		if (err != KErrNone)

			{

			FTRACE( RDebug::Print(_L("### RSyncMLDataProvider::Open failed (id=%x, err=%d) ###"), id, err) );

			}

		}

	CleanupStack::PopAndDestroy(&arr);

	FLOG( _L("CAspContentList::DoInitDataProvidersL END") );

	}

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

// CAspContentList::UpdateDataProviderL

// 

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

//

void CAspContentList::UpdateDataProviderL(TInt aDataProviderId)

	{

	TInt index = FindProviderIndex(aDataProviderId);

	if (index == KErrNotFound)

		{

		return;  // unknown provider

		}

	TAspProviderItem& providerItem = ProviderItem(index);

	RArray<TSmlDataProviderId> arr;

	Session().ListDataProvidersL(arr);

	CleanupClosePushL(arr);

	TInt count = arr.Count();

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

		{

		RSyncMLDataProvider provider;

		TInt id = arr[i];

		TRAPD(err, provider.OpenL(Session(), id));

		if (err == KErrNone)

			{

    		CleanupClosePushL(provider);

		    TInt id = provider.Identifier();

		    if (id == aDataProviderId)

		    	{

       		    ReadDataProviderItemL(provider, providerItem);

       		    CleanupStack::PopAndDestroy(&provider);

       		    break;

		    	}

	        CleanupStack::PopAndDestroy(&provider);

		    }

		}

	CleanupStack::PopAndDestroy(&arr);

	}

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

// CAspContentList::ReadDataProviderItemL

// 

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

//

void CAspContentList::ReadDataProviderItemL(RSyncMLDataProvider& aProvider, 

                                            TAspProviderItem& aItem)

	{

    aItem.iTaskId=KErrNotFound;

	aItem.iDataProviderId = aProvider.Identifier();

    aItem.iSyncProtocol = ESmlVersion1_2;

    //item.iSyncProtocol = provider.RequiredProtocolVersionL();

    aItem.iAllowMultipleDataStores = aProvider.AllowsMultipleDataStores();

    TUtil::StrCopy(aItem.iDisplayName, aProvider.DisplayName());

    TPtrC ptr = aProvider.DefaultDataStoreName();

    if (TUtil::IsEmpty(ptr))

    	{

    	aItem.iHasDefaultDataStore = EFalse;

    	aItem.iDefaultDataStore = KNullDesC;

    	}

    else

    	{

    	aItem.iHasDefaultDataStore = ETrue;

    	TUtil::StrCopy(aItem.iDefaultDataStore, ptr);

    	}

	}

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

// CAspContentList::InitDataProvidersL

// 

// Initialize data provider list.

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

//

void CAspContentList::InitDataProvidersL()