/*

* 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 client API for Caldav server

*

*/

#include "caldavclient.h"

#include "caldavserver.h"

#include "caldavutils.h"

const TUint KDefaultMessageSlots = 4;

// testing ************

#include <e32base.h>

#include <e32cons.h>

#include <e32cmn.h>

/**

 * RCalDavServer::RCalDavServer

 * default constructor

 */

EXPORT_C RCalDavServer::RCalDavServer()

	{

	}

/**

 * RCalDavServer::Connect

 * connect to server

 */

EXPORT_C TInt RCalDavServer::Connect()

	{

	TInt retry = 2;

	for (;;)

		{

		TInt r = CreateSession(KCalDavServerName, Version(),

				KDefaultMessageSlots);

		if ((KErrNotFound != r) && (KErrServerTerminated != r))

			return (r);

		if (--retry == 0)

			return (r);

		r = StartServer();

		if ((KErrNone != r) && (KErrAlreadyExists != r))

			return (r);

		}

	}

/**

 * RCalDavServer::Enable

 * enable Caldav sync

 */

EXPORT_C TInt RCalDavServer::Enable(const TDesC &aCalendar)

	{

	TIpcArgs args(&aCalendar);

	return SendReceive(ECalDavEnable, args);

	}

/**

 * RCalDavServer::Disable

 * disable Caldav sync

 */

EXPORT_C TInt RCalDavServer::Disable(const TDesC &aCalendar)

	{

	TIpcArgs args(&aCalendar);

	return SendReceive(ECalDavDisable, args);

	}

/**

 * RCalDavServer::EnabledSync

 * check for enabled sync

 */

EXPORT_C TInt RCalDavServer::EnabledSync(const TDesC &aCalendar,

		TBool &aEnabled)

	{

	TPckg<TBool> enabled(aEnabled);

	TIpcArgs args(&aCalendar, &enabled);

	return (SendReceive(ECalDavEnabled, args));

	}

/**

 * RCalDavServer::Sync

 * sync now a specific calendar

 */

EXPORT_C TInt RCalDavServer::Sync(const TDesC &aCalendar)

	{

	TIpcArgs args(&aCalendar);

	return SendReceive(ECalDavSync, args);

	}

/**

 * RCalDavServer::SyncAll

 * sync now all calendars

 */

EXPORT_C TInt RCalDavServer::SyncAll()

	{

	return SendReceive(ECalDavSyncAll);

	}

/**

 * RCalDavServer::Url

 * get caldav sync url

 */

EXPORT_C TInt RCalDavServer::Url(const TDesC &aCalendar, TDes8 &aUrl)

	{

	TIpcArgs args(&aCalendar, &aUrl);

	return SendReceive(ECalDavUrl, args);

	}

/**

 * RCalDavServer::SetUrl

 * set url

 */

EXPORT_C TInt RCalDavServer::SetUrl(const TDesC &aCalendar, const TDesC8 &aUrl)

	{

	TIpcArgs args(&aCalendar, &aUrl);

	return SendReceive(ECalDavSetUrl, args);

	}

/**

 * RCalDavServer::Username

 * get username

 */

EXPORT_C TInt RCalDavServer::Username(const TDesC &aCalendar, TDes8 &aUsername)

	{

	TIpcArgs args(&aCalendar, &aUsername);

	return SendReceive(ECalDavUsername, args);

	}

/**

 * RCalDavServer::SetUsername

 * set username

 */

EXPORT_C TInt RCalDavServer::SetUsername(const TDesC &aCalendar,

		const TDesC8 &aUsername)

	{

	TIpcArgs args(&aCalendar, &aUsername);

	return SendReceive(ECalDavSetUsername, args);

	}

/**

 * RCalDavServer::Password

 * get password

 */

EXPORT_C TInt RCalDavServer::Password(const TDesC &aCalendar, TDes8 &aPassword)

	{

	TIpcArgs args(&aCalendar, &aPassword);

	return SendReceive(ECalDavPassword, args);

	}

/**

 * RCalDavServer::SetPassword

 * set password

 */

EXPORT_C TInt RCalDavServer::SetPassword(const TDesC &aCalendar,

		const TDesC8 &aPassword)

	{

	TIpcArgs args(&aCalendar, &aPassword);

	return SendReceive(ECalDavSetPassword, args);

	}

/**

 * RCalDavServer::SyncInterval

 * get SyncInterval

 */

EXPORT_C TInt RCalDavServer::SyncInterval(const TDesC &aCalendar,

		TTimeIntervalMinutes& aSyncInterval)

	{

	TPckg<TTimeIntervalMinutes> syncinterval(aSyncInterval);

	TIpcArgs args(&aCalendar, &syncinterval);

	return (SendReceive(ECalDavSyncInterval, args));

	}

/**

 * RCalDavServer::SetSyncInterval

 * set SyncInterval

 */

EXPORT_C TInt RCalDavServer::SetSyncInterval(const TDesC &aCalendar,

		TTimeIntervalMinutes aSyncInterval)

	{

	TPckg<TTimeIntervalMinutes> syncinterval(aSyncInterval);

	TIpcArgs args(&aCalendar, &syncinterval);

	return (SendReceive(ECalDavSetSyncInterval, args));

	}

/**

 * RCalDavServer::PastDays

 * get past days

 */

EXPORT_C TInt RCalDavServer::PastDays(const TDesC &aCalendar,

		TTimeIntervalDays &aDays)

	{

	TPckg<TTimeIntervalDays> pastdays(aDays);

	TIpcArgs args(&aCalendar, &pastdays);

	return (SendReceive(ECalDavPastDays, args));

	}

/**

 * RCalDavServer::SetPastDays

 * set past days

 */

EXPORT_C TInt RCalDavServer::SetPastDays(const TDesC &aCalendar,

		TTimeIntervalDays aDays)

	{

	TPckg<TTimeIntervalDays> pastdays(aDays);

	TIpcArgs args(&aCalendar, &pastdays);

	return (SendReceive(ECalDavSetPastDays, args));

	}

/**

 * RCalDavServer::ImmediateSync

 * get Immediate Sync

 */

EXPORT_C TInt RCalDavServer::ImmediateSync(const TDesC &aCalendar,

		TBool &aImmediateSyc)

	{

	TPckg<TBool> syncimmediate(aImmediateSyc);

	TIpcArgs args(&aCalendar, &syncimmediate);

	return (SendReceive(ECalDavImmediateSync, args));

	}

/**

 * RCalDavServer::SetImmediateSync

 * set immediate Sync

 */

EXPORT_C TInt RCalDavServer::SetImmediateSync(const TDesC &aCalendar,

		TBool aImmediateSyc)

	{

	TPckg<TBool> syncimmediate(aImmediateSyc);

	TIpcArgs args(&aCalendar, &syncimmediate);

	return SendReceive(ECalDavSetImmediateSync, args);

	}

/**

 * RCalDavServer::KeepServerEntry

 * get KeepServerEntry

 */

EXPORT_C TInt RCalDavServer::KeepServerEntry(const TDesC &aCalendar,

		TBool &aKeepServerEntry)

	{

	TPckg<TBool> keepserverentry(aKeepServerEntry);

	TIpcArgs args(&aCalendar, &keepserverentry);

	return SendReceive(ECalDavKeepServer, args);

	}

/**

 * RCalDavServer::SetKeepServerEntry

 * set KeepServerEntry

 */

EXPORT_C TInt RCalDavServer::SetKeepServerEntry(const TDesC &aCalendar,

		TBool aKeepServerEntry)

	{

	TPckg<TBool> keepserverentry(aKeepServerEntry);

	TIpcArgs args(&aCalendar, &keepserverentry);

	return SendReceive(ECalDavSetKeepServer, args);

	}

/**

 * RCalDavServer::Version

 * get version

 */

TVersion RCalDavServer::Version(void) const

	{

	return (TVersion(KCalDavServerMajorVersionNumber,

			KCalDavServerMinorVersionNumber, KCalDavServerBuildVersionNumber));

	}

/**

 * RCalDavServer::UnsupportedRequest()

 *  A server request to stop the server.

 *  This is a request that is NOT implemented by the server; it is here to show

 *  the handling of non-implemented requests.

 */

TInt RCalDavServer::UnsupportedRequest()

	{

	return SendReceive(ECalDavUnsupportedRequest);

	}

/**

 * RCalDavServer::BadRequest()

 * A request that the server knows nothing about.

 */

void RCalDavServer::BadRequest()

	{

	SendReceive(9999);

	}

static TInt StartServer()

	{

	RProcess server;

	TInt r = server.Create(KCalDavServerFilename, KNullDesC);

	if (r != KErrNone)

		return r;

	TRequestStatus stat;

	server.Rendezvous(stat);

	if (stat != KRequestPending)

		server.Kill(0); // abort startup

	else

		server.Resume(); // logon OK - start the server

	User::WaitForRequest(stat); // wait for start or death

	// Check the exit type.

	// We can't use the 'exit reason' because if the server panicked this

	// is set to the panic 'reason' (which may be '0' and cannot thus be distinguished

	// from KErrNone)

	r = server.ExitType();

	if (EExitPanic == r)

		r = KErrGeneral;

	else

		r = stat.Int();

	server.Close(); // This is no longer needed

	return r;

	}