1 /*

     2  * Copyright (c) 2010 Sun Microsystems, Inc. and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributor:

    10  * Maximilian Odendahl

    11  *

    12  * Contributors:

    13  * 

    14  * Description:  main Caldav class, all magic happens here 

    15  *				one engine for each configured Caldav calendar

    16  */

    17 #include "caldavengine.h"

    18 #include <f32file.h> 

    19 #include <S32FILE.H>

    20 #include <S32MEM.H> 

    21 #include <avkon.rsg>

    22 #include <UTF.H>

    23 #include <agnexportobserver.h>

    24 #include <calsession.h>

    25 #include <caliterator.h>

    26 #include <calentry.h>

    27 #include <calentryview.h>

    28 #include <caltime.h>

    29 #include <calalarm.h>

    30 #include <calcategory.h>

    31 #include <caluser.h>

    32 #include <calrrule.h>

    33 #include <calinstance.h>

    34 #include <calinstanceview.h>

    35 #include <caleninterimutils2.h> 

    36 #include <calenexporter.h>

    37 #include <calenimporter.h>

    38 #include <calcalendarinfo.h>

    39 #include "calenglobaldata.h"

    40 #include <xmlengdocument.h>

    41 #include <xmlengnode.h>

    42 #include <xmlengelement.h>

    43 #include <xmlengnodelist.h>

    44 #include <xmlengtext.h>

    45 #include "httpclient.h"

    46 #include <e32math.h>	// divmod

    47 #define MULTIGETSPLIT 			100

    48 #define ARRAYEXPAND				4

    49 #define	URLMAX					500

    50 #define EXPANDSIZE_SMALL		512

    51 #define EXPANDSIZE_BIG			1024

    52 _LIT(KFormatString,"\"%F%Y%M%DT000000Z\"");

    53 

    54 /**

    55  * SyncTickL

    56  * timer for basic sync interval

    57  */

    58 TInt SyncTickL(TAny *aObject)

    59 	{

    60 	CCalDavEngine* engine = ((CCalDavEngine*) aObject);

    61 	CPeriodic* timer = engine->Timer();

    62 	if (engine && timer)

    63 		{

    64 		timer->Cancel();

    65 		TRAP_IGNORE(engine->SyncL());

    66 		TInt ticktime = engine->SyncInterval().Int() == 0 ? 1

    67 				: engine->SyncInterval().Int();

    68 		const TUint64 tickInterval = 1000000 * 60 * ticktime;

    69 		timer->Start(tickInterval, tickInterval, TCallBack(SyncTickL, engine));

    70 		}

    71 	return 0;

    72 	}

    73 

    74 #ifdef _DEBUG

    75 void ExportToFileNameL(const TDesC8& aDes, const TDesC &aFilename)

    76 	{

    77 	RFs fsSession;

    78 	User::LeaveIfError(fsSession.Connect());

    79 	CleanupClosePushL(fsSession);

    80 

    81 	TInt err = fsSession.MkDirAll(aFilename);

    82 

    83 	RFile file;

    84 	User::LeaveIfError(file.Replace(fsSession, aFilename, EFileWrite));

    85 	CleanupClosePushL(file);

    86 

    87 	RFileWriteStream writeStream2;

    88 	writeStream2.Attach(file);

    89 	CleanupClosePushL(writeStream2);

    90 

    91 	writeStream2 << aDes;

    92 	writeStream2.CommitL();

    93 	CleanupStack::PopAndDestroy(&writeStream2);

    94 	CleanupStack::PopAndDestroy(&file);

    95 	CleanupStack::PopAndDestroy(&fsSession);

    96 	}

    97 

    98 void ExportToFileL(CCalEntry* aEntry, CCalenExporter *iCalExporter)

    99 	{

   100 	if (aEntry)

   101 		{

   102 		_LIT(KFileName, "C:\\logs\\caldav\\testing_export.txt");

   103 

   104 		RFs fsSession;

   105 		User::LeaveIfError(fsSession.Connect());

   106 		CleanupClosePushL(fsSession);

   107 

   108 		TInt err = fsSession.MkDirAll(KFileName);

   109 

   110 		RFile file;

   111 		User::LeaveIfError(file.Replace(fsSession, KFileName, EFileWrite));

   112 		CleanupClosePushL(file);

   113 

   114 		RFileWriteStream writeStream2;

   115 		writeStream2.Attach(file);

   116 		CleanupClosePushL(writeStream2);

   117 

   118 		iCalExporter->ExportICalL(*aEntry, writeStream2);

   119 		writeStream2.CommitL();

   120 		CleanupStack::PopAndDestroy(&writeStream2);

   121 		CleanupStack::PopAndDestroy(&file);

   122 		CleanupStack::PopAndDestroy(&fsSession);

   123 		}

   124 	}

   125 #endif

   126 

   127 /**

   128  * SearchL

   129  * search inside xml tree for a specific node

   130  */

   131 void SearchL(TXmlEngNode &aTopNode, const TDesC8 &aName,

   132 		const TDesC8 &aNamespace, TXmlEngNode & aReturnNode)

   133 	{

   134 	RXmlEngNodeList<TXmlEngNode> List;

   135 	aTopNode.GetChildNodes(List);

   136 	while (List.HasNext() && aReturnNode.IsNull())

   137 		{

   138 		TXmlEngNode Node = List.Next();

   139 		TXmlEngNode::TXmlEngDOMNodeType Type = Node.NodeType();

   140 		if (Type == TXmlEngNode::EElement)

   141 			{

   142 			//todo: compare namespace ?

   143 			if (Node.Name() == aName)

   144 				{

   145 				aReturnNode = Node.CopyL();

   146 				return;

   147 				}

   148 			else

   149 				{

   150 				SearchL(Node, aName, aNamespace, aReturnNode);

   151 				if (!aReturnNode.IsNull())

   152 					return;

   153 				}

   154 			}

   155 		}

   156 	}

   157 

   158 /**

   159  * SearchL

   160  * search inside xml tree for a specific node

   161  */

   162 void SearchL(TXmlEngNode &aTopNode, const TDesC8 &aName,

   163 		const TDesC8 &aNamespace, RBuf8 &aBuf)

   164 	{

   165 	RXmlEngNodeList<TXmlEngNode> List;

   166 	aTopNode.GetChildNodes(List);

   167 	while (List.HasNext())

   168 		{

   169 		TXmlEngNode Node = List.Next();

   170 		TXmlEngNode::TXmlEngDOMNodeType Type = Node.NodeType();

   171 		if (Type == TXmlEngNode::EElement)

   172 			{

   173 			//todo: compare namespace ?

   174 			if (Node.Name() == aName)

   175 				{

   176 				if (Node.IsSimpleTextContents())

   177 					aBuf.Create(Node.Value());

   178 				else

   179 					Node.WholeTextContentsCopyL(aBuf);

   180 				return;

   181 				}

   182 			else

   183 				{

   184 				SearchL(Node, aName, aNamespace, aBuf);

   185 				if (aBuf.Length())

   186 					return;

   187 				}

   188 			}

   189 		}

   190 	}

   191 

   192 /**

   193  * SearchL

   194  * search inside xml tree for a specific node

   195  */

   196 TPtrC8 SearchL(TXmlEngNode &aTopNode, const TDesC8 &aName,

   197 		const TDesC8 &aNamespace)

   198 	{

   199 	RXmlEngNodeList<TXmlEngNode> List;

   200 	aTopNode.GetChildNodes(List);

   201 	while (List.HasNext())

   202 		{

   203 		TXmlEngNode Node = List.Next();

   204 		TXmlEngNode::TXmlEngDOMNodeType Type = Node.NodeType();

   205 		if (Type == TXmlEngNode::EElement)

   206 			{

   207 			//todo: compare namespace ?

   208 			if (Node.Name() == aName)

   209 				return Node.Value();

   210 			else

   211 				{

   212 				TPtrC8 Return = SearchL(Node, aName, aNamespace);

   213 				if (Return != KNullDesC8)

   214 					return Return;

   215 				}

   216 			}

   217 		}

   218 	return KNullDesC8();

   219 	}

   220 

   221 /**

   222  * GetBoolFromPropertiesL

   223  * get a boolean value from CCalCalendarInfo

   224  */

   225 TBool GetBoolFromPropertiesL(CCalCalendarInfo* info, const TDesC8 &aKey)

   226 	{

   227 	TBool boolean;

   228 	TPckgC<TBool> pckgboolean(boolean);

   229 	pckgboolean.Set(info->PropertyValueL(aKey));

   230 	return pckgboolean();

   231 	}

   232 

   233 /**

   234  * GetTimeFromPropertiesL

   235  * get a time value from CCalCalendarInfo

   236  */

   237 TCalTime GetTimeFromPropertiesL(CCalCalendarInfo* info, const TDesC8 &aKey)

   238 	{

   239 	TCalTime time;

   240 	TPckgC<TCalTime> pckgtime(time);

   241 	pckgtime.Set(info->PropertyValueL(aKey));

   242 	return pckgtime();

   243 	}

   244 

   245 /**

   246  * PropertyExists

   247  * finds a property from an array

   248  */

   249 TBool PropertyExists(CDesC8Array* aArray, const TDesC8 &aKey)

   250 	{

   251 	TInt pos = 0;

   252 	return aArray->Find(aKey, pos, ECmpNormal) == KErrNone;

   253 	}

   254 

   255 /**

   256  * CCalDavEngine::SetCalendarInfoL

   257  * set key and value pair at calendar session info

   258  */

   259 void CCalDavEngine::SetCalendarInfoL(const TDesC8 &aKey, const TDesC8 &aValue)

   260 	{

   261 	TBool createdelete = !iCalSession;

   262 	if (createdelete)

   263 		{

   264 		iCalSession = CCalSession::NewL();

   265 		TRAP_IGNORE(iCalSession->OpenL(*iCalendar));

   266 		}

   267 	CCalCalendarInfo* calendarInfo = iCalSession->CalendarInfoL();

   268 	CleanupStack::PushL(calendarInfo);

   269 	TPckgC<TBool> enabled(iEnabled);

   270 	calendarInfo->SetPropertyL(KCaldavEnabled, enabled);

   271 	if (aValue != KNullDesC8)

   272 		calendarInfo->SetPropertyL(aKey, aValue);

   273 	iCalSession->SetCalendarInfoL(*calendarInfo);

   274 	CleanupStack::PopAndDestroy(calendarInfo);

   275 

   276 	if (createdelete)

   277 		{

   278 		delete iCalSession;

   279 		iCalSession = NULL;

   280 		}

   281 	}

   282 

   283 /**

   284  * CCalDavEngine::CCalDavEngine

   285  * default constructor

   286  */

   287 CCalDavEngine::CCalDavEngine() :

   288 	iCalSession(0), iCalIter(0), iCalEntryView(0), iCalExporter(0),

   289 			iCalImporter(0), iCalIntermimUtils2(0), iCalendar(0), iUrl(0),

   290 			iBaseUrl(0), iHome(0), iHttp(0), iSynctoken(0), iCTag(0),

   291 			iSyncInterval(DEFAULT_SYNC_MINUTES), iPastDays(DEFAULT_PAST_DAYS),

   292 			iImmediateSync(DEFAULT_IMMEDIATE_SYNC), iKeepServerEntry(

   293 					DEFAULT_KEEP_SERVER_ENTRY), iEnabled(EFalse), iTimer(0)

   294 	{

   295 	}

   296 

   297 /**

   298  * CCalDavEngine::~CCalDavEngine

   299  * default destructor

   300  */

   301 CCalDavEngine::~CCalDavEngine()

   302 	{

   303 	iLocalUidArray.Close();

   304 	iGlobalUidArray.Close();

   305 	iDeletedEntries.Close();

   306 

   307 	iDomParser.Close();

   308 	iDomImpl.Close();

   309 

   310 	if (iCalendar)

   311 		delete iCalendar;

   312 

   313 	if (iUrl)

   314 		delete iUrl;

   315 

   316 	if (iBaseUrl)

   317 		delete iBaseUrl;

   318 

   319 	if (iHttp)

   320 		delete iHttp;

   321 

   322 	DeleteCalObjects();

   323 

   324 	if (iCalIntermimUtils2)

   325 		delete iCalIntermimUtils2;

   326 

   327 	if (iSynctoken)

   328 		delete iSynctoken;

   329 

   330 	if (iCTag)

   331 		delete iCTag;

   332 

   333 	if (iHome)

   334 		delete iHome;

   335 

   336 	if (iTimer)

   337 		delete iTimer;

   338 	}

   339 

   340 /**

   341  * CCalDavEngine::NewLC

   342  * first phase construction

   343  */

   344 CCalDavEngine* CCalDavEngine::NewLC(const TDesC& aCalendar)

   345 	{

   346 	CCalDavEngine* self = new (ELeave) CCalDavEngine();

   347 	CleanupStack::PushL(self);

   348 	self->ConstructL(aCalendar);

   349 	return self;

   350 	}

   351 

   352 /**

   353  * CCalDavEngine::NewL

   354  * first phase construction

   355  */

   356 CCalDavEngine* CCalDavEngine::NewL(const TDesC& aCalendar)

   357 	{

   358 	CCalDavEngine* self = CCalDavEngine::NewLC(aCalendar);

   359 	CleanupStack::Pop(self); // self;

   360 	return self;

   361 	}

   362 

   363 /**

   364  * CCalDavEngine::

   365  * second phase construction

   366  */

   367 void CCalDavEngine::ConstructL(const TDesC& aCalendar)

   368 	{

   369 	iManualSync = EFalse;

   370 	iFirstInit = ETrue;

   371 	iCalendar = aCalendar.AllocL();

   372 

   373 	iHttp = CHttpClient::NewL();

   374 

   375 	iDomImpl.OpenL();

   376 	TInt err = iDomParser.Open(iDomImpl);

   377 	if (KErrNone != err)

   378 		User::Leave(err);

   379 

   380 	iTimer = CPeriodic::NewL(EPriorityNormal);

   381 	iCalIntermimUtils2 = CCalenInterimUtils2::NewL();

   382 	iCalSession = CCalSession::NewL();

   383 	TRAP_IGNORE(iCalSession->OpenL(aCalendar));

   384 	CalendarInfoL();

   385 	// we can't close the file, so delete it completly

   386 	delete iCalSession;

   387 	iCalSession = NULL;

   388 	}

   389 

   390 /**

   391  * CCalDavEngine::Progress

   392  * Progress callback

   393  */

   394 void CCalDavEngine::Progress(TInt /*aPercentageCompleted*/)

   395 	{

   396 	}

   397 

   398 /**

   399  * CCalDavEngine::RegisterL

   400  * register all neccessary notification callback

   401  */

   402 void CCalDavEngine::RegisterL()

   403 	{

   404 	TDateTime Start;

   405 	TDateTime End;

   406 	End.SetYear(2200);

   407 

   408 	TCalTime StartCal;

   409 	TCalTime EndCal;

   410 	StartCal.SetTimeLocalL(Start);

   411 	EndCal.SetTimeLocalL(End);

   412 	CalCommon::TCalTimeRange Range(StartCal, EndCal);

   413 	CCalChangeNotificationFilter *Filter = CCalChangeNotificationFilter::NewL(

   414 			MCalChangeCallBack2::EChangeEntryAll, true, Range);

   415 	iCalSession->StartChangeNotification(*this, *Filter);

   416 	iCalSession->StartFileChangeNotificationL(*this);

   417 	delete Filter;

   418 	}

   419 

   420 /**

   421  * CCalDavEngine::CalendarInfoL

   422  * load all properties from CalendarInfo

   423  */

   424 void CCalDavEngine::CalendarInfoL()

   425 	{

   426 	CCalCalendarInfo* calendarInfo = iCalSession->CalendarInfoL();

   427 	if (calendarInfo->IsValid())

   428 		{

   429 		CleanupStack::PushL(calendarInfo);

   430 		CDesC8Array* propertyKeys = calendarInfo->PropertyKeysL();

   431 		CleanupStack::PushL(propertyKeys);

   432 		TInt pos = 0;

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

   434 			{

   435 			iEnabled = GetBoolFromPropertiesL(calendarInfo, KCaldavEnabled);

   436 			if (PropertyExists(propertyKeys, KCaldavFirstInit))

   437 				iFirstInit = GetBoolFromPropertiesL(calendarInfo,

   438 						KCaldavFirstInit);

   439 			if (PropertyExists(propertyKeys, KCaldavSynctoken))

   440 				iSynctoken

   441 						= calendarInfo->PropertyValueL(KCaldavSynctoken).AllocL();

   442 			if (PropertyExists(propertyKeys, KCaldavCtag))

   443 				iCTag = calendarInfo->PropertyValueL(KCaldavCtag).AllocL();

   444 			if (PropertyExists(propertyKeys, KCaldavManualSync))

   445 				iManualSync = GetBoolFromPropertiesL(calendarInfo,

   446 						KCaldavManualSync);

   447 			if (PropertyExists(propertyKeys, KCaldavTime))

   448 				iLastSyncTime = GetTimeFromPropertiesL(calendarInfo,

   449 						KCaldavTime);

   450 			if (PropertyExists(propertyKeys, KCaldavUrl))

   451 				iUrl = calendarInfo->PropertyValueL(KCaldavUrl).AllocL();

   452 			if (PropertyExists(propertyKeys, KCaldavUser))

   453 				iHttp->SetUserL(calendarInfo->PropertyValueL(KCaldavUser));

   454 			if (PropertyExists(propertyKeys, KCaldavPassword))

   455 				iHttp->SetPasswordL(calendarInfo->PropertyValueL(

   456 						KCaldavPassword));

   457 			if (PropertyExists(propertyKeys, KCaldavKeepServer))

   458 				iKeepServerEntry = GetBoolFromPropertiesL(calendarInfo,

   459 						KCaldavKeepServer);

   460 			if (PropertyExists(propertyKeys, KCaldavImmediateSync))

   461 				iImmediateSync = GetBoolFromPropertiesL(calendarInfo,

   462 						KCaldavImmediateSync);

   463 			if (PropertyExists(propertyKeys, KCaldavPastDays))

   464 				{

   465 				TPckgC<TTimeIntervalDays> pastdays(iPastDays);

   466 				pastdays.Set(calendarInfo->PropertyValueL(KCaldavPastDays));

   467 				iPastDays = pastdays();

   468 				}

   469 			if (PropertyExists(propertyKeys, KCaldavSyncInterval))

   470 				{

   471 				TPckgC<TTimeIntervalMinutes> syncinterval(iSyncInterval);

   472 				syncinterval.Set(calendarInfo->PropertyValueL(

   473 						KCaldavSyncInterval));

   474 				iSyncInterval = syncinterval();

   475 				}

   476 			// access point	    

   477 			}

   478 

   479 		CleanupStack::PopAndDestroy(propertyKeys);

   480 		CleanupStack::Pop(calendarInfo);

   481 		}

   482 	delete calendarInfo;

   483 	}

   484 

   485 /**

   486  * CCalDavEngine::InitL

   487  * check for correct url

   488  * load most Caldav url properties

   489  * do inital sync

   490  */

   491 TInt CCalDavEngine::InitL()

   492 	{

   493 	// this is only needed to find a GlobalUID from a LocalUID, used after an event was deleted

   494 	// also used now for uploading of local events when only GlobalUID is know 

   495 	LocalLoopL(ELoopActionFillArray);

   496 

   497 	if (iFirstInit)

   498 		{

   499 		TInt err = GetCalendarUrlsL(NULL);

   500 		if (err == KErrArgument)

   501 			return KErrArgument;

   502 		GetOptionsL();

   503 		SetLastSyncTimeL();

   504 

   505 		TBool success;

   506 		// get all server items

   507 		if (iOptions.sync_collection)

   508 			success = WebDavSyncL();

   509 		else

   510 			success = ListL() == KErrNone;

   511 

   512 		if (!success)

   513 			return KErrGeneral;

   514 

   515 		// upload all local entries of this calendar to server

   516 		LocalLoopL(ELoopActionUpload);

   517 

   518 		if (iOptions.sync_collection)

   519 			SetSyncTokenL(GetSyncTokenL());

   520 		else

   521 			SetCTagL(GetCTagL());

   522 

   523 		iFirstInit = EFalse;

   524 		iEnabled = ETrue;

   525 		TPckgC<TBool> firstInit(iFirstInit);

   526 		SetCalendarInfoL(KCaldavFirstInit, firstInit); // this will set iEnabled as well

   527 		}

   528 	else

   529 		{

   530 		TInt err = GetCalendarUrlsL(NULL);

   531 		if (err == KErrArgument)

   532 			return KErrArgument;

   533 		GetOptionsL();

   534 		SetLastSyncTimeL();

   535 		iEnabled = ETrue;

   536 		SetCalendarInfoL(KCaldavEnabled, KNullDesC8);

   537 		SyncL();

   538 		}

   539 

   540 	return KErrNone;

   541 	}

   542 

   543 /**

   544  * CCalDavEngine::Completed

   545  * Completed callback

   546  */

   547 void CCalDavEngine::Completed(TInt aError)

   548 	{

   549 	if (aError == KErrNone)

   550 		{

   551 		CActiveScheduler::Stop();

   552 		}

   553 	else

   554 		iManualSync = true;

   555 	}

   556 

   557 /**

   558  * CCalDavEngine::NotifyProgress

   559  * NotifyProgress callback

   560  */

   561 TBool CCalDavEngine::NotifyProgress()

   562 	{

   563 	return EFalse;

   564 	}

   565 

   566 /**

   567  * CCalDavEngine::CalChangeNotification

   568  * change item callback, sync to server

   569  */

   570 void CCalDavEngine::CalChangeNotification(RArray<TCalChangeEntry> &aChangeItems)

   571 	{

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

   573 		{

   574 		TRAP_IGNORE(HandleChangeL(aChangeItems[i].iChangeType, aChangeItems[i].iEntryType, aChangeItems[i].iEntryId));

   575 		}

   576 	}

   577 

   578 /**

   579  * CCalDavEngine::CalendarInfoChangeNotificationL

   580  * change callback, sync changed color or name to server

   581  */

   582 void CCalDavEngine::CalendarInfoChangeNotificationL(RPointerArray<

   583 		CCalFileChangeInfo>& aCalendarInfoChangeEntries)

   584 	{

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

   586 		{

   587 		if ((aCalendarInfoChangeEntries[i]->FileNameL() == *iCalendar)

   588 				&& (aCalendarInfoChangeEntries[i]->ChangeType()

   589 						== MCalFileChangeObserver::ECalendarInfoUpdated))

   590 			{

   591 			TRAP_IGNORE(HandleCalendarInfoChangeL());

   592 			}

   593 		}

   594 	}

   595 

   596 /**

   597  * CCalDavEngine::HandleCalendarInfoChangeL

   598  * sync changed color or name to server

   599  */

   600 void CCalDavEngine::HandleCalendarInfoChangeL()

   601 	{

   602 	if (iHttp)

   603 		{

   604 		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);

   605 		CleanupStack::PushL(response);

   606 		CCalCalendarInfo* info = iCalSession->CalendarInfoL();

   607 		CleanupStack::PushL(info);

   608 

   609 		HBufC8* name =

   610 				CnvUtfConverter::ConvertFromUnicodeToUtf8L(info->NameL());

   611 		CleanupStack::PushL(name);

   612 

   613 		TRgb color = info->Color();

   614 		_LIT8(KColorformat,"#%02x%02x%02xFF");

   615 		TBuf8<9> colorbuf;

   616 		colorbuf.Format(KColorformat, color.Red(), color.Green(), color.Blue());

   617 

   618 		HBufC8* patch = HBufC8::NewLC(KColorDisplayStart().Length()

   619 				+ colorbuf.Length() + KColorDisplayMiddle().Length()

   620 				+ name->Length() + KColorDisplayEnd().Length());

   621 		patch->Des().Append(KColorDisplayStart);

   622 		patch->Des().Append(colorbuf);

   623 		patch->Des().Append(KColorDisplayMiddle);

   624 		patch->Des().Append(*name);

   625 		patch->Des().Append(KColorDisplayEnd);

   626 		iHttp->ProppatchL(*iUrl, *patch, response);

   627 		CleanupStack::PopAndDestroy(4); // response, info, name, patch

   628 		}

   629 	}

   630 

   631 /**

   632  * CCalDavEngine::HandleChangeL

   633  * change item callback, sync to server

   634  */

   635 void CCalDavEngine::HandleChangeL(

   636 		MCalChangeCallBack2::TChangeType &aChangeType,

   637 		MCalChangeCallBack2::TChangeEntryType &aEntryType, TCalLocalUid &aUid)

   638 	{

   639 	switch (aChangeType)

   640 		{

   641 		case MCalChangeCallBack2::EChangeAdd:

   642 		case MCalChangeCallBack2::EChangeModify:

   643 			{

   644 			if (iImmediateSync)

   645 				UploadEntryL(aUid, aChangeType, aEntryType);

   646 			else

   647 				// enable manual sync for the next sync interval

   648 				SyncFailedL();

   649 			break;

   650 			}

   651 		case MCalChangeCallBack2::EChangeDelete:

   652 			{

   653 			if (iImmediateSync)

   654 				DeleteEntryL(aUid);

   655 			else

   656 				{

   657 				iDeletedEntries.Append(aUid);

   658 				SyncFailedL();

   659 				}

   660 			break;

   661 			}

   662 		case MCalChangeCallBack2::EChangeUndefined:

   663 			{

   664 			// upload new and modified entries to server

   665 			UploadModifiedSinceDateL();

   666 

   667 			// Find locally deleted ones and delete on server

   668 			DeleteRemovedEntriesOnServerL();

   669 

   670 			break;

   671 			}

   672 		}

   673 	}

   674 

   675 /**

   676  * CCalDavEngine::EnableL

   677  * enable Caldav sync

   678  */

   679 TInt CCalDavEngine::EnableL()

   680 	{

   681 	if (!iCalEntryView) //do not use iEnabled here,might be set already in ConstructL()

   682 		{

   683 		TInt aErr = CreateCalObjectsL();

   684 		if ((aErr == KErrNone) && (InitL() == KErrNone))

   685 			{

   686 			iTimer->Cancel();

   687 			TInt ticktime = iSyncInterval.Int() == 0 ? 1 : iSyncInterval.Int();

   688 			const TUint64 tickInterval = 1000000 * 60 * ticktime;

   689 			iTimer->Start(tickInterval, tickInterval,

   690 					TCallBack(SyncTickL, this));

   691 			// register change notification

   692 			RegisterL();

   693 			return KErrNone;

   694 			}

   695 		else

   696 			{

   697 			iEnabled = EFalse;

   698 			SetCalendarInfoL(KCaldavEnabled, KNullDesC8);

   699 			DeleteCalObjects();

   700 			return KErrArgument;

   701 			}

   702 		}

   703 	return KErrNone;

   704 	}

   705 

   706 /**

   707  * CCalDavEngine::DeleteCalObjects

   708  * delete all calendar objects

   709  */

   710 void CCalDavEngine::DeleteCalObjects()

   711 	{

   712 	delete iCalIter;

   713 	iCalIter = NULL;

   714 	delete iCalEntryView;

   715 	iCalEntryView = NULL;

   716 	delete iCalImporter;

   717 	iCalImporter = NULL;

   718 	delete iCalExporter;

   719 	iCalExporter = NULL;

   720 	if (iCalSession)

   721 		{

   722 		iCalSession->StopChangeNotification();

   723 		iCalSession->StopFileChangeNotification();

   724 		delete iCalSession;

   725 		}

   726 	iCalSession = NULL;

   727 	}

   728 

   729 /**

   730  * CCalDavEngine::CreateCalObjectsL

   731  * create all calendar objects

   732  */

   733 TInt CCalDavEngine::CreateCalObjectsL()

   734 	{

   735 	iCalSession = CCalSession::NewL();

   736 	TRAPD(aErr,iCalSession->OpenL(*iCalendar));

   737 	iCalExporter = CCalenExporter::NewL(*iCalSession);

   738 	iCalImporter = CCalenImporter::NewL(*iCalSession);

   739 	iCalEntryView = CCalEntryView::NewL(*iCalSession);

   740 	iCalIter = CCalIter::NewL(*iCalSession);

   741 	return aErr;

   742 	}

   743 

   744 /**

   745  * CCalDavEngine::DisableL

   746  * disable sync

   747  */

   748 void CCalDavEngine::DisableL()

   749 	{

   750 	if (iEnabled)

   751 		{

   752 		iTimer->Cancel();

   753 		iEnabled = EFalse;

   754 		SetCalendarInfoL(KCaldavEnabled, KNullDesC8);

   755 		DeleteCalObjects();

   756 		}

   757 	}

   758 

   759 /**

   760  * CCalDavEngine::EnabledSync

   761  * check for enabled sync

   762  */

   763 TBool CCalDavEngine::EnabledSync()

   764 	{

   765 	return iEnabled;

   766 	}

   767 

   768 /**

   769  * CCalDavEngine::TimeReportL

   770  * do a CalDav time report

   771  */

   772 TInt CCalDavEngine::TimeReportL(TBool VEVENT, const TDesC8 &aStart,

   773 		TBool aDelete)

   774 	{

   775 	CBufFlat* body = CBufFlat::NewL(EXPANDSIZE_BIG);

   776 	CleanupStack::PushL(body);

   777 

   778 	body->InsertL(body->Size(), VEVENT ? KTimeStartEVENT() : KTimeStartTODO());

   779 	body->InsertL(body->Size(), aStart); // "20090509T220000Z"/>

   780 	body->InsertL(body->Size(), KTimeEnd);

   781 

   782 	CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_BIG);

   783 	CleanupStack::PushL(response);

   784 	TInt ret = iHttp->ReportL(*iUrl, body->Ptr(0), response);

   785 

   786 	if (ret == MULTISTATUS)

   787 		ret = aDelete ? ParseResponsesDeleteL(response->Ptr(0))

   788 				: ParseResponsesL(response->Ptr(0));

   789 	else

   790 		ret = KErrGeneral;

   791 

   792 	CleanupStack::PopAndDestroy(response);

   793 	CleanupStack::PopAndDestroy(body);

   794 	return ret;

   795 	}

   796 

   797 /**

   798  * CCalDavEngine::ListL

   799  * get events either using time report or basic propfind

   800  */

   801 TInt CCalDavEngine::ListL()

   802 	{

   803 	if (iOptions.calendar_access)

   804 		{

   805 		TTime syncstart;

   806 		syncstart.HomeTime();

   807 		syncstart = syncstart - iPastDays;

   808 		TBuf<100> nowStr;

   809 		syncstart.FormatL(nowStr, KFormatString);

   810 		TBuf8<100> nowStrAdd;

   811 		nowStrAdd.Append(nowStr);

   812 

   813 		TInt eventreturn = KErrNone;

   814 		if (iOptions.VEVENT)

   815 			eventreturn = TimeReportL(ETrue, nowStrAdd);

   816 

   817 		TInt todoreturn = KErrNone;

   818 		if (iOptions.VTODO)

   819 			todoreturn = TimeReportL(EFalse, nowStrAdd);

   820 

   821 		return (eventreturn == KErrNone) && (todoreturn == KErrNone) ? KErrNone

   822 				: KErrGeneral;

   823 		}

   824 	else

   825 		{

   826 		// use PROPFIND report

   827 		CBufFlat* response = CBufFlat::NewL(EXPANDSIZE_SMALL);

   828 		CleanupStack::PushL(response);

   829 		TInt ret = iHttp->PropfindL(*iUrl, KPropList, response, EFalse);

   830 		if (ret == MULTISTATUS)

   831 			ret = ParseResponsesL(response->Ptr(0));

   832 		else

   833 			ret = KErrGeneral;

   834 		CleanupStack::PopAndDestroy(response);

   835 		return ret;

   836 		}

   837 	}

   838 

   839 /**

   840  * CCalDavEngine::SyncL

   841  * sync a calendar

   842  */

   843 TInt CCalDavEngine::SyncL()

   844 	{

   845 	if (iUrl)

   846 		{

   847 		if (iOptions.sync_collection)

   848 			return WebDavSyncL();

   849 		else

   850 			return ManualSyncL();

   851 		}

   852 	return KErrGeneral;

   853 	}

   854 

   855 /**

   856  * CCalDavEngine::ManualSyncL

   857  * if sync failed previously, try again manually

   858  */

   859 TBool CCalDavEngine::ManualSyncL()

   860 	{

   861 	TBool client = ClientChangesL();

   862 	if (iOptions.sync_ctag)

   863 		{

   864 		HBufC8 *newCTag = GetCTagL();

   865 		TBool server = ETrue;

   866 		if ((CTag() != *newCTag) && (*newCTag != KNullDesC8))

   867 			{

   868 			server = ServerChangesL();

   869 			if (server)

   870 				SetCTagL(newCTag);

   871 			else

   872 				delete newCTag;

   873 			}

   874 		else

   875 			delete newCTag;

   876 

   877 		return client || server;

   878 		}

   879 	else

   880 		{

   881 		TBool server = ServerChangesL();

   882 		return client || server;

   883 		}

   884 	}

   885 

   886 /**

   887  * CCalDavEngine::ServerChangesL

   888  * sync server changes

   889  */

   890 TBool CCalDavEngine::ServerChangesL()

   891 	{

   892 	// loop over all server items to find new and modified entries

   893 	// uses either propfind or calendar-query

   894 	TInt ret = ListL();

   895 

   896 	// loop over all local items to find deleted ones on the server

   897 	LocalLoopL(ELoopActionDeleteLocal);

   898 

   899 	return ret == KErrNone;

   900 	}

   901 

   902 /**

   903  * CCalDavEngine::LocalLoopL

   904  * loop over local calendar store

   905  */

   906 TInt CCalDavEngine::LocalLoopL(TLocalLoopAction aAction)

   907 	{

   908 	TBuf8<URLMAX> iter = iCalIter->FirstL();

   909 	TBuf8<URLMAX> url;

   910 	while (iter != KNullDesC8)

   911 		{

   912 		url.Append(*iUrl);

   913 		url.Append(iter);

   914 		url.Append(KIcs);

   915 		switch (aAction)

   916 			{

   917 			case ELoopActionDeleteLocal:

   918 				{

   919 				if (HeadL(iter) == NOTFOUND)

   920 					DeleteLocalEntryL(url);

   921 				break;

   922 				}

   923 			case ELoopActionFillArray:

   924 				{

   925 				RPointerArray<CCalEntry> entryArray;

   926 				CleanupClosePushL(entryArray);

   927 				iCalEntryView->FetchL(iter, entryArray);

   928 				if (entryArray.Count())

   929 					{

   930 					iLocalUidArray.Append(entryArray[0]->LocalUidL());

   931 					iGlobalUidArray.Append(entryArray[0]->UidL());

   932 					}

   933 				entryArray.ResetAndDestroy();

   934 				CleanupStack::PopAndDestroy(&entryArray);

   935 

   936 				break;

   937 				}

   938 			case ELoopActionUpload:

   939 				{

   940 				TInt pos = iGlobalUidArray.Find(iter);

   941 				if ((pos != KErrNotFound) && (iLocalUidArray.Count() > pos))

   942 					UploadEntryL(iLocalUidArray[pos],

   943 							MCalChangeCallBack2::EChangeAdd,

   944 							MCalChangeCallBack2::EChangeEntryAll);

   945 				break;

   946 				}

   947 			}

   948 		url.Delete(0, url.Length());

   949 		iter = iCalIter->NextL();

   950 		}

   951 	return KErrNone;

   952 	}

   953 

   954 /**

   955  * CCalDavEngine::ParseResponsesDeleteL

   956  * process a recieved multistatus response

   957  */

   958 TInt CCalDavEngine::ParseResponsesDeleteL(const TDesC8 &aDocument)

   959 	{

   960 	TInt ret = KErrNone;

   961 	RXmlEngDocument document = iDomParser.ParseL(aDocument);

   962 	CleanupClosePushL(document);

   963 	if (document.NotNull())

   964 		{

   965 		// this method works for response as well as sync-response

   966 		// do not use GetElementsByTagNameL for one specific responses directly	

   967 		TXmlEngElement ResponseListTop;

   968 		SearchL(document, KMultistatus, KNullDesC8, ResponseListTop);

   969 

   970 		RXmlEngNodeList<TXmlEngNode> ResponseList;

   971 		CleanupClosePushL(ResponseList);

   972 		ResponseListTop.GetChildNodes(ResponseList);

   973 

   974 		while (ResponseList.HasNext())

   975 			{

   976 			TXmlEngNode node = ResponseList.Next();

   977 			if (node.NodeType() == TXmlEngNode::EElement)

   978 				{

   979 				TPtrC8 href = SearchL(node, KHref, KNullDesC8);

   980 				// don't do anything with home itself

   981 				if ((href.Right(KIcs().Length()) == KIcs))

   982 					{

   983 					if (!DoesEntryExistL(href))

   984 						DeleteEntryL(href);

   985 					}

   986 				}

   987 			}

   988 		CleanupStack::PopAndDestroy(&ResponseList);

   989 

   990 		}

   991 	else

   992 		ret = KErrArgument;

   993 	CleanupStack::PopAndDestroy(&document);

   994 	return ret;

   995 	}

   996 

   997 /**

   998  * CCalDavEngine::ParseResponsesL

   999  * process a recieved multistatus response

  1000  */

  1001 TInt CCalDavEngine::ParseResponsesL(RXmlEngDocument &aDocument, TBool aMultiget)

  1002 	{

  1003 	TInt ret = KErrNone;

  1004 	if (aDocument.NotNull())

  1005 		{

  1006 		CDesC8ArrayFlat *multiget = NULL;

  1007 		if (iOptions.MULTIGET)

  1008 			{

  1009 			multiget = new (ELeave) CDesC8ArrayFlat(ARRAYEXPAND);

  1010 			CleanupStack::PushL(multiget);

  1011 			}

  1012 

  1013 		// this method works for response as well as sync-response

  1014 		// do not use GetElementsByTagNameL for one specific responses directly	

  1015 		TXmlEngElement ResponseListTop;

  1016 		SearchL(aDocument, KMultistatus, KNullDesC8, ResponseListTop);

  1017 

  1018 		RXmlEngNodeList<TXmlEngNode> ResponseList;

  1019 		CleanupClosePushL(ResponseList);

  1020 		ResponseListTop.GetChildNodes(ResponseList);

  1021 

  1022 		while (ResponseList.HasNext())

  1023 			{

  1024 			TXmlEngNode node = ResponseList.Next();

  1025 			if (node.NodeType() == TXmlEngNode::EElement)

  1026 				{

  1027 				TPtrC8 href = SearchL(node, KHref, KNullDesC8);

  1028 				//do not use Search, only looking for first childs,

  1029 				//as D:propstat has D:status as well

  1030 				RXmlEngNodeList<TXmlEngElement> statuslist;

  1031 				CleanupClosePushL(statuslist);

  1032 				node.AsElement().GetElementsByTagNameL(statuslist, KStatus,

  1033 						KDav);

  1034 				//only one or zero item

  1035 				HBufC8* status =

  1036 						statuslist.Count() ? statuslist.Next().Value().AllocL()

  1037 								: KNullDesC8().AllocL();

  1038 				CleanupStack::PopAndDestroy(&statuslist);

  1039 				CleanupStack::PushL(status);

  1040 				status->Des().LowerCase();

  1041 				TPtrC8 etag = SearchL(node, KEtag, KNullDesC8);

  1042 				RBuf8 calendardata;

  1043 				SearchL(node, KCalendarData, KNullDesC8, calendardata);

  1044 				calendardata.CleanupClosePushL();

  1045 

  1046 				// don't do anything with home itself

  1047 				if (href.Right(KIcs().Length()) == KIcs)

  1048 					{

  1049 					if ((*status == KHTTP200) || (*status == KHTTP201) || (*status == KNullDesC8))

  1050 						{

  1051 						if ((calendardata == KNullDesC8))

  1052 							{

  1053 							if (aMultiget)

  1054 								{

  1055 								// ATTENTION: an empty response to a multiget should never happen

  1056 								// data wrapped inside CDATA, e.g. bedework ??

  1057 								}

  1058 							else

  1059 								//TOOD: if this is a webdav sync response, we should skip the etag check

  1060 								AddModifyLocalEntryL(href, etag, multiget);

  1061 							}

  1062 						else

  1063 							{

  1064 							// response to a multiget or time-range report, we now already have everything we need

  1065 							StoreEntryL(calendardata, etag);

  1066 							}

  1067 						}

  1068 					else if (*status == KHTTP404)

  1069 						{

  1070 						if (iOptions.sync_collection)

  1071 							{

  1072 							// if this is an initial sync without token, 

  1073 							// this should be ignored, Sun Server bug!!!

  1074 							if (SyncToken() != KNullDesC8)

  1075 								DeleteLocalEntryL(href);

  1076 							}

  1077 						else

  1078 							{

  1079 							//multiget answer, but deleted in the meantime, should delete locally as well

  1080 							DeleteLocalEntryL(href);

  1081 							}

  1082 						}

  1083 					}

  1084 				CleanupStack::PopAndDestroy(&calendardata);

  1085 				CleanupStack::PopAndDestroy(status);

  1086 				}

  1087 			}

  1088 		CleanupStack::PopAndDestroy(&ResponseList);

  1089 

  1090 		if (iOptions.MULTIGET)

  1091 			{

  1092 			if (multiget->Count())

  1093 				{

  1094 				DownloadEntryL(multiget);

  1095 				multiget->Reset();

  1096 				}

  1097 			CleanupStack::PopAndDestroy(multiget);

  1098 			}

  1099 		}

  1100 	else

  1101 		ret = KErrArgument;

  1102 

  1103 	return ret;

  1104 	}

  1105 

  1106 /**

  1107  * CCalDavEngine::ParseResponsesL

  1108  * process a recieved multistatus response

  1109  */

  1110 TInt CCalDavEngine::ParseResponsesL(const TDesC8 &aDocument, TBool aMultiget)

  1111 	{

  1112 #ifdef _DEBUG

  1113 	_LIT(KFilename,"c:\\logs\\caldav\\parseresonseslatest.txt");

  1114 	ExportToFileNameL(aDocument, KFilename);

  1115 #endif

  1116 

  1117 	RXmlEngDocument document = iDomParser.ParseL(aDocument);

  1118 	CleanupClosePushL(document);

  1119 	TInt ret = ParseResponsesL(document, aMultiget);

  1120 	CleanupStack::PopAndDestroy(&document);

  1121 	return ret;

  1122 	}

  1123 

  1124 /**

  1125  * CCalDavEngine::StoreEntryL

  1126  * store event in local store

  1127  */

  1128 #ifdef ETAG

  1129 TInt CCalDavEngine::StoreEntryL(const TDesC8 &aBuf, const TDesC8 &aEtag)

  1130 #else

  1131 TInt CCalDavEngine::StoreEntryL(const TDesC8 &aBuf, const TDesC8 &/*aEtag*/)

  1132 #endif

  1133 	{

  1134 #ifdef _DEBUG