diff -r f5050f1da672 -r 04becd199f91 javaextensions/pim/agnadapter/src.s60/cpimagntodoadapter.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javaextensions/pim/agnadapter/src.s60/cpimagntodoadapter.cpp Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,719 @@ +/* +* 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: Handles PIM API todo item <-> Agenda Model todo conversions + * +*/ + + +// CLASS HEADER +#include "cpimagntodoadapter.h" + +// INTERNAL INCLUDES +#include "mpimtodoitem.h" +#include "mpimitemdata.h" +#include "pimpanics.h" +#include "pimtypes.h" +#include "logger.h" + +// EXTERNAL INCLUDES +#include +#include +#include + + +// UNNAMED LOCAL NAMESPACE +namespace +{ +// Seconds in a one minute +const TInt KPIMSecondsInMinute = 60; +// Maximum length of ToDo item string fields in S60 +const TInt KPIMToDoStringValueMaxLength = 160; +// 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; +} + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CPIMAgnToDoAdapter* CPIMAgnToDoAdapter::NewL( + java::util::FunctionServer* aFuncServer) +{ + JELOG2(EPim); + CPIMAgnToDoAdapter* self = new(ELeave) CPIMAgnToDoAdapter(aFuncServer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; +} + +// destructor +CPIMAgnToDoAdapter::~CPIMAgnToDoAdapter() +{ + JELOG2(EPim); +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::CreateItemToAgnL +// Creates a new Agenda Model To-Do item from a PIM item data. +// Returns: A To-do item based on PIM item data. +// The ownership of the To-do item is transferred to the caller. +// ----------------------------------------------------------------------------- +// +CCalEntry* CPIMAgnToDoAdapter::CreateItemToAgnL(const MPIMToDoItem& aItem) +{ + JELOG2(EPim); + // Create new calendar entry + CCalEntry* entry = CreateCalendarEntryLC(CCalEntry::ETodo); + // Export entry. No need to reset since this is a new entry + ExportItemL(aItem, *entry, EFalse); + CleanupStack::Pop(entry); + return entry; +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::ReadAgnToItemL +// Reads an Agenda Model To-do item and converts it to a framework PIM item. +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::ReadAgnToItemL(MPIMToDoItem& aItem, CCalEntry& aEntry) +{ + JELOG2(EPim); + MPIMItemData& itemData = aItem.ItemData(); + // Read string fields to PIM API ToDo entry (summary and note) + ReadStringFieldsL(itemData, aEntry); + // Read integer fields to PIM API ToDo entry (priority and class) + ReadIntFieldsL(itemData, aEntry); + // Read date fields to PIM API ToDo entry (due and completion date). Alarm + // is read here also because it is related to the due date of the item + ReadDateFieldsL(itemData, aEntry); +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::UpdateItemToAgnL +// Reads an Agenda Model To-do item and updates it based on the PIM item data. +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::UpdateItemToAgnL(const MPIMToDoItem& aItem, + CCalEntry& aEntry) +{ + JELOG2(EPim); + // Export PIM item data to the native entry. Reset the entry for new data + ExportItemL(aItem, aEntry, ETrue); +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::ExportItemL +// (other items were commented in a header) +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::ExportItemL(const MPIMToDoItem& aItem, + CCalEntry& aEntry, TBool aResetEntry) +{ + JELOG2(EPim); + if (aResetEntry) + { + // Reset native entry for exporting new data + aEntry.SetSummaryL(KNullDesC()); + aEntry.SetDescriptionL(KNullDesC()); + aEntry.SetPriorityL(0); + aEntry.SetCompletedL(EFalse, aEntry.CompletedTimeL()); + } + + // Export item data to the native ToDo calendar entry + const MPIMItemData& itemData = aItem.ItemData(); + CArrayFix* fields = itemData.FieldsLC(); + + // Add default values to the calendar entry + AddDefaultValuesToEntryL(itemData, aEntry); + + // Convert each field to the native ToDo calendar entry + TInt count = fields->Count(); + for (TInt i = 0; i < count; i++) + { + TPIMToDoField field = static_cast(fields->At(i)); + ConvertToAgnL(field, aEntry, itemData); + } + CleanupStack::PopAndDestroy(fields); +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::AddDefaultValuesToEntryL +// (other items were commented in a header) +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::AddDefaultValuesToEntryL(const MPIMItemData& aData, + CCalEntry& aEntry) const +{ + JELOG2(EPim); + // Calendar creates medium priority ToDos by default + if (!aData.CountValues(EPIMToDoPriority)) + { + aEntry.SetPriorityL(EPIMToDoNativePriorityMedium); + } + // Calendar uses private synchronization by default + if (!aData.CountValues(EPIMToDoClass)) + { + aEntry.SetReplicationStatusL(CCalEntry::EPrivate); + } + // Calendar does not support timed ToDo so the time is set to 00:00 o'clock + if (!aData.CountValues(EPIMToDoDue)) + { + TTime thisTime; + thisTime.HomeTime(); + // Set time to calendar specific due time. Currently this is the start + // of the date. Note that No conversion needed since time is local + TCalTime calThisTime; + // Set time as local time since acquired above as local time + calThisTime.SetTimeLocalL(StartOfDay(thisTime)); + aEntry.SetStartAndEndTimeL(calThisTime, calThisTime); + } + if (!aData.CountValues(EPIMToDoCompletionDate) && !aData.CountValues( + EPIMToDoCompleted)) + { + aEntry.SetCompletedL(EFalse, aEntry.CompletedTimeL()); + } + +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::ReadStringFieldsL +// (other items were commented in a header) +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::ReadStringFieldsL(MPIMItemData& aData, + CCalEntry& aEntry) +{ + JELOG2(EPim); + // Summary is converted to PIM API ToDo summary field + const TDesC& sum = aEntry.SummaryL(); + if (sum != KNullDesC) + { + TPIMFieldData fieldData(EPIMToDoSummary, KPIMAttrNone, sum.AllocLC()); + aData.AddValueL(fieldData); + CleanupStack::Pop(); // agnSummary.AllocLC() + } + // Description is converted to PIM API ToDo note field + const TDesC& note = aEntry.DescriptionL(); + if (note != KNullDesC) + { + TPIMFieldData fieldData(EPIMToDoNote, KPIMAttrNone, note.AllocLC()); + aData.AddValueL(fieldData); + CleanupStack::Pop(); // AllocLC + } +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::ReadIntFieldsL +// (other items were commented in a header) +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::ReadIntFieldsL(MPIMItemData& aData, CCalEntry& aEntry) +{ + JELOG2(EPim); + // Convert synchornization field to PIM API. The default value is private + // and unrecognized priority values are mapped also to private due to + // security reasons + TPIMToDoClassValue value = EPIMToDoClassPrivate; + const CCalEntry::TReplicationStatus status = aEntry.ReplicationStatusL(); + if (status == CCalEntry::EOpen) + { + // Open is mapped as public synhronization + value = EPIMToDoClassPublic; + } + else if (status == CCalEntry::ERestricted) + { + // Open is mapped as user confidential synhronization + value = EPIMToDoClassConfidential; + } + // Note that boolean and integer fields must be identified in the constructor + TPIMFieldData classData(EPIMToDoClass, EPIMFieldInt, KPIMAttrNone, value); + aData.AddValueL(classData); + + // Default value is zero acording to vCalendar specification. PIM API default + // priority is medium which indicates normal native priority + // See common/pimtodo.h for platform-specific native priorities. + TUint nativePriority = aEntry.PriorityL(); + TPIMToDoPriority priority = EPIMToDoPriorityMedium; + if (nativePriority == EPIMToDoNativePriorityHigh) + { + // Native priority value High is mapped to value 1 + priority = EPIMToDoPriorityHigh; + } + else if (nativePriority == EPIMToDoNativePriorityLow) + { + // Native priority value Low is mapped to value 7 + priority = EPIMToDoPriorityLow; + } + // Note that boolean and integer fields must be identified in the constructor + TPIMFieldData + prData(EPIMToDoPriority, EPIMFieldInt, KPIMAttrNone, priority); + aData.AddValueL(prData); +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::ReadDateFieldsL +// (other items were commented in a header) +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::ReadDateFieldsL(MPIMItemData& aData, CCalEntry& aEntry) +{ + JELOG2(EPim); + TTime nullTime = Time::NullTTime(); + // The Agenda todo entry end field is the due date + TTime due(aEntry.EndTimeL().TimeLocalL()); + if (due != nullTime) + { + // Set due to the PIM API specific due date, in this case, the start of date + // Note that PIM API uses times as UTC times so the due date must be in + // correct format. Previously requested as local time -> do not change + TPIMDate pimDueDate(StartOfDay(due)); + // Date must be converted UTC time because acquired as local above + ConvertTimeL(pimDueDate, EPIMDateUTC); + TPIMFieldData dueFieldData(EPIMToDoDue, KPIMAttrNone, pimDueDate); + aData.AddValueL(dueFieldData); + + // Get alarm. Ownership is transferred to the caller. Alarm cannot be set + // if the due date is not set because the calculation is done as an offset + // from the ToDo due date. + CCalAlarm* calAlarm = aEntry.AlarmL(); + if (calAlarm) + { + TTimeIntervalMinutes nativeValue = calAlarm->TimeOffset(); + // The alarm is not needed anymore so it can be deleted + delete calAlarm; + calAlarm = NULL; + // Change the time to the start of the due date + TTime startOfDayLocal(StartOfDay(due)); + // Calculate the difference from the start of due date and start time including + // the original alarm offset which was previously read + TTimeIntervalMinutes temp(0); + User::LeaveIfError(startOfDayLocal.MinutesFrom(due, 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... + TInt alarm = (nativeValue.Int() + temp.Int()) * KPIMSecondsInMinute; + // Add alarm value to the item + TPIMFieldData fieldData(EPIMToDoExtAlarm, EPIMFieldInt, + KPIMAttrNone, alarm); + // Add value to the PIM item data + aData.AddValueL(fieldData); + } + } + + // Completion date. If the item has a completion date, the item is then completed + // and completed flag is set to true in PIM API. Null time if not crossed out. + TTime completed = aEntry.CompletedTimeL().TimeUtcL(); + if (completed != nullTime) + { + TPIMFieldData dateData(EPIMToDoCompletionDate, KPIMAttrNone, completed); + aData.AddValueL(dateData); + // Note that boolean and integer fields must be identified in the constructor + TPIMFieldData flag(EPIMToDoCompleted, EPIMFieldBoolean, KPIMAttrNone, + ETrue); + aData.AddValueL(flag); + } +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::ConvertToAgnL +// Makes the conversion from framework PIM item data field to To-do item field. +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::ConvertToAgnL(TPIMToDoField aField, // The field to be converted + CCalEntry& aEntry, const MPIMItemData& aItem) +{ + JELOG2(EPim); + TInt amount = aItem.CountValues(aField); + for (TInt index = 0; index < amount; index++) + { + switch (aField) + { + case EPIMToDoCompletionDate: // fallthrough + case EPIMToDoDue: + { + ConvertDateToAgnL(aField, index, aEntry, aItem); + break; + } + case EPIMToDoSummary: // fallthrough + case EPIMToDoNote: + { + ConvertStringToAgnL(aField, index, aEntry, aItem); + break; + } + case EPIMToDoClass: // fallthrough + case EPIMToDoExtAlarm: + case EPIMToDoPriority: + { + ConvertIntToAgnL(aField, index, aEntry, aItem); + break; + } + case EPIMToDoCompleted: + { + ConvertBooleanToAgnL(aField, index, aEntry, aItem); + break; + } + case EPIMToDoUid: // fallthrough + case EPIMToDoRevision: + { + // nothing + break; + } + default: + { + __ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory, + EPIMPanicUnsupportedField)); + } + } + } +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::ConvertDateToAgnL +// Makes date conversion from framework PIM item data field to To-do item field. +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::ConvertDateToAgnL(TPIMToDoField aField, // Date field to be converted + TInt aIndex, // Index of the date field + CCalEntry& aEntry, const MPIMItemData& aItem) // The PIM item to read the field from +{ + JELOG2(EPim); + const TPIMFieldData fieldData = aItem.ValueL(aField, aIndex); + const TPIMDate& date = fieldData.DateValue(); + switch (aField) + { + case EPIMToDoDue: + { + // Because undated to-dos are possible, the due date can be set + // to a null value. + if (date != Time::NullTTime() && !IsDateInValidAgendaRange(date)) + { + User::Leave(KErrAbort); + } + // Java dates cannot be set to native null TTime + else + { + // Convert due date and time to calendar specific due time + // Note that PIM API dates are in UTC time format -> convert + TTime dueDate(date); + ConvertTimeL(dueDate, EPIMDateLocal); + // Set time to native entry. Note that the time is local + TCalTime calDate; + calDate.SetTimeLocalL(StartOfDay(dueDate)); + aEntry.SetStartAndEndTimeL(calDate, calDate); + } + break; + } + case EPIMToDoCompletionDate: + { + if (date != Time::NullTTime()) + { + __ASSERT_ALWAYS(IsDateInValidAgendaRange(date), User::Leave( + KErrAbort)); + TCalTime calDate; + calDate.SetTimeUtcL(date); + aEntry.SetCompletedL(ETrue, calDate); + } + else + { + aEntry.SetCompletedL(EFalse, aEntry.CompletedTimeL()); + } + break; + } + default: + { + __ASSERT_DEBUG(EFalse, User::Panic(KPIMPanicCategory, + EPIMPanicUnsupportedField)); + } + } +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::ConvertStringToAgnL +// Makes string conversion from framework PIM item data field to To-do item field +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::ConvertStringToAgnL(TPIMToDoField aField, // String field to be converted + TInt aIndex, // Index of the date field + CCalEntry& aEntry, // The Agenda Model entry + const MPIMItemData& aItem) // The PIM item to read the field from +{ + JELOG2(EPim); + const TPIMFieldData fieldData = aItem.ValueL(aField, aIndex); + const TDesC& string = fieldData.StringValue(); + + // Check that string is not too long + __ASSERT_ALWAYS(string.Length() <= KPIMToDoStringValueMaxLength, + User::Leave(KErrTooBig)); + + switch (aField) + { + case EPIMToDoSummary: + { + aEntry.SetSummaryL(string); + break; + } + case EPIMToDoNote: + { + aEntry.SetDescriptionL(string); + break; + } + default: + { + // Should not happen + } + } + +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::ConvertIntToAgnL +// Makes int conversion from framework PIM item data field to To-do item field. +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::ConvertIntToAgnL(TPIMToDoField aField, // Int field to be converted + TInt aIndex, // Index of the date field + CCalEntry& aEntry, // The Agenda model entry typecasted to a Todo item + const MPIMItemData& aItemData) // The PIM item to read the field from +{ + JELOG2(EPim); + const TPIMFieldData fieldData = aItemData.ValueL(aField, aIndex); + switch (aField) + { + case EPIMToDoPriority: + { + TInt intField = fieldData.IntegerValue(); + + if ((EPIMToDoPriorityHigh <= intField) && (intField + < EPIMToDoPriorityMedium)) + { + aEntry.SetPriorityL(EPIMToDoNativePriorityHigh); + } + else if ((EPIMToDoPriorityMedium <= intField) && (intField + < EPIMToDoPriorityLow)) + { + aEntry.SetPriorityL(EPIMToDoNativePriorityMedium); + } + else if ((EPIMToDoPriorityLow <= intField) && (intField + <= EPIMToDoPriorityMaxValue)) + { + aEntry.SetPriorityL(EPIMToDoNativePriorityLow); + } + else + { + // From requirement specification: Imported to-do items with + // priority set to zero must be mapped to the native priority + // value Medium. + aEntry.SetPriorityL(EPIMToDoNativePriorityMedium); + } + break; + } + case EPIMToDoClass: + { + CCalEntry::TReplicationStatus replicationStatus = CCalEntry::EPrivate; + + // Single value assumed + TInt classValue = fieldData.IntegerValue(); + + switch (classValue) + { + case EPIMToDoClassPrivate: + { + replicationStatus = CCalEntry::EPrivate; + break; + } + case EPIMToDoClassConfidential: + { + replicationStatus = CCalEntry::ERestricted; + break; + } + case EPIMToDoClassPublic: + { + replicationStatus = CCalEntry::EOpen; + break; + } + default: + { + User::Leave(KErrArgument); + break; + } + } + aEntry.SetReplicationStatusL(replicationStatus); + break; + } + case EPIMToDoExtAlarm: + { + CCalAlarm* agnAlarm = CCalAlarm::NewL(); + CleanupStack::PushL(agnAlarm); + agnAlarm->SetTimeOffset(AlarmOffsetL(aItemData, aEntry)); + aEntry.SetAlarmL(agnAlarm); + CleanupStack::PopAndDestroy(agnAlarm); + break; + } + default: + { + // Should not happen + __ASSERT_DEBUG(EFalse, User::Invariant()); + } + } +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::ConvertBooleanToAgnL +// Makes boolean conversion from framework PIM item data field to To-do item field +// ----------------------------------------------------------------------------- +// +void CPIMAgnToDoAdapter::ConvertBooleanToAgnL(TPIMToDoField aField, // Boolean field to be converted + TInt aIndex, // Index of the date field + CCalEntry& aEntry, // The Agenda model entry typecasted to a Todo item + const MPIMItemData& aItem) // The PIM item to read the field from +{ + JELOG2(EPim); + const TPIMFieldData fieldData = aItem.ValueL(aField, aIndex); + TBool booleanField = fieldData.BooleanValue(); + + if (booleanField) // completed flag is set to value TRUE + { + // Check if the completed date field is present + if (aItem.CountValues(EPIMToDoCompletionDate) == 0) + { + // If completed date is not present, use the current time. + TTime currentTime; + currentTime.HomeTime(); + TCalTime calCurrentTime; + // Set time as local time since acquired above as local time + calCurrentTime.SetTimeLocalL(currentTime); + aEntry.SetCompletedL(ETrue, calCurrentTime); + } + else + { + TPIMFieldData completionData = aItem.ValueL(EPIMToDoCompletionDate, + aIndex); + const TPIMDate& date = completionData.DateValue(); + if (date != Time::NullTTime()) + { + TCalTime calDate; + calDate.SetTimeUtcL(date); + aEntry.SetCompletedL(ETrue, calDate); + } + else + { + // If completed date is set to null time, use the current time. + TTime currentTime; + currentTime.HomeTime(); + TCalTime calCurrentTime; + // Set time as local time since acquired above as local time + calCurrentTime.SetTimeLocalL(currentTime); + aEntry.SetCompletedL(ETrue, calCurrentTime); + } + } + } + else // completed flag is set to value FALSE + { + aEntry.SetCompletedL(EFalse, aEntry.CompletedTimeL()); + } +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::AlarmOffsetL +// Calculates PIM alarm offset for native Calendar entry +// The offset calculation is done by calculating the difference between the +// due date and the alarm offset. After we know the alarm date and time we +// calculate difference between calender specific todo due date (which now is +// 00:00) +// +// For example: +// +// If our due time is 23:00 and the alarm offset is 900 seconds before it. +// Then the alarm should launch at 22:45 at the same day. So, the offset which +// we have to write to the native alarm is the difference between 00:00 and 22:45 +// which is a negative value because the alarm rises in the future. This all is +// done because the calendar understands only the date of the due date and not the +// exact time of it. The time is ignored and set to 00:00 by default. +// ----------------------------------------------------------------------------- +// +TTimeIntervalMinutes CPIMAgnToDoAdapter::AlarmOffsetL( + const MPIMItemData& aItemData, CCalEntry& aEntry) +{ + JELOG2(EPim); + // 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 + // Due has been already set to default time (current home time) if + // ToDo due field is not present in the field so start should be present + if (!aItemData.CountValues(EPIMToDoDue)) + { + User::Leave(KErrArgument); + } + else + { + ConvertDateToAgnL(EPIMToDoDue, 0, aEntry, aItemData); + } + + __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 = aItemData.ValueL(EPIMToDoExtAlarm, 0); + TInt value = alarmData.IntegerValue(); + + // Count the alarm value from the start date of the event + TTime entryStart = aEntry.StartTimeL().TimeLocalL(); + const TPIMFieldData dateData = aItemData.ValueL(EPIMToDoDue, 0); + TPIMDate dueDate(dateData.DateValue()); + ConvertTimeL(dueDate, EPIMDateLocal); + TTimeIntervalSeconds temp(0); + User::LeaveIfError(entryStart.SecondsFrom(dueDate, 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(dueDate + TTimeIntervalDays(1))); + if (alarmTime >= startOfNextDay) + { + alarmTime = StartOfDay(entryStart); + alarmTime += TTimeIntervalSeconds(KPIMDefaultAlarmInterval); + User::LeaveIfError(entryStart.SecondsFrom(alarmTime, temp)); + value = temp.Int(); + } + // Convert seconds to minutes + return TTimeIntervalMinutes(value / KPIMSecondsInMinute); +} + +// ----------------------------------------------------------------------------- +// CPIMAgnToDoAdapter::CPIMAgnToDoAdapter +// ----------------------------------------------------------------------------- +// +CPIMAgnToDoAdapter::CPIMAgnToDoAdapter(java::util::FunctionServer* aFuncServer) : + CPIMAgnItemAdapter(aFuncServer) +{ + JELOG2(EPim); +} + +// End of File