/*

* Copyright (c) 2010 Sun Microsystems, Inc. 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 Contributor:

* Maximilian Odendahl

*

* Contributors:

* 

* Description: provides a manager to keep track of all available engines

*

*/

#include "caldavenginemgr.h"

#include "caldavengine.h"

#include <calsession.h>

#include <calcalendarinfo.h>

#include "calenglobaldata.h"

/**

 * CCalDavEngineMgr::CCalDavEngineMgr()

 * default constructor

 */

CCalDavEngineMgr::CCalDavEngineMgr()

	{

	}

/**

 * CCalDavEngineMgr::~CCalDavEngineMgr()

 * default destructor

 */

CCalDavEngineMgr::~CCalDavEngineMgr()

	{

	for (TInt i = iEngines.Count() - 1; i >= 0; --i)

		delete iEngines[i];

	iEngines.Close();

	}

/**

 * CCalDavEngineMgr::NewLC()

 * first phase construction

 */

CCalDavEngineMgr* CCalDavEngineMgr::NewLC()

	{

	CCalDavEngineMgr* self = new (ELeave) CCalDavEngineMgr();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**

 * CCalDavEngineMgr::NewL()

 * first phase construction

 */

CCalDavEngineMgr* CCalDavEngineMgr::NewL()

	{

	CCalDavEngineMgr* self = CCalDavEngineMgr::NewLC();

	CleanupStack::Pop(); // self;

	return self;

	}

/**

 * CCalDavEngineMgr::Progress()

 * progress callback

 */

void CCalDavEngineMgr::Progress(TInt /*aPercentageCompleted*/)

	{

	}

/**

 * CCalDavEngineMgr::Completed()

 * completed callback

 */

void CCalDavEngineMgr::Completed(TInt /*aError*/)

	{

	}

/**

 * CCalDavEngineMgr::NotifyProgress()

 * NotifyProgress callback

 */

TBool CCalDavEngineMgr::NotifyProgress()

	{

	return EFalse;

	}

/**

 * CCalDavEngineMgr::ConstructL()

 * second phase construction

 * check all calendar files, for each one which has caldav sync enabled, 

 * create a CCalDavengine and enable sync

 */

void CCalDavEngineMgr::ConstructL()

	{

	RPointerArray<CCalCalendarInfo> calendarInfoList;

	CCalenGlobalData* data = CCalenGlobalData::NewL(*this);

	data->InitializeGlobalDataL();

	CleanupStack::PushL(data);

	data->GetAllCalendarInfoL(calendarInfoList);

	CleanupClosePushL(calendarInfoList);

	for (TInt i = 0; i < calendarInfoList.Count(); i++)

		{

		CDesC8Array* propertyKeys = calendarInfoList[i]->PropertyKeysL();

		CleanupStack::PushL(propertyKeys);

		TInt pos = 0;

		if (propertyKeys->Find(KCaldavEnabled, pos, ECmpNormal) == KErrNone)

			{

			CCalDavEngine* engine = CCalDavEngine::NewL(

					calendarInfoList[i]->FileNameL());

			iEngines.Append(engine);

			if (engine->EnabledSync())

				engine->EnableL();

			}

		CleanupStack::PopAndDestroy(propertyKeys);

		}

	CleanupStack::PopAndDestroy(&calendarInfoList);

	CleanupStack::PopAndDestroy(data);

	}

/**

 * CCalDavEngineMgr::FindEngineL()

 * find engines inside engine array, create if neccessary

 */

TInt CCalDavEngineMgr::FindEngineL(const TDesC &aName, TBool aCreate)

	{

	CCalSession* session = CCalSession::NewL();

	TRAPD(error,session->OpenL(aName));

	delete session;

	if (error != KErrNone)

		return KErrNotFound;

	for (TInt i = 0; i <= iEngines.Count() - 1; i++)

		{

		if (iEngines[i]->CalendarName() == aName)

			return i;

		}

	if (aCreate)

		{

		iEngines.Append(CCalDavEngine::NewL(aName));

		return iEngines.Count() - 1;

		}

	else

		return KErrNotFound;

	}

/**

 * CCalDavEngineMgr::SyncL()

 * sync specific calendar

 */

TInt CCalDavEngineMgr::SyncL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	if (pos != KErrNotFound)

		return iEngines[pos]->SyncL();

	else

		return KErrNotFound;

	}

/**

 * CCalDavEngineMgr::SyncAllL()

 * sync all calendars

 */

TInt CCalDavEngineMgr::SyncAllL()

	{

	// sync all caldav enabled calendars

	for (TInt i = 0; i <= iEngines.Count() - 1; i++)

		iEngines[i]->SyncL();

	return KErrNone;

	}

/**

 * CCalDavEngineMgr::DisableL()

 * 

 */

TInt CCalDavEngineMgr::DisableL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	if (pos != KErrNotFound)

		iEngines[pos]->DisableL();

	return pos == KErrNotFound ? KErrNotFound : KErrNone;

	}

/**

 * CCalDavEngineMgr::EnableL()

 * 

 */

TInt CCalDavEngineMgr::EnableL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	if (pos != KErrNotFound)

		{

		return iEngines[pos]->EnableL();

		}

	return KErrArgument;

	}

/**

 * CCalDavEngineMgr::UrlL()

 * 

 */

TPtrC8 CCalDavEngineMgr::UrlL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	return (pos != KErrNotFound) ? iEngines[pos]->Url() : KNullDesC8();

	}

/**

 * CCalDavEngineMgr::SetUrlL()

 * 

 */

void CCalDavEngineMgr::SetUrlL(const TDesC &aCalendar, const TDesC8 &aUrl)

	{

	TInt pos = FindEngineL(aCalendar, ETrue);

	if (pos != KErrNotFound)

		iEngines[pos]->SetUrlL(aUrl);

	}

/**

 * CCalDavEngineMgr::UsernameL()

 * 

 */

TPtrC8 CCalDavEngineMgr::UsernameL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	return (pos != KErrNotFound) ? iEngines[pos]->User() : KNullDesC8();

	}

/**

 * CCalDavEngineMgr::SetUsernameL()

 * 

 */

void CCalDavEngineMgr::SetUsernameL(const TDesC &aCalendar,

		const TDesC8 &aUsername)

	{

	TInt pos = FindEngineL(aCalendar, ETrue);

	if (pos != KErrNotFound)

		iEngines[pos]->SetUserL(aUsername);

	}

/**

 * CCalDavEngineMgr::PasswordL()

 * 

 */

TPtrC8 CCalDavEngineMgr::PasswordL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	return (pos != KErrNotFound) ? iEngines[pos]->Password() : KNullDesC8();

	}

/**

 * CCalDavEngineMgr::SetPasswordL()

 * 

 */

void CCalDavEngineMgr::SetPasswordL(const TDesC &aCalendar,

		const TDesC8 &aPassword)

	{

	TInt pos = FindEngineL(aCalendar, ETrue);

	if (pos != KErrNotFound)

		iEngines[pos]->SetPasswordL(aPassword);

	}

/**

 * CCalDavEngineMgr::SyncIntervalL()

 * 

 */

TTimeIntervalMinutes CCalDavEngineMgr::SyncIntervalL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	return (pos != KErrNotFound) ? iEngines[pos]->SyncInterval()

			: TTimeIntervalMinutes(DEFAULT_SYNC_MINUTES);

	}

/**

 * CCalDavEngineMgr::SetSyncIntervalL()

 * 

 */

void CCalDavEngineMgr::SetSyncIntervalL(const TDesC &aCalendar,

		TTimeIntervalMinutes aSyncInterval)

	{

	TInt pos = FindEngineL(aCalendar, ETrue);

	if (pos != KErrNotFound)

		iEngines[pos]->SetSyncIntervalL(aSyncInterval);

	}

/**

 * CCalDavEngineMgr::PastDaysL()

 * 

 */

TTimeIntervalDays CCalDavEngineMgr::PastDaysL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	return (pos != KErrNotFound) ? iEngines[pos]->PastDays()

			: TTimeIntervalDays(DEFAULT_PAST_DAYS);

	}

/**

 * CCalDavEngineMgr::SetPastDaysL()

 * 

 */

void CCalDavEngineMgr::SetPastDaysL(const TDesC &aCalendar,

		TTimeIntervalDays aDays)

	{

	TInt pos = FindEngineL(aCalendar, ETrue);

	if (pos != KErrNotFound)

		iEngines[pos]->SetPastDaysL(aDays);

	}

/**

 * CCalDavEngineMgr::ImmediateSyncL()

 * 

 */

TBool CCalDavEngineMgr::ImmediateSyncL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	return pos != KErrNotFound ? iEngines[pos]->ImmediateSync()

			: DEFAULT_IMMEDIATE_SYNC;

	}

/**

 * CCalDavEngineMgr::SetImmediateSyncL()

 * 

 */

void CCalDavEngineMgr::SetImmediateSyncL(const TDesC &aCalendar,

		TBool aImmediateSyc)

	{

	TInt pos = FindEngineL(aCalendar, ETrue);

	if (pos != KErrNotFound)

		iEngines[pos]->SetImmediateSyncL(aImmediateSyc);

	}

/**

 * CCalDavEngineMgr::KeepServerEntryL()

 * 

 */

TBool CCalDavEngineMgr::KeepServerEntryL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	return pos != KErrNotFound ? iEngines[pos]->KeepServerEntry()

			: DEFAULT_KEEP_SERVER_ENTRY;

	}

/**

 * CCalDavEngineMgr::SetKeepServerEntryL()

 * 

 */

void CCalDavEngineMgr::SetKeepServerEntryL(const TDesC &aCalendar,

		TBool aKeepServerEntry)

	{

	TInt pos = FindEngineL(aCalendar, ETrue);

	if (pos != KErrNotFound)

		iEngines[pos]->SetKeepServerEntryL(aKeepServerEntry);

	}

/**

 * CCalDavEngineMgr::EnabledSyncL()

 * 

 */

TBool CCalDavEngineMgr::EnabledSyncL(const TDesC &aCalendar)

	{

	TInt pos = FindEngineL(aCalendar);

	return (pos != KErrNotFound) ? iEngines[pos]->EnabledSync() : EFalse;

	}