|
1 /* |
|
2 * Copyright (c) 2007-2009 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: ESMR mrinfo calendar entry retriever implementation |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include "emailtrace.h" |
|
20 #include "cesmrmrinfoicalretriever.h" |
|
21 #include "cesmrinforecurrencehandler.h" |
|
22 #include "mesmricalviewerobserver.h" |
|
23 #include "tesmrinputparams.h" |
|
24 #include "esmricalviewerutils.h" |
|
25 #include "esmrconfig.hrh" |
|
26 |
|
27 //<cmail> |
|
28 #include "esmricalvieweropcodes.hrh" |
|
29 #include "cfsmailclient.h" |
|
30 #include "cfsmailbox.h" |
|
31 #include "cfsmailmessage.h" |
|
32 #include "cfsmailmessagepart.h" |
|
33 #include "cfsmailcommon.h" |
|
34 #include "mmrinfoprocessor.h" |
|
35 #include "mmrattendee.h" |
|
36 #include "mmrrecurrencerule.h" |
|
37 //</cmail> |
|
38 |
|
39 #include <calentry.h> |
|
40 #include <caluser.h> |
|
41 #include <calalarm.h> |
|
42 #include <CalenInterimUtils2.h> |
|
43 #include <utf.h> |
|
44 |
|
45 // Unnamed namespace for local definitions and functions |
|
46 namespace { |
|
47 |
|
48 /** |
|
49 * Raises system leave if parameter is different than KErrNone. |
|
50 * |
|
51 * @param aError Error code |
|
52 */ |
|
53 void LeaveIfError( TInt aError ) |
|
54 { |
|
55 if ( KErrNone != aError ) |
|
56 { |
|
57 |
|
58 User::Leave( aError ); |
|
59 } |
|
60 } |
|
61 |
|
62 /** |
|
63 * Tests if certain field is supported by MRINFO object. |
|
64 * @param aFields Reference to MRINFO fields' |
|
65 * @param aFieldType Tested fieldtype |
|
66 */ |
|
67 TBool IsFieldSupported( |
|
68 RArray<MMRInfoObject::TESMRInfoField>& aFields, |
|
69 MMRInfoObject::TESMRInfoField aFieldType) |
|
70 { |
|
71 TInt fieldSupported( ETrue ); |
|
72 |
|
73 TInt fieldCount( aFields.Count() ); |
|
74 for (TInt i=0; i < fieldCount; ++i) |
|
75 { |
|
76 if (aFields[i] == aFieldType) |
|
77 { |
|
78 fieldSupported = ETrue; |
|
79 break; |
|
80 } |
|
81 } |
|
82 return fieldSupported; |
|
83 } |
|
84 |
|
85 /** |
|
86 * Converts MRINFO method to CCalEntry method. |
|
87 * @param aMRMethod MRINFO method. |
|
88 * @return CCalEntry method. |
|
89 */ |
|
90 CCalEntry::TMethod ConverMRMethodToCalEntryMethod( |
|
91 MMRInfoObject::TMRMethod aMRMethod ) |
|
92 { |
|
93 CCalEntry::TMethod ret(CCalEntry::EMethodNone); |
|
94 switch (aMRMethod) |
|
95 { |
|
96 case MMRInfoObject::EMRMethodRequest: |
|
97 { |
|
98 ret = CCalEntry::EMethodRequest; |
|
99 break; |
|
100 } |
|
101 case MMRInfoObject::EMRMethodCancel: |
|
102 { |
|
103 ret = CCalEntry::EMethodCancel; |
|
104 break; |
|
105 } |
|
106 case MMRInfoObject::EMRMethodResponse: |
|
107 { |
|
108 ret = CCalEntry::EMethodReply; |
|
109 break; |
|
110 } |
|
111 default: |
|
112 break; |
|
113 } |
|
114 return ret; |
|
115 } |
|
116 |
|
117 /** |
|
118 * Converts MMRINFO response status to CCalEntry response status. |
|
119 * @param aMRResponseStatus MRINFO response status. |
|
120 * @return CCalEntry response status. |
|
121 */ |
|
122 CCalEntry::TStatus ConvertMRResponseToCalEntryStatus( |
|
123 MMRInfoObject::TResponse aMRResponseStatus ) |
|
124 { |
|
125 FUNC_LOG; |
|
126 CCalEntry::TStatus ret(CCalEntry::ENullStatus); |
|
127 switch (aMRResponseStatus) |
|
128 { |
|
129 case MMRInfoObject::EMrCmdResponseAccept: |
|
130 { |
|
131 ret = CCalEntry::EConfirmed; |
|
132 break; |
|
133 } |
|
134 case MMRInfoObject::EMrCmdResponseTentative: |
|
135 { |
|
136 ret = CCalEntry::ETentative; |
|
137 break; |
|
138 } |
|
139 case MMRInfoObject::EMrCmdResponseDecline: |
|
140 { |
|
141 ret = CCalEntry::ECancelled; |
|
142 break; |
|
143 } |
|
144 default: |
|
145 break; |
|
146 } |
|
147 return ret; |
|
148 } |
|
149 |
|
150 /** |
|
151 * Converts MRINFO attendee role to MRINFO attendee role. |
|
152 * @param aMRRole MRINFO attendee role. |
|
153 * @return CCalEntry attendee role. |
|
154 */ |
|
155 CCalAttendee::TCalRole ConvertMRAttendeeRoleToCalEntryRole( |
|
156 MMRAttendee::TAttendeeRole aMRRole) |
|
157 { |
|
158 CCalAttendee::TCalRole ret(CCalAttendee::ENonParticipant); |
|
159 switch (aMRRole) |
|
160 { |
|
161 case MMRAttendee::EMRAttendeeNotSet: |
|
162 { |
|
163 ret = CCalAttendee::ENonParticipant; |
|
164 break; |
|
165 } |
|
166 case MMRAttendee::EMRAttendeeChair: |
|
167 { |
|
168 ret = CCalAttendee::EChair; |
|
169 break; |
|
170 } |
|
171 case MMRAttendee::EMRAttendeeParticipant: |
|
172 { |
|
173 ret = CCalAttendee::EReqParticipant; |
|
174 break; |
|
175 } |
|
176 case MMRAttendee::EMRAttendeeOptionalParticipant: |
|
177 { |
|
178 ret = CCalAttendee::EOptParticipant; |
|
179 break; |
|
180 } |
|
181 case MMRAttendee::EMRAttendeeNonParticipant: |
|
182 { |
|
183 ret = CCalAttendee::ENonParticipant; |
|
184 break; |
|
185 } |
|
186 default: |
|
187 break; |
|
188 } |
|
189 return ret; |
|
190 } |
|
191 |
|
192 /** |
|
193 * Converts MMRINFO response status to CCalEntry response status. |
|
194 * @param aMRStatus MRINFO response status. |
|
195 * @return CCalEntry response status. |
|
196 */ |
|
197 CCalAttendee::TCalStatus ConvertMRAttendeeStatusToCalEntryStatus( |
|
198 MMRAttendee::TAttendeeStatus aMRStatus ) |
|
199 { |
|
200 FUNC_LOG; |
|
201 CCalAttendee::TCalStatus ret(CCalAttendee::ENeedsAction); |
|
202 switch (aMRStatus) |
|
203 { |
|
204 case MMRAttendee::EMRAttendeeActionNotSet: |
|
205 { |
|
206 ret = CCalAttendee::ENeedsAction; |
|
207 break; |
|
208 } |
|
209 case MMRAttendee::EMRAttendeeActionNeeded: |
|
210 { |
|
211 ret = CCalAttendee::ENeedsAction; |
|
212 break; |
|
213 } |
|
214 case MMRAttendee::EMRAttendeeActionAccepted: |
|
215 { |
|
216 ret = CCalAttendee::EAccepted; |
|
217 break; |
|
218 } |
|
219 case MMRAttendee::EMRAttendeeActionTentative: |
|
220 { |
|
221 ret = CCalAttendee::ETentative; |
|
222 break; |
|
223 } |
|
224 case MMRAttendee::EMRAttendeeActionConfirmed: |
|
225 { |
|
226 ret = CCalAttendee::EConfirmed; |
|
227 break; |
|
228 } |
|
229 case MMRAttendee::EMRAttendeeActionDeclined: |
|
230 { |
|
231 ret = CCalAttendee::EDeclined; |
|
232 break; |
|
233 } |
|
234 case MMRAttendee::EMRAttendeeActionCompleted: |
|
235 { |
|
236 ret = CCalAttendee::ECompleted; |
|
237 break; |
|
238 } |
|
239 default: |
|
240 break; |
|
241 } |
|
242 return ret; |
|
243 } |
|
244 |
|
245 /** |
|
246 * Copies attendees from MRINFO object to CCalEntry object. |
|
247 * @param attendeesArray array of meeting request attendees |
|
248 * @param calendar entry of the meeting request |
|
249 */ |
|
250 void FillAttendeesL( |
|
251 RPointerArray<MMRAttendee>& attendeesArray, |
|
252 CCalEntry& aEntry) |
|
253 { |
|
254 |
|
255 CCalAttendee* attendee = NULL; |
|
256 TInt attendeeArrayCount( attendeesArray.Count() ); |
|
257 for (TInt i=0; i < attendeeArrayCount; ++i) |
|
258 { |
|
259 // New attendee + address |
|
260 attendee = CCalAttendee::NewL( attendeesArray[i]->Address() ); |
|
261 CleanupStack::PushL(attendee); |
|
262 // Common name: |
|
263 if ( attendeesArray[i]->CommonName().Length() > 0 ) |
|
264 { |
|
265 attendee->SetCommonNameL( attendeesArray[i]->CommonName() ); |
|
266 } |
|
267 |
|
268 // Set attendeee role: |
|
269 attendee->SetRoleL( |
|
270 ConvertMRAttendeeRoleToCalEntryRole( |
|
271 attendeesArray[i]->AttendeeRole() ) ); |
|
272 |
|
273 // add attendee status: |
|
274 attendee->SetStatusL( |
|
275 ConvertMRAttendeeStatusToCalEntryStatus( |
|
276 attendeesArray[i]->AttendeeStatus() ) ); |
|
277 |
|
278 // add attendee to entry |
|
279 aEntry.AddAttendeeL( attendee ); |
|
280 CleanupStack::Pop(attendee); |
|
281 } |
|
282 } |
|
283 |
|
284 /** |
|
285 * Tests if MRINFO object is modifying entry |
|
286 * @param aEntry Reference to MRINFO object. |
|
287 */ |
|
288 TBool IsModifyingEntryL( |
|
289 MMRInfoObject& aEntry ) |
|
290 { |
|
291 TBool modifying( EFalse ); |
|
292 TTime recurrenceId = aEntry.MRRecurrenceId(); |
|
293 |
|
294 if ( recurrenceId != Time::NullTTime() ) |
|
295 { |
|
296 modifying = ETrue; |
|
297 } |
|
298 |
|
299 return modifying; |
|
300 } |
|
301 |
|
302 }//namespace |
|
303 |
|
304 // ======== MEMBER FUNCTIONS ======== |
|
305 |
|
306 // --------------------------------------------------------------------------- |
|
307 // CESMRInfoIcalRetrieverCmd::CESMRInfoIcalRetrieverCmd |
|
308 // --------------------------------------------------------------------------- |
|
309 // |
|
310 CESMRInfoIcalRetrieverCmd::CESMRInfoIcalRetrieverCmd( |
|
311 CCalSession& aCalSession, |
|
312 TESMRInputParams& aInputParameters ) |
|
313 : CESMRIcalViewerCommandBase( EESMRLoadMRInfoData, aCalSession ), |
|
314 iInputParameters( aInputParameters ) |
|
315 { |
|
316 FUNC_LOG; |
|
317 //do nothing |
|
318 } |
|
319 |
|
320 // --------------------------------------------------------------------------- |
|
321 // CESMRInfoIcalRetrieverCmd::~CESMRInfoIcalRetrieverCmd |
|
322 // --------------------------------------------------------------------------- |
|
323 // |
|
324 CESMRInfoIcalRetrieverCmd::~CESMRInfoIcalRetrieverCmd() |
|
325 { |
|
326 FUNC_LOG; |
|
327 iSupportedFields.Reset(); |
|
328 iSupportedFields.Close(); |
|
329 delete iConvertedEntry; |
|
330 } |
|
331 |
|
332 // --------------------------------------------------------------------------- |
|
333 // CESMRInfoIcalRetriever::NewL |
|
334 // --------------------------------------------------------------------------- |
|
335 // |
|
336 CESMRInfoIcalRetrieverCmd* CESMRInfoIcalRetrieverCmd::NewL( |
|
337 CCalSession& aCalSession, |
|
338 TESMRInputParams& aInputParameters ) |
|
339 { |
|
340 FUNC_LOG; |
|
341 CESMRInfoIcalRetrieverCmd* self = |
|
342 new (ELeave) CESMRInfoIcalRetrieverCmd( aCalSession, aInputParameters ); |
|
343 CleanupStack::PushL( self ); |
|
344 self->ConstructL(); |
|
345 CleanupStack::Pop( self ); |
|
346 return self; |
|
347 } |
|
348 |
|
349 // --------------------------------------------------------------------------- |
|
350 // CESMRInfoIcalRetrieverCmd::ConstructL |
|
351 // --------------------------------------------------------------------------- |
|
352 // |
|
353 void CESMRInfoIcalRetrieverCmd::ConstructL() |
|
354 { |
|
355 FUNC_LOG; |
|
356 //do nothing |
|
357 } |
|
358 |
|
359 // --------------------------------------------------------------------------- |
|
360 // CESMRInfoIcalRetriever::ExecuteCommandL |
|
361 // --------------------------------------------------------------------------- |
|
362 // |
|
363 void CESMRInfoIcalRetrieverCmd::ExecuteCommandL( |
|
364 CFSMailMessage& aMessage, |
|
365 MESMRIcalViewerObserver& aObserver ) |
|
366 { |
|
367 FUNC_LOG; |
|
368 SetMessage( &aMessage ); |
|
369 SetObserver( &aObserver ); |
|
370 |
|
371 iResult.iOpType = OperationType(); |
|
372 iResult.iResultCode = KErrNone; |
|
373 iResult.iMessage = &aMessage; |
|
374 |
|
375 // Fetch MRINFO object |
|
376 if ( !aMessage.IsMRInfoSet() ) |
|
377 { |
|
378 iResult.iResultCode = KErrNotFound; |
|
379 aObserver.OperationError( iResult ); |
|
380 } |
|
381 else |
|
382 { |
|
383 iMRInfoObject = &(aMessage.GetMRInfo()); |
|
384 |
|
385 CreateEntryL(); |
|
386 FillCommonFieldsL(); |
|
387 |
|
388 if ( !IsModifyingEntryL( *iMRInfoObject ) ) |
|
389 { |
|
390 FillRecurrenceL(); |
|
391 } |
|
392 |
|
393 // Fill input parameters |
|
394 // Ownership is not trasferred |
|
395 iInputParameters.iCalEntry = iConvertedEntry; |
|
396 |
|
397 iInputParameters.iMRInfoObject = iMRInfoObject; |
|
398 iMRInfoObject = NULL; |
|
399 |
|
400 aObserver.OperationCompleted( iResult ); |
|
401 } |
|
402 } |
|
403 |
|
404 // --------------------------------------------------------------------------- |
|
405 // CESMRInfoIcalRetrieverCmd::CancelCommand |
|
406 // --------------------------------------------------------------------------- |
|
407 // |
|
408 void CESMRInfoIcalRetrieverCmd::CancelCommand() |
|
409 { |
|
410 FUNC_LOG; |
|
411 // No implementation required because this is synchronous command |
|
412 } |
|
413 |
|
414 // --------------------------------------------------------------------------- |
|
415 // CESMRInfoIcalRetrieverCmd::CreateEntryL |
|
416 // --------------------------------------------------------------------------- |
|
417 // |
|
418 void CESMRInfoIcalRetrieverCmd::CreateEntryL() |
|
419 { |
|
420 FUNC_LOG; |
|
421 iMRInfoObject->SupportedFields( iSupportedFields ); |
|
422 |
|
423 HBufC8* uid8 = NULL; // buffer for UID |
|
424 TInt seqNum(0); // Sequence Number |
|
425 CCalEntry::TMethod method( CCalEntry::EMethodNone ); // Method |
|
426 |
|
427 // fetch the UID |
|
428 if (IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldId)) |
|
429 { |
|
430 // CnvUtfConverter |
|
431 TPtrC uid16( iMRInfoObject->UidL() ); |
|
432 uid8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L( uid16 ); |
|
433 |
|
434 CleanupStack::PushL( uid8 ); |
|
435 } |
|
436 else |
|
437 { |
|
438 User::Leave( KErrCorrupt ); |
|
439 } |
|
440 |
|
441 // Fetch the sequence nunber |
|
442 if (IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldSeqNo)) |
|
443 { |
|
444 seqNum = iMRInfoObject->MRSequenceNumberL(); |
|
445 } |
|
446 |
|
447 // Fetch the method |
|
448 if ( IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldMethod) ) |
|
449 { |
|
450 MMRInfoObject::TMRMethod mrMethod = iMRInfoObject->MRMethodL(); |
|
451 method = ConverMRMethodToCalEntryMethod(mrMethod); |
|
452 if (method == CCalEntry::EMethodNone) |
|
453 { |
|
454 LeaveIfError( KErrCorrupt ); |
|
455 } |
|
456 } |
|
457 else |
|
458 { |
|
459 LeaveIfError( KErrCorrupt ); |
|
460 } |
|
461 |
|
462 // create new entry: |
|
463 delete iConvertedEntry; iConvertedEntry = NULL; |
|
464 |
|
465 if ( !IsModifyingEntryL( *iMRInfoObject ) ) |
|
466 { |
|
467 iConvertedEntry = CCalEntry::NewL (CCalEntry::EAppt, |
|
468 uid8, |
|
469 method, |
|
470 seqNum ); |
|
471 } |
|
472 else |
|
473 { |
|
474 TBool seqNoSupported( |
|
475 IsFieldSupported( iSupportedFields, MMRInfoObject::EESMRInfoFieldSeqNo ) ); |
|
476 |
|
477 if( !seqNoSupported ) |
|
478 { |
|
479 LeaveIfError( KErrCorrupt ); |
|
480 } |
|
481 |
|
482 TInt seqwNo( iMRInfoObject->MRSequenceNumberL() ); |
|
483 TCalTime recurrenceID; |
|
484 recurrenceID.SetTimeLocalL( iMRInfoObject->MRRecurrenceId() ); |
|
485 |
|
486 iConvertedEntry = CCalEntry::NewL( |
|
487 CCalEntry::EAppt, |
|
488 uid8, |
|
489 method, |
|
490 seqwNo, |
|
491 recurrenceID, |
|
492 CalCommon::EThisOnly ); |
|
493 } |
|
494 |
|
495 CleanupStack::Pop(uid8 ); |
|
496 } |
|
497 |
|
498 // --------------------------------------------------------------------------- |
|
499 // CESMRInfoIcalRetrieverCmd::FillCommonFieldsL |
|
500 // --------------------------------------------------------------------------- |
|
501 // |
|
502 void CESMRInfoIcalRetrieverCmd::FillCommonFieldsL() |
|
503 { |
|
504 FUNC_LOG; |
|
505 if (IsFieldSupported( |
|
506 iSupportedFields, |
|
507 MMRInfoObject::EESMRInfoFieldMStatus)) |
|
508 { |
|
509 CCalEntry::TStatus status = |
|
510 ConvertMRResponseToCalEntryStatus(iMRInfoObject->MRResponse()); |
|
511 iConvertedEntry->SetStatusL(status); |
|
512 } |
|
513 |
|
514 if (IsFieldSupported( |
|
515 iSupportedFields, |
|
516 MMRInfoObject::EESMRInfoFieldCreationDateTime)) |
|
517 { |
|
518 TTime creationTime = iMRInfoObject->CreationTimeInUtcL(); |
|
519 iConvertedEntry->SetLastModifiedDateL(); |
|
520 } |
|
521 |
|
522 if (IsFieldSupported( |
|
523 iSupportedFields, |
|
524 MMRInfoObject::EESMRInfoFieldOrganizer)) |
|
525 { |
|
526 MMROrganizer* mrOrganizer = &iMRInfoObject->MROrganizerL(); |
|
527 CCalUser* organizer = CCalUser::NewL(mrOrganizer->Address()); |
|
528 CleanupStack::PushL(organizer); |
|
529 if ( mrOrganizer->CommonName().Length() > 0 ) |
|
530 { |
|
531 organizer->SetCommonNameL(mrOrganizer->CommonName()); |
|
532 } |
|
533 |
|
534 iConvertedEntry->SetOrganizerL(organizer); |
|
535 CleanupStack::Pop(organizer); |
|
536 } |
|
537 |
|
538 if (IsFieldSupported( |
|
539 iSupportedFields, MMRInfoObject::EESMRInfoFieldAttendee) || |
|
540 IsFieldSupported( |
|
541 iSupportedFields, MMRInfoObject::EESMRInfoFieldOptAttendee) ) |
|
542 { |
|
543 RPointerArray<MMRAttendee> attendeesArray = iMRInfoObject->AttendeesL(); |
|
544 // go through attendee array and append attendees |
|
545 FillAttendeesL(attendeesArray, *iConvertedEntry ); |
|
546 } |
|
547 |
|
548 if (IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldStartDateTime) && |
|
549 IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldStopDateTime) ) |
|
550 { |
|
551 TTime start = iMRInfoObject->StartTimeInUtcL(); |
|
552 TTime end = iMRInfoObject->EndTimeInUtcL(); |
|
553 TCalTime calStart; |
|
554 calStart.SetTimeUtcL(start); |
|
555 TCalTime calEnd; |
|
556 calEnd.SetTimeUtcL(end); |
|
557 iConvertedEntry->SetStartAndEndTimeL(calStart, calEnd); |
|
558 } |
|
559 |
|
560 |
|
561 if (IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldLocation)) |
|
562 { |
|
563 TPtrC location( iMRInfoObject->LocationL() ); |
|
564 iConvertedEntry->SetLocationL( location ); |
|
565 } |
|
566 |
|
567 if ( IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldStartDateTime) && |
|
568 IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldAlarm)) |
|
569 { |
|
570 CCalAlarm* alarm = CCalAlarm::NewL(); |
|
571 CleanupStack::PushL( alarm ); |
|
572 |
|
573 TTime start = iMRInfoObject->StartTimeInUtcL(); |
|
574 TTime alarmTime = iMRInfoObject->AlarmInUtcL(); |
|
575 |
|
576 TDateTime startDateTime = start.DateTime(); |
|
577 TDateTime alarmDateTime = alarmTime.DateTime(); |
|
578 |
|
579 TTimeIntervalMinutes minutesBetween; |
|
580 TInt err = start.MinutesFrom(alarmTime, minutesBetween); |
|
581 |
|
582 if ( KErrNone == err && minutesBetween.Int() > 0 ) |
|
583 { |
|
584 alarm->SetTimeOffset( minutesBetween ); |
|
585 // this method copies alarm details and does not take ownership |
|
586 iConvertedEntry->SetAlarmL( alarm ); |
|
587 } |
|
588 // that's why we can destroy it here |
|
589 CleanupStack::PopAndDestroy( alarm ); |
|
590 } |
|
591 |
|
592 if (IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldSubject)) |
|
593 { |
|
594 TPtrC summary( iMRInfoObject->SubjectL() ); |
|
595 iConvertedEntry->SetSummaryL(summary); |
|
596 } |
|
597 |
|
598 if (IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldDescription)) |
|
599 { |
|
600 TPtrC description( iMRInfoObject->DescriptionL() ); |
|
601 iConvertedEntry->SetDescriptionL(description); |
|
602 } |
|
603 |
|
604 if (IsFieldSupported(iSupportedFields, MMRInfoObject::EESMRInfoFieldPriority)) |
|
605 { |
|
606 iConvertedEntry->SetPriorityL( iMRInfoObject->PriorityL() ); |
|
607 } |
|
608 } |
|
609 |
|
610 // --------------------------------------------------------------------------- |
|
611 // CESMRInfoIcalRetrieverCmd::FillCommonFieldsL |
|
612 // --------------------------------------------------------------------------- |
|
613 // |
|
614 void CESMRInfoIcalRetrieverCmd::FillRecurrenceL() |
|
615 { |
|
616 FUNC_LOG; |
|
617 if (IsFieldSupported( |
|
618 iSupportedFields, |
|
619 MMRInfoObject::EESMRInfoFieldRecurrence)) |
|
620 { |
|
621 CESMRInfoRecurrenceHandler* recurrenceHandler = |
|
622 CESMRInfoRecurrenceHandler::NewLC(); |
|
623 |
|
624 recurrenceHandler->ParseRecurrenceInforationL( |
|
625 *iConvertedEntry, |
|
626 *iMRInfoObject ); |
|
627 |
|
628 CleanupStack::PopAndDestroy( recurrenceHandler ); |
|
629 } |
|
630 } |
|
631 |
|
632 // EOF |
|
633 |