1 /*

     2 * Copyright (c) 2002-2004 Nokia Corporation 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 Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   This file contains iCal importer implementation.

    15 *                Converts iCal data to symbian agenda entry.

    16 *

    17 */

    18 

    19 

    20 

    21 // Class include.

    22 #include "AgnVersit2Importer.h"

    23 

    24 //debug

    25 #include "calendarengines_debug.h"

    26 

    27 // Agenda includes.

    28 #include <calalarm.h>			// For CCalAlarm

    29 #include <calcategory.h>		// For CCalCategory

    30 #include <calentry.h>			// For CCalEntry

    31 #include <calrrule.h>			// For CCalRRule

    32 #include <caltime.h>			// For CCalTime

    33 #include <caluser.h>			// For CCalUser

    34 #include <tzdefines.h>			// For TTzRuleDay

    35 #include <vtzrules.h>			// For CTzRules and TTzRule

    36 #include <CalenInterimUtils2.h>

    37 

    38 // Versit includes.

    39 #include "ICal.h"				// For CICal

    40 #include "ICalComponent.h"		// For CICalComponent

    41 #include "ICalKeyWords.h"		// For CICalKeyWords

    42 #include "ICalParser.h"			// For CICalParser

    43 #include "ICalProperty.h"		// For CICalProperty

    44 #include "ICalPropertyParam.h"	// For CICalPropertyParam

    45 #include "ICalRuleSegment.h"	// For CICalRuleSegment

    46 #include "ICalValue.h"			// For CICalValue

    47 

    48 // AgnVersit2 includes.

    49 #include "agnimportobserver.h"			// For MAgnImportObserver

    50 #include "AgnVersit2StringProvider.h"	// For CAgnVersit2StringProvider

    51 #include "CleanupPointerArray.h"		// For TCleanupPointerArray

    52 

    53 #include "AgnRRuleImporter.h"           // For CAgnRRuleImporter

    54 // Constants.

    55 

    56 

    57 /** A semi-colon character. */

    58 const TUint KAgnVersitTokenSemiColonVal =';';

    59 

    60 //

    61 //    CTzNamedRules

    62 //    =============

    63 //

    64 

    65 /**

    66 Constructor.

    67 @internalTechnology

    68 */

    69 CAgnVersit2Importer::CTzNamedRules::CTzNamedRules()

    70 	{

    71 	TRACE_ENTRY_POINT;

    72 	TRACE_EXIT_POINT;

    73 	}

    74 

    75 /**

    76 Destructor.

    77 @internalTechnology

    78 */

    79 CAgnVersit2Importer::CTzNamedRules::~CTzNamedRules()

    80 	{

    81 	TRACE_ENTRY_POINT;

    82 	

    83 	delete iRules;

    84 	delete iName;

    85 	

    86 	TRACE_EXIT_POINT;

    87 	}

    88 

    89 //

    90 //     CAgnVersit2Importer

    91 //     ===================

    92 //

    93 

    94 /**

    95 Constructs a new CAgnVersit2Importer and returns it.

    96 @param aStringProvider A string provider for obtaining resource strings from.

    97 @return a new CAgnVersit2Importer.

    98 @internalTechnology

    99 */

   100 CAgnVersit2Importer* CAgnVersit2Importer::NewL(CAgnVersit2StringProvider& aStringProvider)

   101 	{

   102 	TRACE_ENTRY_POINT;

   103 	

   104 	CAgnVersit2Importer* self = CAgnVersit2Importer::NewLC(aStringProvider);

   105 	CleanupStack::Pop(self);

   106 	

   107 	TRACE_EXIT_POINT;

   108 	return self;

   109 	}

   110 

   111 /**

   112 Constructs a new CAgnVersit2Importer and returns it. The object is left on the

   113 cleanup stack.

   114 @param aStringProvider A string provider for obtaining resource strings from.

   115 @return a new CAgnVersit2Importer.

   116 @internalTechnology

   117 */

   118 CAgnVersit2Importer* CAgnVersit2Importer::NewLC(CAgnVersit2StringProvider& aStringProvider)

   119 	{

   120 	TRACE_ENTRY_POINT;

   121 	

   122 	CAgnVersit2Importer* self = new (ELeave) CAgnVersit2Importer(aStringProvider);

   123 	CleanupStack::PushL(self);

   124 	self->ConstructL();

   125 	

   126 	TRACE_EXIT_POINT;

   127 	return self;

   128 	}

   129 

   130 /**

   131 Destructor.

   132 @internalTechnology

   133 */

   134 CAgnVersit2Importer::~CAgnVersit2Importer()

   135 	{

   136 	TRACE_ENTRY_POINT;

   137 	

   138 	iTzRules.ResetAndDestroy();

   139 	

   140 	TRACE_EXIT_POINT;

   141 	}

   142 

   143 /**

   144 Uses Versit2 to parse an input stream, and then converts the result into

   145 CCalEntry objects.

   146 @param aEntries The array to append entries to.

   147 @param aReadStream The stream to read iCalendar data from.

   148 @param aObserver Application interface for error reporting.

   149 @internalTechnology

   150 */

   151 void CAgnVersit2Importer::ImportL( RPointerArray<CCalEntry>& aEntries,

   152                                    RReadStream& aReadStream,

   153                                    MAgnImportObserver& aObserver )

   154 	{

   155 	TRACE_ENTRY_POINT;

   156 	

   157 	iImportObserver = &aObserver;

   158 

   159 	CICalParser* parser = CICalParser::NewLC();

   160 	parser->InternalizeL(aReadStream);

   161 

   162 	const TInt count = parser->CalCount();

   163 

   164 	for (TInt cal = 0; cal < count; ++cal)

   165 		{

   166 		CICal& calendar = parser->Cal(cal);

   167 		TRAPD(err, ImportICalL(aEntries, calendar));

   168 		iTzRules.ResetAndDestroy();

   169 		User::LeaveIfError(err);

   170 		}

   171 

   172 	CleanupStack::PopAndDestroy(parser);

   173 	TRACE_EXIT_POINT;

   174 	}

   175 

   176 /**

   177 Constructor.

   178 @internalTechnology

   179 */

   180 CAgnVersit2Importer::CAgnVersit2Importer(CAgnVersit2StringProvider& aStringProvider)

   181 	: iStringProvider(aStringProvider)

   182 	{

   183 	TRACE_ENTRY_POINT;

   184 	TRACE_EXIT_POINT;

   185 	}

   186 

   187 /**

   188 Internal construction.

   189 @internalTechnology

   190 */

   191 void CAgnVersit2Importer::ConstructL()

   192 	{

   193 	TRACE_ENTRY_POINT;

   194 	TRACE_EXIT_POINT;

   195 	}

   196 

   197 /**

   198 Takes a calendar object from Versit2 and converts it into a set of CCalEntry

   199 objects.

   200 @param aEntries The array to append entries to.

   201 @param aCal An object of type CICal from which to obtain data.

   202 @leave KErrAbort, or any other system wide error code.

   203 @internalTechnology

   204 */

   205 void CAgnVersit2Importer::ImportICalL(RPointerArray<CCalEntry>& aEntries, CICal& aCal)

   206 	{

   207 	TRACE_ENTRY_POINT;

   208 	

   209 	const RPointerArray<CICalComponent>& components = aCal.Components();

   210 

   211 	// Run through the timezones so that we know what other components are referring to:

   212 	iTzRules.ResetAndDestroy();

   213 	TInt com; // current component number

   214 	TInt comCount = components.Count();

   215 	for (com = 0; com < comCount && iResponse == MAgnImportObserver::EImpResponseContinue; ++com)

   216 		{

   217 		CICalComponent* component = components[com];

   218 

   219 		// We are only interested in timezones:

   220 		if (component->Type() == CICalBase::EICalTimeZone)

   221 			{

   222 			TRAPD(err, ImportTimezoneL(*component));

   223 			if (err)

   224 				{

   225 				// If there isn't a response, then it isn't a recoverable leave:

   226 				if (iResponse == MAgnImportObserver::EImpResponseContinue)

   227 					{

   228 					User::Leave(err);

   229 					}

   230 				// If there is a response, then we threw this after reporting an

   231 				// error to the observer, and we may be able to continue:

   232 				else if(iResponse == MAgnImportObserver::EImpResponseSkip)

   233 					{

   234 					iResponse = MAgnImportObserver::EImpResponseContinue;

   235 					}

   236 				}

   237 			}

   238 		}

   239 

   240 	// Run through the other components:

   241 	for (com = 0; com < comCount && iResponse == MAgnImportObserver::EImpResponseContinue; ++com)

   242 		{

   243 		CICalComponent* component = components[com];

   244 

   245 		// We aren't interested in timezones:

   246 		if (component->Type() != CICalBase::EICalTimeZone)

   247 			{

   248 			TRAPD(err, ImportComponentL(aCal, *component, aEntries));

   249 			if (err)

   250 				{

   251 				// If there isn't a response, then it isn't a recoverable leave:

   252 				if (iResponse == MAgnImportObserver::EImpResponseContinue)

   253 					{

   254 					User::Leave(err);

   255 					}

   256 				// If there is a response, then we threw this after reporting an

   257 				// error to the observer, and we may be able to continue:

   258 				else if(iResponse == MAgnImportObserver::EImpResponseSkip)

   259 					{

   260 					iResponse = MAgnImportObserver::EImpResponseContinue;

   261 					}

   262 				}

   263 			}

   264 		}

   265 

   266 	// If we have been asked to leave after an error, do so:

   267 	if (iResponse == MAgnImportObserver::EImpResponseLeave)

   268 		{

   269 		User::Leave(KErrAbort);

   270 		}

   271 	

   272 	TRACE_EXIT_POINT;

   273 	}

   274 

   275 /**

   276 *     IMPORT COMPONENT FUNCTIONS

   277 *     ==========================

   278 */

   279 

   280 /**

   281 Handles the importing of a single component, other than a timezone.

   282 @param aCal The calendar object from which we are importing

   283 @param aComponent The specific component we are importing

   284 @param aEntries The agenda entries onto which this component is to be appended.

   285 @internalTechnology

   286 */

   287 void CAgnVersit2Importer::ImportComponentL( const CICal& aCal,

   288                                             const CICalComponent& aComponent,

   289                                             RPointerArray<CCalEntry>& aEntries )

   290 	{

   291 	TRACE_ENTRY_POINT;

   292 	

   293 	// Get the UID:

   294 	HBufC8* entryUid = NULL;

   295 	const CICalProperty* propUid = aComponent.FindProperty(KICalUid());

   296 

   297 	if (!propUid)//(propUid && propUid->Values().Count() < 1)

   298 		{

   299 		// if UID is not present,generate using caleninterimutils api

   300 		CCalenInterimUtils2* interimUtils = CCalenInterimUtils2::NewL();

   301 		CleanupStack::PushL(interimUtils);

   302 		// get the global uid

   303 		entryUid = interimUtils->GlobalUidL();

   304 		CleanupStack::PopAndDestroy(interimUtils);

   305 		CleanupStack::PushL(entryUid);

   306 		}

   307 	else

   308 		{

   309 		entryUid = propUid->Values()[0]->BinaryLC();

   310 		}

   311 	

   312 	if(entryUid)

   313 	    {

   314 		// Import entry-type specific data:

   315 		switch (aComponent.Type())

   316 			{

   317 			case CICalBase::EICalEvent :

   318 				{

   319 				CCalEntry::TType eventType = CCalEntry::EEvent;

   320 				

   321 				//Check if we have a DTEND or DURATION

   322 				if (aComponent.FindProperty(KICalDtend()) || aComponent.FindProperty(KICalDuration()))

   323 					{

   324 					eventType = CCalEntry::EAppt;

   325 					}

   326 					

   327 				else

   328 					{

   329 					//Check if we have a DTSTART

   330 					if (aComponent.FindProperty(KICalDtstart()))

   331 						{

   332 						eventType = CCalEntry::EReminder;

   333 						}

   334 					

   335 					//Check if this is a yearly repeat

   336 					if (aComponent.FindProperty(KICalRRule()))

   337 						{

   338 						const CICalProperty* rrule = aComponent.FindProperty(KICalRRule());

   339 						const RPointerArray<CICalValue>& rulevalues = rrule->Values();

   340 	

   341 						if (rulevalues.Count() >= 1)

   342 							{

   343 							CICalRuleSegment::TFreq freq = CICalRuleSegment::EFreqDaily;

   344 							RPointerArray<CICalRuleSegment> recRules;

   345 							CleanupPointerArrayPushL(recRules);

   346 

   347 							// At this point we take ownership of the things which rules contains:

   348 							rulevalues[0]->GetRecurrenceRuleL(recRules);

   349 

   350 							// An RRule must have a frequency.

   351 							TInt pos = FindRuleSegment(recRules, CICalRuleSegment::ESegFreq);

   352 							if (pos != KErrNotFound)

   353 								{

   354 								ASSERT(recRules.Count() >= pos + 1);

   355 								freq = recRules[pos]->FreqL();

   356 								}

   357 

   358 							// Find the interval.

   359 							pos = FindRuleSegment(recRules, CICalRuleSegment::ESegInterval);

   360 							TInt interval = 1; //default value if no INTERVAL specified

   361 							if (pos != KErrNotFound)

   362 								{

   363 								ASSERT(recRules[pos]->Values().Count() >= 0);

   364 								interval = recRules[pos]->Values()[0]->IntegerL();

   365 								}

   366 						

   367 							if ((freq == CICalRuleSegment::EFreqYearly) && (interval == 1))

   368 								{

   369 								//Anniversary repeats once a year

   370 								eventType = CCalEntry::EAnniv;

   371 								}

   372 								

   373 							CleanupStack::PopAndDestroy(&recRules);

   374 							}

   375 						}

   376 					}

   377 				CleanupStack::Pop(entryUid);

   378 				// Passing ownership of entryUid

   379 				ImportEntryL(aCal, aComponent, aEntries, entryUid, eventType);

   380 				}

   381 				break;

   382 			case CICalBase::EICalTodo :

   383 				CleanupStack::Pop(entryUid);

   384 				// Passing ownership of entryUid

   385 				ImportEntryL(aCal, aComponent, aEntries, entryUid, CCalEntry::ETodo);

   386 				break;

   387 			case CICalBase::EICalJournal :

   388 				ReportErrorL(MAgnImportObserver::EImpErrorNotSupported, *entryUid, KICalJournal, EFalse);

   389 				// Continue equates to skip in this instance.

   390 				break;

   391 			case CICalBase::EICalAlarm :

   392 				ReportErrorL(MAgnImportObserver::EImpErrorInvalidData, *entryUid, KICalAlarm, EFalse);

   393 				// Continue equates to skip in this instance.

   394 				break;

   395 			case CICalBase::EICalFreeBusy :

   396 				ReportErrorL(MAgnImportObserver::EImpErrorNotSupported, *entryUid, KICalFreeBusy, EFalse);

   397 				// Continue equates to skip in this instance.

   398 				break;

   399 			case CICalBase::EICalInvalid :	// not valid here, fall through

   400 			case CICalBase::EICalCalendar :	// not valid here, fall through

   401 			case CICalBase::EICalTimeZone :	// not valid here, fall through

   402 			case CICalBase::EICalStandard :	// not valid here, fall through

   403 			case CICalBase::EICalDaylight :	// not valid here, fall through

   404 			default :

   405 				ReportErrorL( MAgnImportObserver::EImpErrorInvalidData,

   406 				              *entryUid,

   407 				              aComponent.TypeStringL(),

   408 				              EFalse );

   409 				// Continue equates to skip in this instance.

   410 				break;

   411 			}

   412 		}

   413 	TRACE_EXIT_POINT;

   414 	}

   415 

   416 /**

   417 Checks for a VALARM in a component. If a valid one is found, it is added to the

   418 specified entry.

   419 @param aComponent Component to search for a VALARM in.

   420 @param aEntry Alarm is added to this calendar entry.

   421 @param aUid UID of the component.

   422 @param aStartTime A pointer to the DTSTART of the parent component, if it has

   423 one, or NULL if it does not. This does not take ownership.

   424 @return MAgnImportObserver::TImpResponse indicating application response to errors, if any.

   425 @internalTechnology

   426 */

   427 void CAgnVersit2Importer::ImportAlarmL( const CICalComponent& aComponent,

   428                                         CCalEntry& aEntry,

   429                                         const HBufC8& aUid,

   430                                         const TCalTime* aStartTime )

   431 	{

   432 	TRACE_ENTRY_POINT;

   433 	

   434 	if (aComponent.ComponentExists(CICalBase::EICalAlarm))

   435 		{

   436 		// Check the outer component is a VEVENT or a VTODO

   437 		if (aComponent.Type() == CICalBase::EICalEvent || aComponent.Type() == CICalBase::EICalTodo)

   438 			{

   439 			const RPointerArray<CICalComponent>& nestedComponents = aComponent.Components();

   440 			// Iterate through all the nested components and create a new alarm for each VALARM component

   441 			TInt nestedComCount = nestedComponents.Count();

   442 			for (TInt i = 0; i < nestedComCount; i++)

   443 				{

   444 				if (nestedComponents[i]->Type() == CICalBase::EICalAlarm)

   445 					{

   446 					CCalAlarm* alarm = CCalAlarm::NewL();

   447 					CleanupStack::PushL(alarm);

   448 					const RPointerArray<CICalProperty>& nestedProperties = nestedComponents[i]->Properties();

   449 					// Go through all the nested properties until we find the TRIGGER

   450 					// Ignore REPEAT and DURATION + any others

   451 					TBool foundTrigger=EFalse;

   452 					TInt nestedPropCount = nestedProperties.Count();

   453 					for (TInt j = 0; j < nestedPropCount; j++)

   454 						{

   455 						if (nestedProperties[j]->Type() == KICalTrigger)

   456 							{

   457 							const RPointerArray<CICalValue>& values = nestedProperties[j]->Values();

   458 							// There should only be one value, don't try to add the alarm if there are more

   459 							if (values.Count() == 1)

   460 								{

   461 								const CICalPropertyParam* valueType = nestedProperties[j]->FindParam(KICalValue);

   462 								TTimeIntervalMinutes duration;

   463 								if (valueType) // Only DATE-TIME is legal here - assume it's that one.

   464 									{

   465 									if (!aStartTime)

   466 										{

   467 										ReportErrorL( MAgnImportObserver::EImpErrorMissingData,

   468 										              aUid,

   469 										              iStringProvider.StringL(EICalErrValarmNoStart),

   470 										              EFalse );

   471 										// On continue, we skip the alarm.

   472 										}

   473 									else

   474 										{

   475 										TCalTime absTime;

   476 										GetCalTimeL(*nestedProperties[j], absTime, EDateTime);

   477 										aStartTime->TimeUtcL().MinutesFrom(absTime.TimeUtcL(), duration);

   478 										}

   479 									}

   480 								else

   481 									{

   482 									duration = values[0]->DurationL().Int() / KSecondsInOneMinute;

   483 									}

   484 

   485 								// Only negative durations are allowed (the alarm must be *before* the event).

   486 								if (duration.Int() > 0)

   487 									{

   488 									ReportErrorL( MAgnImportObserver::EImpErrorNotSupported,

   489 									              aUid,

   490 									              iStringProvider.StringL(EICalErrAlarmAfterEvent) );

   491 									// On continue, the duration will be made "negative".

   492 									}

   493 

   494 								// Agenda expects a positive duration - convert the sign.

   495 								if (duration.Int() < 0)

   496 									{

   497 									duration = -(duration.Int());

   498 									}

   499 

   500 								alarm->SetTimeOffset(duration);

   501 								foundTrigger=ETrue;

   502 								}

   503 							}

   504 						}

   505 					if (foundTrigger)

   506 						{

   507 						aEntry.SetAlarmL(alarm);// Doesn't take ownership

   508 						}

   509 					else

   510 						{

   511 						ReportErrorL( MAgnImportObserver::EImpErrorMissingData,

   512 						              aUid,

   513 						              iStringProvider.StringL(EICalErrValarmNoTrigger),

   514 						              EFalse );

   515 						// On continue, the alarm will be skipped.

   516 						}

   517 					CleanupStack::PopAndDestroy(alarm);

   518 					}

   519 				}

   520 			}

   521 		else

   522 			{

   523 			ReportErrorL( MAgnImportObserver::EImpErrorInvalidData,

   524 			              aUid,

   525 			              iStringProvider.StringL(EICalErrValarmNotAllowed),

   526 			              EFalse );

   527 			// On continue, the alarm will be skipped.

   528 			}

   529 		}

   530 	

   531 	TRACE_EXIT_POINT;

   532 	}

   533 

   534 

   535 /**

   536 Performs most of the work of importing a component from an iCalendar, provided

   537 that the component is one which can be handled as a CCalEntry. Timezone and

   538 Alarm components are not imported in this manner.

   539 @param aCal The calendar object containing the component.

   540 @param aComponent The component to be imported.

   541 @param aEntries The array onto which to append the new entry.

   542 @param aUid The UID of the component (takes ownership).

   543 @param aType The type of entry being imoported

   544 @return MAgnImportObserver::TImpResponse indicating application response to errors, if any.

   545 @internalTechnology

   546 */

   547 void CAgnVersit2Importer::ImportEntryL( const CICal& aCal,

   548                                         const CICalComponent& aComponent,

   549                                         RPointerArray<CCalEntry>& aEntries,

   550                                         HBufC8* aUid,

   551                                         CCalEntry::TType aType )

   552 	{

   553 	TRACE_ENTRY_POINT;

   554 	

   555 	// Create a basic entry to add properties to.

   556 	CCalEntry* entry = CreateEntryLC(aCal, aComponent, aUid, aType); // takes ownership of aUid

   557 

   558 	iNeedsTzRules = (EFalse);

   559 	iCurrentTzRules = NULL;

   560 

   561 	// set the entry properties:

   562 	CICalProperty* rruleproperty = NULL;

   563 	CICalProperty* startproperty = NULL;

   564 	CICalProperty* endproperty = NULL;

   565 	CICalProperty* durationproperty = NULL;

   566 	RPointerArray<CICalProperty> exDateProperties;

   567 	CleanupClosePushL(exDateProperties);

   568 	RPointerArray<CICalProperty> rDateProperties;

   569 	CleanupClosePushL(rDateProperties);

   570 

   571 	const RPointerArray<CICalProperty>& properties = aComponent.Properties();

   572 	TInt propCount = properties.Count();

   573 	for (TInt pnum = 0; pnum < propCount; ++pnum)

   574 		{

   575 		CICalProperty* property = properties[pnum];

   576 

   577 		// DTSTART, DTEND, DURATION, EXDATE, RDATE and RRULE need special handling,

   578 		//as they affect one another.

   579 		if (property->Type().CompareF(KICalRRule) == 0)

   580 			{

   581 			rruleproperty = property;

   582 			}

   583 		else if (property->Type().CompareF(KICalDtstart) == 0)

   584 			{

   585 			startproperty = property;

   586 			}

   587 		else if (property->Type().CompareF(KICalDtend) == 0)

   588 			{

   589 			endproperty = property;

   590 			}

   591 		else if (property->Type().CompareF(KICalDuration) == 0)

   592 			{

   593 			durationproperty = property;

   594 			}

   595 		else if (property->Type().CompareF(KICalExdate) == 0)

   596 			{

   597 			// It is valid to have more than one EXDATE property. We store them all in an array.

   598 			User::LeaveIfError(exDateProperties.Append(property));

   599 			}

   600 		else if (property->Type().CompareF(KICalRdate) == 0)

   601 			{

   602 			// It is valid to have more than one RDATE property. We store them all in an array.

   603 			User::LeaveIfError(rDateProperties.Append(property));

   604 			}

   605 		else

   606 			{

   607 			ImportPropertyL(*entry, *property);

   608 			}

   609 		}

   610 

   611 	// We cannot handle a DTSTART, DTEND or DURATION field on its own, so we have saved them up

   612 	// and will sort them out here.

   613 	// In theory, some methods allow an event to specify an end time but no start time.

   614 	// We have no way of dealing with this so we discard it.  When we get a start time

   615 	// with no end time, we assume a duration of 0 seconds.

   616 	TCalTime start;

   617 	TCalTime end;

   618 	if (startproperty)

   619 		{

   620 		GetCalTimeL(*startproperty, start, EDateTime);

   621 		end = start;

   622 		if (endproperty)

   623 			{

   624 			GetCalTimeL(*endproperty, end, EDateTime);

   625 			}

   626 		else if (durationproperty && startproperty)

   627 			{

   628 			if (durationproperty->Values().Count() < 1)

   629 				{

   630 				ReportErrorL(MAgnImportObserver::EImpErrorMissingData, *aUid, KICalDuration);

   631 				// On continue use the start time as the end time (a duration of 0 seconds)

   632 				}

   633 			else

   634 				{

   635 				end.SetTimeUtcL(start.TimeUtcL() + durationproperty->Values()[0]->DurationL());

   636 				}

   637 			}

   638 		entry->SetStartAndEndTimeL(start, end);

   639 		}

   640 

   641 	// We must have a start time before we can interpret some alarms:

   642 	TRAPD(alarmerr, ImportAlarmL(aComponent, *entry, *aUid, startproperty?&start:0));

   643 	// If we fail and elect to skip whilst importing the alarm, continue

   644 	// with the current component.

   645 	if (alarmerr && iResponse == MAgnImportObserver::EImpResponseSkip)

   646 		{

   647 		iResponse = MAgnImportObserver::EImpResponseContinue;

   648 		}

   649 	else

   650 		{

   651 		User::LeaveIfError(alarmerr);

   652 		}

   653 

   654 	// We cannot put an rrule property into the agenda model format until we

   655 	// have properties such as dtstart already stored, so we do this last:

   656 	if (rruleproperty)

   657 		{

   658 		if (startproperty)

   659 			{

   660 			if (ImportRRuleL(*rruleproperty, *entry, start))

   661 				{

   662 				// APINOTE: In the Cal Interim API EXDATE is only valid with an RRULE.

   663 				// This is not necessarily so for iTIP updates.

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

   665 					{

   666 					ImportPropertyL(*entry, *(exDateProperties[i]));

   667 					}

   668 				}

   669 			else if (exDateProperties.Count() > 0)

   670 				{

   671 				// Cannot process an EXDATE without an RRULE.

   672 				ReportErrorL(MAgnImportObserver::EImpErrorNotSupported, *aUid, KICalExdate);

   673 				}

   674 			}

   675 		else

   676 			{

   677 			// Cannot process an RRULE without a DTSTART

   678 			ReportErrorL(MAgnImportObserver::EImpErrorMissingData, *aUid, KICalDtstart);

   679 			}

   680 		}

   681 

   682 

   683 	// RDATE does not neccessary need an RRULE.

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

   685 		{

   686 		ImportPropertyL(*entry, *(rDateProperties[i]));

   687 		}

   688 

   689 	CleanupStack::PopAndDestroy(&rDateProperties);

   690 	CleanupStack::PopAndDestroy(&exDateProperties);

   691 

   692 	// APINOTE: When setting the RRULE, the API overwrites the DTEND field.

   693 	// This block sets it back to what it should be.

   694 	if (startproperty)

   695 		{

   696 		// We don't need to check for an end time as it gets initialised when the

   697 		// start time gets set.

   698 		entry->SetStartAndEndTimeL(start, end);

   699 		}

   700 

   701 	// If we have set up a timezone, add this to the entry.

   702 	// Only entries with RDATES, EXDATES, RRULES or EXRULES will have this.

   703 	if (iNeedsTzRules)

   704 		{

   705 		if (iCurrentTzRules)

   706 			{

   707 			entry->SetTzRulesL(*iCurrentTzRules);

   708 			}

   709 		}

   710 

   711 	//Set the last modified date to current time

   712 	entry->SetLastModifiedDateL();

   713 	// Store the entry:

   714 	User::LeaveIfError(aEntries.Append(entry)); // Takes ownership if successful

   715 	CleanupStack::Pop(entry);

   716 	

   717 	TRACE_EXIT_POINT;

   718 	}

   719 

   720 /**

   721 Creates a new entry and pushes it onto the cleanup stack.

   722 @param aCal The calendar object containing the component.

   723 @param aComponent The component to be imported.

   724 @param aUid The UID of the component (takes ownership).

   725 @param aType The type of entry being imoported

   726 @return A new CCalEntry, or zero if a recoverable error occurs and the observer

   727 elects not to continue from it.

   728 @internalTechnology

   729 */

   730 CCalEntry * CAgnVersit2Importer::CreateEntryLC( const CICal& aCal,

   731                                                 const CICalComponent& aComponent,

   732                                                 HBufC8* aUid,

   733                                                 CCalEntry::TType aType )

   734     {

   735     TRACE_ENTRY_POINT;

   736     

   737 	CleanupStack::PushL(aUid);

   738 

   739 	const CICalProperty* propSeq = aComponent.FindProperty(KICalSequence);

   740 

   741 	// Find the sequence number, but accept a default of 0 if there isn't one:

   742 	TUint entrySeq = 0;

   743 	if (propSeq && propSeq->Values().Count() > 0)

   744 		{

   745 		entrySeq = propSeq->Values()[0]->IntegerL();

   746 		}

   747 

   748 	// Find the method, but accept a default of EMethodNone if there isn't one:

   749 	CCalEntry::TMethod method = CCalEntry::EMethodNone;

   750 	const CICalProperty* prop = aCal.FindProperty(KICalMethod);

   751 	if (prop && prop->Values().Count() > 0)

   752 		{

   753 		TPtrC val;

   754 		val.Set(prop->Values()[0]->TextL());

   755 		if (val.CompareF(KICalPublish) == 0)

   756 			{

   757 			method = CCalEntry::EMethodPublish;

   758 			}

   759 		else if (val.CompareF(KICalRequest) == 0)

   760 			{

   761 			method = CCalEntry::EMethodRequest;

   762 			}

   763 		else if (val.CompareF(KICalReply) == 0)

   764 			{

   765 			method = CCalEntry::EMethodReply;

   766 			}

   767 		else if (val.CompareF(KICalAdd) == 0)

   768 			{

   769 			method = CCalEntry::EMethodAdd;

   770 			}

   771 		else if (val.CompareF(KICalCancel) == 0)

   772 			{

   773 			method = CCalEntry::EMethodCancel;

   774 			}

   775 		else if (val.CompareF(KICalRefresh) == 0)

   776 			{

   777 			method = CCalEntry::EMethodRefresh;

   778 			}

   779 		else if (val.CompareF(KICalCounter) == 0)

   780 			{

   781 			method = CCalEntry::EMethodCounter;

   782 			}

   783 		else if (val.CompareF(KICalDeclineCounter) == 0)

   784 			{

   785 			method = CCalEntry::EMethodDeclineCounter;

   786 			}

   787 		else

   788 			{

   789 			ReportErrorL(MAgnImportObserver::EImpErrorInvalidData, *aUid, val);

   790 			// On continue, use EMethodNone.

   791 			}

   792 		}

   793 

   794 	CCalEntry* entry = NULL;

   795 	// Find the recurrence information, if there is any:

   796 	const CICalProperty* propRecurrenceId = aComponent.FindProperty(KICalRecurrenceId);

   797 	if (propRecurrenceId)

   798 		{

   799 		TCalTime entryRecId;

   800 		GetCalTimeL(*propRecurrenceId, entryRecId, EDateTime);

   801 

   802 		const CICalPropertyParam* range = propRecurrenceId->FindParam(KICalRange);

   803 		CalCommon::TRecurrenceRange entryRange = CalCommon::EThisOnly;

   804 		if (range && range->Values().Count() > 0)

   805 			{

   806 			if (range->Values()[0]->TextL().CompareF(KICalThisAndPrior) == 0)

   807 				{

   808 				entryRange = CalCommon::EThisAndPrior;

   809 				}

   810 			else if (range->Values()[0]->TextL().CompareF(KICalThisAndFuture) == 0)

   811 				{

   812 				entryRange = CalCommon::EThisAndFuture;

   813 				}

   814 			else

   815 				{

   816 				ReportErrorL(MAgnImportObserver::EImpErrorInvalidData, *aUid, range->Values()[0]->TextL());

   817 				// On continue, assume this instance only.

   818 				}

   819 			}

   820 		// Create an entry with recurrence data:

   821 		// Passing ownership of aUid

   822 		CleanupStack::Pop(aUid);

   823 		entry = CCalEntry::NewL(aType, aUid, method, entrySeq, entryRecId, entryRange);

   824 		CleanupStack::PushL(entry);

   825 		}

   826 	else

   827 		{

   828 		// Create an entry without recurrence data:

   829 		// Passing ownership of aUid

   830 		CleanupStack::Pop(aUid);

   831 		entry = CCalEntry::NewL(aType, aUid, method, entrySeq);

   832 		CleanupStack::PushL(entry);

   833 		}

   834     

   835     TRACE_EXIT_POINT;

   836 	return entry;

   837 	}

   838 

   839 /**

   840 Imports an individual property and adds it to an entry.

   841 @param aEntry The entry to which the property is to be added.

   842 @param aProperty The property to add.

   843 @internalTechnology

   844 */

   845 void CAgnVersit2Importer::ImportPropertyL(CCalEntry& aEntry, const CICalProperty& aProperty)

   846 	{

   847 	TRACE_ENTRY_POINT;

   848 	

   849 	if (aProperty.Type().CompareF(KICalAttendee) == 0)

   850 		{

   851 		// Find the paramaters we need:

   852 		CICalValue* address = aProperty.Values()[0];

   853 		const CICalPropertyParam* sentBy = aProperty.FindParam(KICalSentBy);

   854 		const CICalPropertyParam* role = aProperty.FindParam(KICalRole);

   855 		const CICalPropertyParam* status = aProperty.FindParam(KICalPartStat);

   856 		const CICalPropertyParam* rsvp = aProperty.FindParam(KICalRsvp);

   857 		const CICalPropertyParam* cn = aProperty.FindParam(KICalCn);

   858 		// The role:

   859 		CCalAttendee::TCalRole roleVal = CCalAttendee::EReqParticipant;

   860 		if (role && role->Values().Count() > 0)

   861 			{

   862 			CICalValue* theVal = role->Values()[0];

   863 			if (theVal->TextL().CompareF(KICalChair) == 0)

   864 				{

   865 				roleVal = CCalAttendee::EChair;

   866 				}

   867 			else if (theVal->TextL().CompareF(KICalOptParticipant) == 0)

   868 				{

   869 				roleVal = CCalAttendee::EOptParticipant;

   870 				}

   871 			else if (theVal->TextL().CompareF(KICalNonParticipant) == 0)

   872 				{

   873 				roleVal = CCalAttendee::ENonParticipant;

   874 				}

   875 

   876 			}

   877 		// The status:

   878 		CCalAttendee::TCalStatus statusVal = CCalAttendee::ENeedsAction;

   879 		if (status && status->Values().Count() > 0)

   880 			{

   881 			CICalValue* theVal = status->Values()[0];

   882 			if (theVal->TextL().CompareF(KICalAccepted) == 0)

   883 				{

   884 				statusVal = CCalAttendee::EAccepted;

   885 				}

   886 			else if (theVal->TextL().CompareF(KICalDeclined) == 0)

   887 				{

   888 				statusVal = CCalAttendee::EDeclined;

   889 				}

   890 			else if (theVal->TextL().CompareF(KICalTentative) == 0)

   891 				{

   892 				statusVal = CCalAttendee::ETentative;

   893 				}

   894 			else if (theVal->TextL().CompareF(KICalDelegated) == 0)

   895 				{

   896 				statusVal = CCalAttendee::EDelegated;

   897 				}

   898 			else if (theVal->TextL().CompareF(KICalCompleted) == 0)

   899 				{

   900 				statusVal = CCalAttendee::ECompleted;

   901 				}

   902 			else if (theVal->TextL().CompareF(KICalInProcess) == 0)

   903 				{

   904 				statusVal = CCalAttendee::EInProcess;

   905 				}

   906 			}

   907 		// The RSVP:

   908 		TBool rsvpVal = EFalse;

   909 		if (rsvp && rsvp->Values().Count() > 0)

   910 			{

   911 			rsvpVal = rsvp->Values()[0]->BooleanL();

   912 			}

   913 

   914 		// The complete attendee:

   915 		CCalAttendee* attendee;

   916 		if (sentBy && sentBy->Values().Count() > 0)

   917 			{

   918 			attendee = CCalAttendee::NewL(address->TextL(), sentBy->Values()[0]->TextL());

   919 			}

   920 		else

   921 			{

   922 			attendee = CCalAttendee::NewL(address->TextL());

   923 			}

   924 		CleanupStack::PushL(attendee);

   925 		if (cn && cn->Values().Count() > 0)

   926 			{

   927 			attendee->SetCommonNameL(cn->Values()[0]->TextL());

   928 			}

   929 		attendee->SetRoleL(roleVal);

   930 		attendee->SetStatusL(statusVal);

   931 		attendee->SetResponseRequested(rsvpVal);

   932 		// Add the attendee:

   933 		CleanupStack::Pop(attendee);

   934 		// Passing ownership of attendee

   935 		aEntry.AddAttendeeL(attendee);

   936 		}

   937 	else if (aProperty.Type().CompareF(KICalCategories) == 0)

   938 		{

   939 		ImportCategoriesL(aProperty, aEntry);

   940 		}

   941 	else if (aProperty.Type().CompareF(KICalClass) == 0)

   942 		{

   943 		ImportClassL(aProperty, aEntry);

   944 		}

   945 	else if (aProperty.Type().CompareF(KICalDescription) == 0)

   946 		{

   947 		if (aProperty.Values().Count() < 1)

   948 			{

   949 			ReportErrorL(MAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalDescription);

   950 			// On continue ignore the description.

   951 			}

   952 		else

   953 			{

   954 			aEntry.SetDescriptionL(aProperty.Values()[0]->TextL());

   955 			}

   956 		}

   957 	else if (aProperty.Type().CompareF(KICalLocation) == 0)

   958 		{

   959 		// CCalEntry only supports one location, so bundle them all

   960 		// together into one descriptor.

   961 		TInt numLocations = aProperty.Values().Count();

   962 

   963 		if (numLocations > 0)

   964 			{

   965 			HBufC* loc (aProperty.Values()[0]->TextL().AllocLC());

   966 

   967 			for (TInt i = 1; i < numLocations; i++)

   968 				{

   969 				HBufC* oldLoc = loc;

   970 				loc = loc->ReAllocL(loc->Length() + aProperty.Values()[i]->TextL().Length() + 1);

   971 				CleanupStack::Pop(oldLoc); // location of loc has changed, cleanupstack needs updating

   972 				CleanupStack::PushL(loc);

   973 				loc->Des().Append(KICalComma);

   974 				loc->Des().Append(aProperty.Values()[i]->TextL());

   975 				}

   976 

   977 			aEntry.SetLocationL(*loc);

   978 			CleanupStack::PopAndDestroy(loc);

   979 			}

   980 		}

   981 	else if (aProperty.Type().CompareF(KICalOrganizer) == 0)

   982 		{

   983 		if (aProperty.Values().Count() < 1)

   984 			{

   985 			ReportErrorL(MAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalOrganizer);

   986 			// On continue ignore the organizer.

   987 			}

   988 		else

   989 			{

   990 			CICalValue* address = aProperty.Values()[0];

   991 			const CICalPropertyParam* sentBy = aProperty.FindParam(KICalSentBy);

   992 			const CICalPropertyParam* cn = aProperty.FindParam(KICalCn);

   993 			CCalUser* user = NULL;

   994 			if (sentBy && sentBy->Values().Count() > 0)

   995 				{

   996 				user = CCalAttendee::NewL(address->TextL(), sentBy->Values()[0]->TextL());

   997 				}

   998 			else

   999 				{

  1000 				user = CCalAttendee::NewL(address->TextL());

  1001 				}

  1002 			CleanupStack::PushL(user);

  1003 			if (cn && cn->Values().Count() > 0)

  1004 				{

  1005 				user->SetCommonNameL(cn->Values()[0]->TextL());

  1006 				}

  1007 			CleanupStack::Pop(user);

  1008 			// Passing ownership of user

  1009 			aEntry.SetOrganizerL(user);

  1010 			}

  1011 		}

  1012 	else if (aProperty.Type().CompareF(KICalRdate) == 0)

  1013 		{

  1014 		iNeedsTzRules = ETrue;

  1015 		RArray<TCalTime> dates;

  1016 		CleanupClosePushL(dates);

  1017 		aEntry.GetRDatesL(dates);

  1018 		TInt valCount = aProperty.Values().Count();

  1019 		for (TInt dnum = 0; dnum < valCount; ++dnum)

  1020 			{

  1021 			TCalTime time;

  1022 			GetCalTimeL(aProperty, time, EDateTime, dnum);

  1023 			User::LeaveIfError(dates.Append(time));

  1024 			}

  1025 		aEntry.SetRDatesL(dates);

  1026 		CleanupStack::PopAndDestroy(&dates);

  1027 		}

  1028 	else if (aProperty.Type().CompareF(KICalExdate) == 0)

  1029 		{

  1030 		iNeedsTzRules = ETrue;

  1031 		RArray<TCalTime> dates;

  1032 		CleanupClosePushL(dates);

  1033 		aEntry.GetExceptionDatesL(dates);

  1034 		TInt valCount = aProperty.Values().Count();

  1035 		for (TInt dnum = 0; dnum < valCount; ++dnum)

  1036 			{

  1037 			TCalTime time;

  1038 			GetCalTimeL(aProperty, time, EDateTime, dnum);

  1039 			User::LeaveIfError(dates.Append(time));

  1040 			}

  1041 		aEntry.SetExceptionDatesL(dates);

  1042 		CleanupStack::PopAndDestroy(&dates);

  1043 		}

  1044 	else if (aProperty.Type().CompareF(KICalStatus) == 0)

  1045 		{

  1046 		if (aProperty.Values().Count() < 1)

  1047 			{

  1048 			ReportErrorL(MAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalDescription);

  1049 			// On continue ignore the status.

  1050 			}

  1051 		else

  1052 			{

  1053 			TPtrC statstr(aProperty.Values()[0]->TextL());

  1054 			if (statstr.CompareF(KICalTentative) == 0)

  1055 				{

  1056 				aEntry.SetStatusL(CCalEntry::ETentative);

  1057 				}

  1058 			else if (statstr.CompareF(KICalConfirmed) == 0)

  1059 				{

  1060 				aEntry.SetStatusL(CCalEntry::EConfirmed);

  1061 				}

  1062 			else if (statstr.CompareF(KICalCancelled) == 0)

  1063 				{

  1064 				aEntry.SetStatusL(CCalEntry::ECancelled);

  1065 				}

  1066 			else if (statstr.CompareF(KICalNeedsAction) == 0)

  1067 				{

  1068 				aEntry.SetStatusL(CCalEntry::ETodoNeedsAction);

  1069 				}

  1070 			else if (statstr.CompareF(KICalCompleted) == 0)

  1071 				{

  1072 				aEntry.SetStatusL(CCalEntry::ETodoCompleted);

  1073 				}

  1074 			else if (statstr.CompareF(KICalInProcess) == 0)

  1075 				{

  1076 				aEntry.SetStatusL(CCalEntry::ETodoInProcess);

  1077 				}

  1078 			else

  1079 				{

  1080 				ReportErrorL(MAgnImportObserver::EImpErrorNotSupported, aEntry.UidL(), statstr);

  1081 				// On continue ignore the status.

  1082 				}

  1083 			}

  1084 		}

  1085 	else if (aProperty.Type().CompareF(KICalSummary) == 0)

  1086 		{

  1087 		if (aProperty.Values().Count() < 1)

  1088 			{

  1089 			ReportErrorL(MAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalDescription);

  1090 			// On continue ignore the summary.

  1091 			}

  1092 		else

  1093 			{

  1094 			aEntry.SetSummaryL(aProperty.Values()[0]->TextL());

  1095 			}

  1096 		}

  1097 	else if (aProperty.Type().CompareF(KICalPriority) == 0)

  1098 		{

  1099 		if (aProperty.Values().Count() < 1)

  1100 			{

  1101 			ReportErrorL(MAgnImportObserver::EImpErrorMissingData, aEntry.UidL(), KICalDescription);

  1102 			// On continue ignore the priority.

  1103 			}

  1104 		else

  1105 			{

  1106 			TInt priority = aProperty.Values()[0]->IntegerL();

  1107 			

  1108 		    //Pirorites are saved always in vcal format

  1109 		    //so they are mapped the following way

  1110 		    //iCal 1 - 4 = vCal 1

  1111 		    //iCal 5     = vCal 2

  1112 		    //iCal 6 - 9 = vCal 3

  1113 			if( priority < 5 )

  1114 			    {

  1115 			    priority = 1;

  1116 			    }

  1117 			

  1118 			else if( priority == 5 )

  1119 			    {

  1120 			    priority = 2;

  1121 			    }

  1122 			

  1123 			else 

  1124 			    {

  1125 			    priority = 3;

  1126 			    }

  1127 			    

  1128 			aEntry.SetPriorityL( priority );

  1129 			}

  1130 		}

  1131 

  1132 	else if (aProperty.Type().CompareF(KICalDtstamp) == 0)

  1133 		{

  1134 		TCalTime timeStamp;