TBool CDummyCalendarApp::CheckEntryNumL(TEntryType aType, TInt aNumEntry)
{
CCalIter& iter = GetIterL();
TPtrC8 Uid(iter.FirstL());
TInt ii=0;
while (Uid!=KNullDesC8())
{
++ii;
RPointerArray<CCalEntry> entryList;
CleanupResetAndDestroyPushL(entryList);
iLocalEntryView->FetchL(Uid, entryList);
CCalEntry* entry = entryList[0];
if(aType==EApp)
{
test(entry->EntryTypeL()==CCalEntry::EAppt);
}
else if (aType==ETodo)
{
test(entry->EntryTypeL()==CCalEntry::ETodo);
}
else if(aType == EReminder)
{
test(entry->EntryTypeL()==CCalEntry::EReminder);
}
CleanupStack::PopAndDestroy(&entryList);
Uid.Set(iter.NextL());
}
return (ii==aNumEntry);
}
// -----------------------------------------------------------------------------
// 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);
}
}
void OrganizerItemTypeTransform::transformToDetailL(const CCalEntry& entry, QOrganizerItem *item)
{
CCalEntry::TType entryType = entry.EntryTypeL();
QString itemType;
if (entryType == CCalEntry::ETodo) {
// Assume this is an occurrence if the recurrence id is set
if (entry.RecurrenceIdL().TimeUtcL() != Time::NullTTime())
itemType = QLatin1String(QOrganizerItemType::TypeTodoOccurrence);
else
itemType = QLatin1String(QOrganizerItemType::TypeTodo);
}
else if (entryType == CCalEntry::EEvent || entryType == CCalEntry::EAppt) {
// Assume this is an occurrence if the recurrence id is set
if (entry.RecurrenceIdL().TimeUtcL() != Time::NullTTime())
itemType = QLatin1String(QOrganizerItemType::TypeEventOccurrence);
else
itemType = QLatin1String(QOrganizerItemType::TypeEvent);
}
else if (entryType == CCalEntry::EAnniv)
itemType = QLatin1String(QOrganizerItemType::TypeEvent);
#ifdef AGENDA_EXT_SUPPORT
else if (CCalEntry::ENote == entryType) {
itemType = QLatin1String(QOrganizerItemType::TypeNote);
}
#endif
else
User::Leave(KErrUnknown); // unknown type
item->setType(itemType);
}
void CPIMAgnListAdapter::DoExternalItemModificationsByEntryTypeL(
CCalEntry::TType aEntryType)
{
JELOG2(EPim);
EnsureOpenSessionL();
if (!iChangesRead)
{
if (!iItemChangeArray)
{
iItemChangeArray
= new(ELeave) RPointerArray<CPIMItemStateChange> (10);
}
// Read all the entries in the agenda file
RPointerArray<CCalEntry> entryArray;
CCalIter* iterator = CCalIter::NewL(*iCalSession);
CleanupStack::PushL(iterator);
const TDesC8* entryId = &(iterator->FirstL());
while ((*entryId) != KNullDesC8())
{
iCalEntryView->FetchL(*entryId, entryArray);
CleanupResetAndDestroyPushL(entryArray);
// There should be at least one entry in the array. Other instances
// will be ignored since child entries are currently not supported
if (entryArray.Count() > 0)
{
// Get only the parent item from the array. Other items are
// simply ignored since PIM API does not support them
CCalEntry* entry = entryArray[0];
// Check that the entry type is correct and add the item
// to the change list
if (entry->EntryTypeL() == aEntryType)
{
HBufC8* changeId = entryId->AllocLC();
CPIMItemStateChange
* change =
new(ELeave) CPIMItemStateChange(changeId, EPIMExternalChangeNew);
CleanupStack::Pop(changeId);
CleanupStack::PushL(change);
iItemChangeArray->AppendL(change);
CleanupStack::Pop(change);
}
}
CleanupStack::PopAndDestroy(&entryArray);
// Get next calendar entry from the iterator
entryId = &(iterator->NextL());
}
CleanupStack::PopAndDestroy(iterator);
iChangesRead = ETrue;
}
}
// -----------------------------------------------------------------------------
// 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::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);
}
}
void CMultiThreadTestApp::DeleteEntryL(CCalEntryView& aView, CCalEntry::TType aType, TBool aIsSynchronous)
{
TCalTime minTime;
minTime.SetTimeUtcL(TCalTime::MinTime());
TCalTime maxTime;
maxTime.SetTimeUtcL(TCalTime::MaxTime());
if(aIsSynchronous)
{
RPointerArray<CCalEntry> entries;
CleanupResetAndDestroyPushL(entries);
FetchEntryL(aView, entries);
TInt count = entries.Count();
for (TInt ii = 0; ii < count; ++ii)
{
CCalEntry* entry = entries[ii];
if(entry->EntryTypeL() == aType)
{
aView.DeleteL(*entry);
}
}
CleanupStack::PopAndDestroy(&entries);
}
else
{
const CalCommon::TCalTimeRange timeRange(minTime, maxTime);
CalCommon::TCalViewFilter filter;
if(aType==CCalEntry::EAppt)
{
filter = CalCommon::EIncludeAppts;
}
else
{
filter = ~ (CalCommon::EIncludeAll & CalCommon::EIncludeAppts);
}
aView.DeleteL(timeRange, filter, *this);
}
}
void CTestApp::FillEntryL(CCalEntry& aEntry)
{
switch (aEntry.EntryTypeL())
{
case CCalEntry::EAppt:
{
aEntry.SetSummaryL(_L("appt"));
// the appt spans midnight
iCalTestLib->SetEntryStartAndEndTimeL(&aEntry, TTime(TDateTime(1995,EJanuary,0,20,15,0,0)), TTime(TDateTime(1995,EJanuary,1,5,15,0,0)) );
// it repeats every 2 days and has and exception
TCalRRule rRuleAppt(TCalRRule::EDaily);
TCalTime dtStartAppt;
dtStartAppt.SetTimeLocalL(TTime(TDateTime(1995,EJanuary,0,0,0,0,0)));
TCalTime untilAppt;
untilAppt.SetTimeLocalL(TTime(TDateTime(1995,EJanuary,9,0,0,0,0)));
rRuleAppt.SetDtStart(dtStartAppt);
rRuleAppt.SetUntil(untilAppt);
rRuleAppt.SetInterval(2);
aEntry.SetRRuleL(rRuleAppt);
TCalTime exception;
exception.SetTimeLocalL(TTime(TDateTime(1995,EJanuary,4,0,0,0,0)));
RArray<TCalTime> exceptions;
CleanupClosePushL(exceptions);
exceptions.AppendL(exception);
aEntry.SetExceptionDatesL(exceptions);
CleanupStack::PopAndDestroy(&exceptions);
break;
}
case CCalEntry::EEvent:
{
aEntry.SetSummaryL(_L("event"));
iCalTestLib->SetEntryStartAndEndTimeL(&aEntry, TTime(TDateTime(1995,EJanuary,0,0,0,0,0)), TTime(TDateTime(1995,EJanuary,0,0,0,0,0)));
break;
}
case CCalEntry::EAnniv:
{
aEntry.SetSummaryL(_L("anniv"));
iCalTestLib->SetEntryStartAndEndTimeL(&aEntry, TTime(TDateTime(1995,EJanuary,0,0,0,0,0)), TTime(TDateTime(1995,EJanuary,0,0,0,0,0))); // !!! WHAT'S THIS FOR ???
TCalRRule rRuleAnniv(TCalRRule::EYearly);
TCalTime dtStartAnniv;
dtStartAnniv.SetTimeLocalL(TTime(TDateTime(1994,EJanuary,0,0,0,0,0)));
TCalTime untilAnniv;
untilAnniv.SetTimeLocalL(TCalTime::MaxTime());
rRuleAnniv.SetDtStart(dtStartAnniv);
rRuleAnniv.SetUntil(untilAnniv);
rRuleAnniv.SetInterval(1);
aEntry.SetRRuleL(rRuleAnniv);
break;
}
case CCalEntry::ETodo:
{
aEntry.SetSummaryL(_L("todo"));
aEntry.SetPriorityL(1);
break;
}
}
}
