diff -r f5050f1da672 -r 04becd199f91 javaextensions/pim/agnadapter/src.s60/cpimagneventadapter.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javaextensions/pim/agnadapter/src.s60/cpimagneventadapter.cpp	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,791 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  Base class for PIM Event item adapters
+ *
+*/
+
+
+// CLASS HEADER
+#include "cpimagneventadapter.h"
+
+// INTERNAL INCLUDES
+#include "pimcommon.h"
+#include "agneventsupport.h"
+#include "cpimrepeatrule.h"
+#include "pimrepeatruleconverter.h"
+#include "mpimitemdata.h"
+#include "mpimeventitem.h"
+#include "pimpanics.h"
+#include "logger.h"
+
+// EXTERNAL INCLUDES
+#include <calentryview.h>
+#include <calalarm.h>
+#include <calrrule.h>
+
+
+// UNNAMED LOCAL NAMESPACE
+namespace
+{
+const TInt KPIMSecondsInMinute = 60;
+// Alarm offset for TTime in seconds from the start of the date. This is
+// the default alarm value which is set to the item if the user defined
+// alarm value is too small (meaning that it has been passed to the next
+// day when start of the event occurs
+const TInt KPIMDefaultAlarmInterval = 43200;
+}
+
+// LOCAL FUNCTION PROTOTYPES
+void CopyExceptionDatesToAgnL(const MPIMRepeatRuleData& aPimRepeatRuleData,
+                              CCalEntry& aAgnEntry);
+
+void CopyExceptionDatesToPimL(const CCalEntry& aAgnEntry,
+                              MPIMRepeatRuleData& aPimRepeatRuleData);
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CopyExceptionDatesToAgnL
+// Copies PIM API exception dates to an Agenda entry.
+// Returns: void
+// -----------------------------------------------------------------------------
+//
+void CopyExceptionDatesToAgnL(const MPIMRepeatRuleData& aPimRepeatRuleData,
+                              CCalEntry& aAgnEntry)
+{
+    JELOG2(EPim);
+    RArray<TCalTime> agnExceptionDates;
+    CleanupClosePushL(agnExceptionDates);
+    const CArrayFix<TPIMDate>& pimExceptionDates =
+        aPimRepeatRuleData.GetExceptDatesL();
+    const TInt numExceptDates = pimExceptionDates.Count();
+    TCalTime agnExceptionDate;
+    for (TInt i = 0; i < numExceptDates; i++)
+    {
+        agnExceptionDate.SetTimeUtcL(pimExceptionDates[i]);
+        User::LeaveIfError(agnExceptionDates.Append(agnExceptionDate));
+    }
+    aAgnEntry.SetExceptionDatesL(agnExceptionDates);
+    CleanupStack::PopAndDestroy(); // pimExceptionDates close
+}
+
+// -----------------------------------------------------------------------------
+// CopyExceptionDatesToPimL
+// Copies Agenda exception dates to a PIM API repeat rule.
+// Returns: void
+// -----------------------------------------------------------------------------
+//
+void CopyExceptionDatesToPimL(const CCalEntry& aAgnEntry,
+                              MPIMRepeatRuleData& aPimRepeatRuleData)
+{
+    JELOG2(EPim);
+    RArray<TCalTime> agnExceptionDates;
+    aAgnEntry.GetExceptionDatesL(agnExceptionDates);
+    CleanupClosePushL(agnExceptionDates);
+    const TInt numExceptions = agnExceptionDates.Count();
+    for (TInt i = 0; i < numExceptions; i++)
+    {
+        TCalTime agnExceptionDate = agnExceptionDates[i];
+        TTime pimExceptionDate = agnExceptionDate.TimeUtcL();
+        aPimRepeatRuleData.AddExceptDateL(pimExceptionDate);
+    }
+
+    CleanupStack::PopAndDestroy(); // agnExceptionDates close
+}
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// destructor
+CPIMAgnEventAdapter::~CPIMAgnEventAdapter()
+{
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::CPIMAgnEventAdapter
+// C++ constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CPIMAgnEventAdapter::CPIMAgnEventAdapter(
+    java::util::FunctionServer* aFuncServer) :
+        CPIMAgnItemAdapter(aFuncServer)
+{
+    JELOG2(EPim);
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ReadFieldsFromAgnL
+// Reads Agenda entry's fields and converts them into PIM Item fields.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ReadFieldsFromAgnL(MPIMEventItem& aItem,
+        CCalEntry& aEntry, const TPIMField aSupportedFields[], // supported field types
+        TInt aSize) // size of the array
+{
+    JELOG2(EPim);
+    for (int i = 0; i < aSize; i++)
+    {
+        switch (aSupportedFields[i])
+        {
+        case EPIMEventSummary:
+        {
+            ReadSummaryFromAgnL(aItem, aEntry);
+            break;
+        }
+        case EPIMEventLocation:
+        {
+            ReadLocationFromAgnL(aItem, aEntry);
+            break;
+        }
+        case EPIMEventNote:
+        {
+            ReadNoteFromAgnL(aItem, aEntry);
+            break;
+        }
+        case EPIMEventAlarm:
+        {
+            ReadAlarmFromAgnL(aItem, aEntry);
+            break;
+        }
+        case EPIMEventStart:
+        {
+            ReadStartFromAgnL(aItem, aEntry);
+            break;
+        }
+        case EPIMEventEnd:
+        {
+            ReadEndFromAgnL(aItem, aEntry);
+            break;
+        }
+        case EPIMEventClass:
+        {
+            ReadClassFromAgnL(aItem, aEntry);
+            break;
+        }
+        case EPIMEventRevision: // fallthrough
+        case EPIMEventUid:
+        {
+            // nothing
+            break;
+        }
+        default:
+        {
+            User::Leave(KErrArgument);
+        }
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ConvertFieldsToAgnL
+// Reads PIM Item fields and converts them into Agenda entry's fields.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ConvertFieldsToAgnL(const MPIMEventItem& aItem,
+        CCalEntry& aEntry)
+{
+    JELOG2(EPim);
+    CArrayFix<TPIMField>* fields = aItem.ItemData().FieldsLC();
+    TInt amount = fields->Count();
+
+    for (int i = 0; i < amount; i++)
+    {
+        TPIMEventField field = static_cast<TPIMEventField>(fields->At(i));
+        switch (field)
+        {
+        case EPIMEventSummary: // Fallthrough
+        case EPIMEventLocation: // Fallthrough
+        case EPIMEventNote:
+        {
+            ConvertStringFieldToAgnL(aItem, aEntry, field);
+            break;
+        }
+        case EPIMEventAlarm:
+        {
+            ConvertAlarmToAgnL(aItem, aEntry);
+            break;
+        }
+        case EPIMEventStart: // Fallthrough
+        case EPIMEventEnd:
+        {
+            ConvertDateFieldToAgnL(aItem, aEntry, field);
+            break;
+        }
+        case EPIMEventClass:
+        {
+            ConvertClassToAgnL(aItem, aEntry);
+            break;
+        }
+        case EPIMEventRevision: // fallthrough
+        case EPIMEventUid:
+        {
+            // nothing
+            break;
+        }
+        default:
+        {
+            User::Leave(KErrArgument);
+        }
+        }
+    }
+    CleanupStack::PopAndDestroy(fields);
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ClearPIMFieldsL
+// Clears the fields supported by PIM API from this Agenda Model entry.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ClearPIMFieldsL(CCalEntry& aEntry,
+        const TPIMField aSupportedFields[], // Array of supported field types
+        TInt aSize) // Size of the array of supported fields
+{
+    JELOG2(EPim);
+    for (int i = 0; i < aSize; i++)
+    {
+        switch (aSupportedFields[i])
+        {
+        case EPIMEventSummary:
+        {
+            aEntry.SetSummaryL(KNullDesC);
+            break;
+        }
+        case EPIMEventLocation:
+        {
+            aEntry.SetLocationL(KNullDesC);
+            break;
+        }
+        case EPIMEventNote:
+        {
+            aEntry.SetDescriptionL(KNullDesC);
+            break;
+        }
+        case EPIMEventAlarm:
+        {
+            aEntry.SetAlarmL(NULL);
+            break;
+        }
+        case EPIMEventStart: // Fallthrough
+        case EPIMEventEnd: // Fallthrough
+        case EPIMEventUid: // Fallthrough
+        case EPIMEventClass: // Fallthrough
+        case EPIMEventRevision:
+        {
+            break; // For these fields there is no need to do anything
+        }
+        default:
+        {
+            User::Leave(KErrArgument);
+        }
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ReadSummaryFromAgnL
+// Reads Agenda entry's summary field and converts it into PIM Item field.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ReadSummaryFromAgnL(MPIMEventItem& aItem,
+        CCalEntry& aEntry)
+{
+    JELOG2(EPim);
+    const TDesC& agnSummary = aEntry.SummaryL();
+    if (agnSummary != KNullDesC)
+    {
+        TPIMFieldData fieldData(EPIMEventSummary, KPIMAttrNone,
+                                agnSummary.AllocLC());
+        aItem.ItemData().AddValueL(fieldData);
+        CleanupStack::Pop(); // agnSummary.AllocLC()
+    }
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ReadLocationFromAgnL
+// Reads Agenda entry's location field and converts it into PIM Item field.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ReadLocationFromAgnL(MPIMEventItem& aItem,
+        CCalEntry& aEntry)
+{
+    JELOG2(EPim);
+    const TDesC& agnLocation = aEntry.LocationL();
+    if (agnLocation != KNullDesC)
+    {
+        TPIMFieldData fieldData(EPIMEventLocation, KPIMAttrNone,
+                                agnLocation.AllocLC());
+        aItem.ItemData().AddValueL(fieldData);
+        CleanupStack::Pop(); // agnLocation.AllocLC()
+    }
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ReadNoteFromAgnL
+// Reads Agenda entry's notes field and converts it into PIM Item field.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ReadNoteFromAgnL(MPIMEventItem& aItem,
+        CCalEntry& aEntry)
+{
+    JELOG2(EPim);
+    const TDesC& note = aEntry.DescriptionL();
+    if (note != KNullDesC)
+    {
+        TPIMFieldData fieldData(EPIMEventNote, KPIMAttrNone, note.AllocLC());
+        aItem.ItemData().AddValueL(fieldData);
+        CleanupStack::Pop(); // notes.AllocLC( )
+    }
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ConvertStringFieldToAgnL
+// Makes string conversion from framework PIM item data field to Appt item field
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ConvertStringFieldToAgnL(const MPIMEventItem& aItem,
+        CCalEntry& aEntry, const TPIMEventField aField) const
+{
+    JELOG2(EPim);
+    const MPIMItemData& itemData = aItem.ItemData();
+    TInt amount = itemData.CountValues(aField);
+    for (TInt i = 0; i < amount; i++)
+    {
+        const TPIMFieldData fieldData = itemData.ValueL(aField, i);
+        const TDesC& stringValue = fieldData.StringValue();
+        EnsureValidStringValueL(stringValue);
+        // Add correct data to the field
+        switch (aField)
+        {
+        case EPIMEventNote:
+        {
+            aEntry.SetDescriptionL(stringValue);
+            break;
+        }
+        case EPIMEventSummary:
+        {
+            aEntry.SetSummaryL(stringValue);
+            break;
+        }
+        case EPIMEventLocation:
+        {
+            aEntry.SetLocationL(stringValue);
+            break;
+        }
+        default:
+        {
+            __ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory,
+                                               EPIMPanicUnsupportedStringField));
+            break;
+        }
+        }
+
+    }
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ConvertDateFieldToAgnL
+// Converts a PIM date field to native Calendar entry
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ConvertDateFieldToAgnL(const MPIMEventItem& aItem,
+        CCalEntry& aEntry, const TPIMEventField aField)
+{
+    JELOG2(EPim);
+    __ASSERT_DEBUG(aField == EPIMEventStart || aField == EPIMEventEnd,
+                   User::Panic(KPIMPanicCategory, EPIMPanicUnsupportedDateField));
+
+    TCalTime end;
+    TCalTime start;
+
+    // Get date from the Java item
+    const MPIMItemData& itemData = aItem.ItemData();
+    // Get date from index 0 since native entries support only one value
+    const TPIMFieldData fieldData = itemData.ValueL(aField, 0);
+    const TPIMDate date = fieldData.DateValue();
+
+    // Check that the date is inside the valid range
+    __ASSERT_ALWAYS(IsDateInValidAgendaRange(date), User::Leave(KErrAbort));
+    // By default, set both end and start to the same time and check if there
+    // is the other part of the date field present in the item
+    start.SetTimeUtcL(date);
+    end.SetTimeUtcL(date);
+
+    if (aField == EPIMEventStart && itemData.CountValues(EPIMEventEnd) > 0
+            && itemData.ValueL(EPIMEventEnd, 0).DateValue() >= date)
+    {
+        const TPIMFieldData endData = itemData.ValueL(EPIMEventEnd, 0);
+        const TPIMDate endDate = endData.DateValue();
+        // Check that the date is inside the valid range
+        __ASSERT_ALWAYS(IsDateInValidAgendaRange(endDate), User::Leave(
+                            KErrAbort));
+        // Set end date to the calendar date in UTC since
+        // PIM API does not support local time format
+        end.SetTimeUtcL(endDate);
+    }
+    else if (aField == EPIMEventEnd && itemData.CountValues(EPIMEventStart) > 0
+             && itemData.ValueL(EPIMEventStart, 0).DateValue() <= date)
+    {
+        const TPIMFieldData startData = itemData.ValueL(EPIMEventStart, 0);
+        const TPIMDate startDate = startData.DateValue();
+        // Check that the date is inside the valid range
+        __ASSERT_ALWAYS(IsDateInValidAgendaRange(startDate), User::Leave(
+                            KErrAbort));
+        // Set end date to the calendar date in UTC since
+        // PIM API does not support local time format
+        start.SetTimeUtcL(startDate);
+    }
+
+    // Set values to the native calendar entry
+    aEntry.SetStartAndEndTimeL(start, end);
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ReadAlarmFromAgnL
+// Reads alarm offset from the native Calendar entry. In case of Anniversary,
+// the offset is calculated from the midnight since native Calendar supports
+// only dates in these types of entries
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ReadAlarmFromAgnL(MPIMEventItem& aItem,
+        CCalEntry& aEntry)
+{
+    JELOG2(EPim);
+    CCalAlarm* calAlarm = aEntry.AlarmL();
+    // The previous function call returns NULL if there is no alarm
+    // set in the item. The ownership is transferred to the caller
+    // if the alarm values has been added to the item.
+    if (calAlarm)
+    {
+        TTimeIntervalMinutes nativeValue = calAlarm->TimeOffset();
+        // The alarm is not needed anymore so it can be deleted
+        delete calAlarm;
+        calAlarm = NULL;
+        //            nativeValue.Int() );
+        // Convert the alarm value based on the start time of the entry
+        CCalEntry::TType entryType = aEntry.EntryTypeL();
+        // Events (memos) and anniversaries do not have time in the native
+        // side, therefore alarm field in those entries need to be calculated
+        // from the end of the day
+        if (entryType == CCalEntry::EAnniv)
+        {
+            TTime start(aEntry.StartTimeL().TimeLocalL());
+            // Change the time to the end of the start date
+            TTime startOfDayLocal(start);
+            startOfDayLocal = StartOfDay(startOfDayLocal);
+            // Calculate the difference from end of day and start time including
+            // the original alarm offset which was previously read
+            TTimeIntervalMinutes temp(0);
+            User::LeaveIfError(startOfDayLocal.MinutesFrom(start, temp));
+            // Since it is not possible to substract TTimeIntervalMinutes
+            // from TTime (probably a Symbian error), the difference has
+            // to be calculated using the following way...
+            nativeValue = nativeValue.Int() + temp.Int();
+        }
+        TInt alarmValue = nativeValue.Int() * KPIMSecondsInMinute;
+        //            alarmValue );
+        // Add alarm value to the item
+        TPIMFieldData fieldData(EPIMEventAlarm, EPIMFieldInt, KPIMAttrNone,
+                                alarmValue);
+        aItem.ItemData().AddValueL(fieldData);
+    }
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ConvertAlarmToAgnL
+// Converts alarm from PIM item to a native entry. The alarm is calculated
+// from the start date of the event and if it is not present, the alarm field
+// is ignored because there is no possibility to calculate it
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ConvertAlarmToAgnL(const MPIMEventItem& aItem,
+        CCalEntry& aEntry)
+{
+    JELOG2(EPim);
+    const MPIMItemData& itemData = aItem.ItemData();
+
+    // Note that start time must be set before alarm can be calculated
+    // Add start to the item so alarm can be properly converted. The
+    // native entry does not accept alarm value if start is not present
+
+    if (itemData.CountValues(EPIMEventStart) == 0)
+    {
+        User::Leave(KErrArgument);
+    }
+    else
+    {
+        ConvertDateFieldToAgnL(aItem, aEntry, EPIMEventStart);
+    }
+
+    __ASSERT_DEBUG(aEntry.StartTimeL().TimeUtcL() != Time::NullTTime(),
+                   User::Panic(KPIMPanicCategory, EPIMPanicInvalidState));
+
+    // Get alarm value from the Java item. There should be only one alarm
+    // value supported by the PIM API because native entries do not support
+    // multiple alarm values.
+    const TPIMFieldData alarmData = itemData.ValueL(EPIMEventAlarm, 0);
+    TInt value = alarmData.IntegerValue();
+
+    // Count the alarm value from the start date of the event
+    TTime entryStart = aEntry.StartTimeL().TimeLocalL();
+    const TPIMFieldData startData = itemData.ValueL(EPIMEventStart, 0);
+    TPIMDate startTime = startData.DateValue();
+    ConvertTimeL(startTime, EPIMDateLocal);
+    TTimeIntervalSeconds temp(0);
+    User::LeaveIfError(entryStart.SecondsFrom(startTime, temp));
+
+    // Add difference between PIM API start and start which has been
+    // converted to the item (in case if the date has been changed, it is
+    // reflected here)
+    value += temp.Int();
+
+    // Check that if the alarm has passed to the following day. In this case,
+    // the alarm is transferred back to 12 o'clock of the current start date
+    TTime alarmTime(entryStart - TTimeIntervalSeconds(value));
+    // Temporary date. This date is used when calculating if the alarm
+    // value has passed to the following date.
+    TTime startOfNextDay(StartOfDay(startTime + TTimeIntervalDays(1)));
+    if (alarmTime >= startOfNextDay)
+    {
+        alarmTime = StartOfDay(entryStart);
+        alarmTime += TTimeIntervalSeconds(KPIMDefaultAlarmInterval);
+        User::LeaveIfError(entryStart.SecondsFrom(alarmTime, temp));
+        value = temp.Int();
+    }
+    // Convert the alarm value to the native entry
+    SetAlarmToEntryL(aEntry, value);
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ReadRepeatFromAgnL
+// Reads entry's repeat details and converts them into PIM repeat rule.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ReadRepeatFromAgnL(MPIMEventItem& aItem,
+        CCalEntry& aEntry)
+{
+    JELOG2(EPim);
+    MPIMRepeatRuleData* repeatRuleData = aItem.GetRepeat();
+
+    TCalRRule agnRRule;
+    if (aEntry.GetRRuleL(agnRRule))
+    {
+        repeatRuleData->clear();
+
+        PIMRepeatRuleConverter::ConvertSupportedRepeatToPIML(*repeatRuleData,
+                agnRRule);
+
+        CopyExceptionDatesToPimL(aEntry, *repeatRuleData);
+
+        // Anniv does not need to have an end date, so clear that field to be sure
+        if (aEntry.EntryTypeL() == CCalEntry::EAnniv)
+        {
+            repeatRuleData->ClearFieldL(EPIMRepeatRuleEnd);
+        }
+
+        aItem.SetRepeating(ETrue);
+    }
+    else
+    {
+        repeatRuleData->clear();
+        aItem.SetRepeating(EFalse);
+    }
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ConvertRepeatToAgnL
+// Makes conversion from framework PIM item repeat rule to native entry repeat.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ConvertRepeatToAgnL(
+    const MPIMEventItem& aEventItemData, CCalEntry& aAgnEntry)
+{
+    JELOG2(EPim);
+    const MPIMRepeatRuleData* repeatRuleData = aEventItemData.GetRepeat();
+
+    TTime eventStart = aAgnEntry.StartTimeL().TimeUtcL();
+
+    TCalRRule agnRRule = PIMRepeatRuleConverter::ConvertSupportedRepeatToAgnL(
+                             *repeatRuleData, eventStart);
+
+    if ((aAgnEntry.EntryTypeL() == CCalEntry::EAnniv) && (agnRRule.Type()
+            != TCalRRule::EYearly))
+    {
+        User::Leave(KErrArgument);
+    }
+
+    if (agnRRule.Type() == TCalRRule::EWeekly)
+    {
+        __ASSERT_ALWAYS(agnRRule.Interval() <= 2, User::Leave(KErrArgument));
+    }
+    else // other than weekly
+    {
+        __ASSERT_ALWAYS(agnRRule.Interval() == 1, User::Leave(KErrArgument));
+    }
+
+    // Use local time to check the day since UTC times provide incorrect
+    // results if the compared dates are near midnight
+    TTime untilLocal = agnRRule.Until().TimeLocalL();
+    TTime startLocal = aAgnEntry.StartTimeL().TimeLocalL();
+    // Validate that repeat rule is correct. The end of the repeat rule
+    // must be greater than the event start and it must not be within
+    // the same day as the start of the event
+    if (untilLocal != Time::NullTTime())
+    {
+        __ASSERT_ALWAYS(untilLocal >= startLocal, User::Leave(KErrAbort));
+        TTimeIntervalDays intervalDays = untilLocal.DaysFrom(startLocal);
+        // Interval smaller than one day. Check that the day is not the same
+        if (intervalDays < TTimeIntervalDays(1))
+        {
+            __ASSERT_ALWAYS(untilLocal.DateTime().Day()
+                            != startLocal.DateTime().Day(), User::Leave(KErrAbort));
+        }
+    }
+
+    // Repeat Rules OK
+    aAgnEntry.SetRRuleL(agnRRule);
+    CopyExceptionDatesToAgnL(*repeatRuleData, aAgnEntry);
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ReadClassFromAgnL
+// Reads entry's class details and converts them into PIM class.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ReadClassFromAgnL(MPIMEventItem& aItem,
+        CCalEntry& aEntry)
+{
+    JELOG2(EPim);
+    TPIMEventClassValue eClassValue = EPIMEventClassPrivate;
+    const CCalEntry::TReplicationStatus replicationStatus =
+        aEntry.ReplicationStatusL();
+
+    // Map calendar entry values to pim value
+    switch (replicationStatus)
+    {
+    case CCalEntry::EOpen:
+    {
+        eClassValue = EPIMEventClassPublic;
+        break;
+    }
+    case CCalEntry::EPrivate:
+    {
+        eClassValue = EPIMEventClassPrivate;
+        break;
+    }
+    case CCalEntry::ERestricted:
+    {
+        eClassValue = EPIMEventClassConfidential;
+        break;
+    }
+    default:
+    {
+        User::Leave(KErrArgument);
+        break;
+    }
+    }
+    TPIMFieldData fieldData(EPIMEventClass, EPIMFieldInt, KPIMAttrNone,
+                            eClassValue);
+    // Set value for the class item
+    aItem.ItemData().AddValueL(fieldData);
+}
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::ConvertClassToAgnL
+// Makes conversion from framework PIM item class to native entry class.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::ConvertClassToAgnL(const MPIMEventItem& aItem,
+        CCalEntry& aEntry)
+{
+    JELOG2(EPim);
+    CCalEntry::TReplicationStatus replicationStatus = CCalEntry::EPrivate;
+
+    // There should and MUST be only one value in the
+    // class field so get the value from the first index
+    const TPIMFieldData& fieldData = aItem.ItemData().ValueL(EPIMEventClass, 0);
+    TInt eClassValue = fieldData.IntegerValue();
+
+    // Map pim class value to calendar entry value
+    switch (eClassValue)
+    {
+    case EPIMEventClassPrivate:
+    {
+        replicationStatus = CCalEntry::EPrivate;
+        break;
+    }
+    case EPIMEventClassConfidential:
+    {
+        replicationStatus = CCalEntry::ERestricted;
+        break;
+    }
+    case EPIMEventClassPublic:
+    {
+        replicationStatus = CCalEntry::EOpen;
+        break;
+    }
+    default:
+    {
+        User::Leave(KErrArgument);
+        break;
+    }
+    }
+    aEntry.SetReplicationStatusL(replicationStatus);
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::SetAlarmToEntryL
+// Sets the native entry alarm field.
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::SetAlarmToEntryL(CCalEntry& aEntry, const TInt aValue) const
+{
+    JELOG2(EPim);
+    TTimeIntervalMinutes offMin(aValue / KPIMSecondsInMinute);
+    CCalAlarm* agnAlarm = CCalAlarm::NewL();
+    agnAlarm->SetTimeOffset(offMin);
+
+    CleanupStack::PushL(agnAlarm);
+    aEntry.SetAlarmL(agnAlarm);
+    CleanupStack::PopAndDestroy(agnAlarm);
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::EnsureValidStringValueL
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::EnsureValidStringValueL(const TDesC& aStringValue) const
+{
+    JELOG2(EPim);
+    if (aStringValue.Length() > KPIMAgnStringFieldMaxLength)
+    {
+        User::Leave(KErrTooBig);
+    }
+}
+
+// -----------------------------------------------------------------------------
+// CPIMAgnEventAdapter::AddDefaultValuesToEntryL
+// -----------------------------------------------------------------------------
+//
+void CPIMAgnEventAdapter::AddDefaultValuesToEntryL(const MPIMEventItem& aItem,
+        CCalEntry& aEntry) const
+{
+    JELOG2(EPim);
+    const MPIMItemData& data = aItem.ItemData();
+    // Default calendar synchronisation is private
+    if (data.CountValues(EPIMEventClass) == 0)
+    {
+        aEntry.SetReplicationStatusL(CCalEntry::EPrivate);
+    }
+}
+
+// End of File