void CDummyCalendarApp::RepeatExceptedEntryCreateL()
{
test.Next(_L("Add entry, repeat twice, set excepted and delete"));
iEntries.ResetAndDestroy();
// Create new calendar entry.
CCalEntry* entry = NULL;
HBufC8* guid = KGUIDInc081869().AllocLC();
entry = CreateCalEntryL(CCalEntry::EAppt, guid);
CleanupStack::Pop(guid);
iEntries.AppendL(entry);
// Set start and end date.
TTime start(TDateTime(2006, EMarch, 6, 10, 0, 0, 0));
TTime end(TDateTime(2006, EMarch, 6, 14, 0, 0, 0));
SetEntryStartAndEndTimeL(entry, start, end);
TBuf<50> summary;
RandomText(summary);
entry->SetSummaryL(summary);
TBuf<50> location;
RandomText(location);
entry->SetLocationL(location);
TBuf<50> description;
RandomText(description);
entry->SetDescriptionL(description);
// Create a daily repeating rule that occurs for 2 days.
TCalRRule rpt(TCalRRule::EDaily);
rpt.SetInterval(1);
rpt.SetCount(2);
// Make sure the repeat time is within the delete time range.
TCalTime repeatStart;
TCalTime repeatEnd;
repeatStart.SetTimeLocalL(TDateTime(2006, EMarch, 6, 0, 0, 0, 0));
repeatEnd.SetTimeLocalL(TDateTime(2006, EMarch, 8, 0, 0, 0, 0));
rpt.SetDtStart(repeatStart);
rpt.SetUntil(repeatEnd);
entry->SetRRuleL(rpt);
// Store the entry. Because it repeats over 2 days, there will
// be 2 entries.
TInt entriesStored(0);
SynCGetEntryViewL().StoreL(iEntries, entriesStored);
test(entriesStored == iEntries.Count());
}
// -----------------------------------------------------------------------------
// 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);
}
void CBadRRule::CreateToDoEntryL()
{
RPointerArray<CCalEntry> entryarr ;
CleanupResetAndDestroyPushL(entryarr);
TInt num ;
HBufC8* guid = KGUID1().AllocLC(); // ownership of guid gets transferred
CCalEntry *entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0) ;
CleanupStack::Pop(guid);
CleanupStack::PushL(entry) ;
TCalTime startTime ;
TCalTime endTime ;
startTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 8, 10, 30, 0, 0))) ;
endTime.SetTimeUtcL(startTime.TimeUtcL() + TTimeIntervalDays(1)) ;
entry->SetStartAndEndTimeL(startTime, endTime) ;
TCalTime endTime1 ;
endTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 23, 10, 5, 0, 0))) ;
TCalRRule rrule(TCalRRule::EWeekly) ;
rrule.SetDtStart(startTime);
rrule.SetUntil(endTime1);
rrule.SetInterval(1);
RArray<TDay> days;
CleanupClosePushL(days);
days.AppendL(ETuesday);
rrule.SetByDay(days);
CleanupStack::PopAndDestroy(&days);
entry->SetRRuleL(rrule) ;
// both entry and rrule start time should be aligned to the first instance
TCalRRule setRRule ;
entry->GetRRuleL(setRRule) ;
test(setRRule.DtStart().TimeUtcL() == rrule.DtStart().TimeUtcL()) ;
entryarr.AppendL(entry) ;
CleanupStack::Pop(entry);
iCalEntryView->StoreL(entryarr, num) ;
entryarr.ResetAndDestroy();
TCalTime recId;
recId.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 9, 10, 30, 0, 0))); // creating recurrence id
guid = KGUID1().AllocLC(); // ownership of guid gets transferred
entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0, recId, CalCommon::EThisOnly);
CleanupStack::Pop(guid);
CleanupStack::PushL(entry) ;
TCalTime startTime3 ;
TCalTime endTime3 ;
startTime3.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 7, 10, 2, 0, 0))) ;
endTime3.SetTimeUtcL(startTime3.TimeUtcL() + TTimeIntervalHours(1)) ;
entry->SetStartAndEndTimeL(startTime3, endTime3) ;
entryarr.AppendL(entry) ;
CleanupStack::Pop(entry) ;
iCalEntryView->StoreL(entryarr, num) ;
CleanupStack::PopAndDestroy(&entryarr);
RArray<TTime> insTimes ;
insTimes.Append(TTime(TDateTime(2006, EJanuary, 7, 11, 2, 0, 0))) ;
insTimes.Append(TTime(TDateTime(2006, EJanuary, 16, 10, 30, 0, 0))) ;
CleanupClosePushL(insTimes) ;
CheckInstancesL(insTimes) ;
CleanupStack::PopAndDestroy(&insTimes) ;
// time portion of repeat's end eliminates the third instance
}
void CBadRRule::ModifyEntriesL()
{
TInt num, err ;
RPointerArray<CCalEntry> entryarr3 ;
iCalEntryView->FetchL(KGUID(), entryarr3) ;
test(entryarr3.Count() == 3) ;
/* got 3 entries - EThisAndAll of second child do not have any special effect */
CleanupStack::PushL(TCleanupItem(CleanupCCalEntryArray, &entryarr3));
TCalTime startTime4 ;
TCalTime endTime4 ;
startTime4.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 1, 10, 1, 0, 0))) ;
endTime4.SetTimeUtcL(startTime4.TimeUtcL() + TTimeIntervalHours(1)) ;
entryarr3[0]->SetStartAndEndTimeL(startTime4, endTime4) ;
//The repeating starting time will not be adjusted until the entry is stored
test(entryarr3[0]->StartTimeL().TimeUtcL() == startTime4.TimeUtcL()) ;
TCalRRule savedRRule ;
entryarr3[0]->GetRRuleL(savedRRule) ;
//The repeating starting time will not be adjusted until the entry is stored
test(savedRRule.DtStart().TimeUtcL() == startTime4.TimeUtcL()) ;
iCalEntryView->StoreL(entryarr3, num) ;
// store succeeds, because children are still aligned to an instance
CleanupStack::PopAndDestroy(&entryarr3) ;
RArray<TTime> insTimes ;
insTimes.Append(TTime(TDateTime(2006, EJanuary, 2, 10, 1, 0, 0))) ;
insTimes.Append(TTime(TDateTime(2006, EJanuary, 7, 10, 2, 0, 0))) ;
insTimes.Append(TTime(TDateTime(2006, EJanuary, 8, 11, 2, 0, 0))) ;
insTimes.Append(TTime(TDateTime(2006, EJanuary, 23, 10, 1, 0, 0))) ;
CleanupClosePushL(insTimes) ;
CheckInstancesL(insTimes) ;
CleanupStack::PopAndDestroy(&insTimes) ;
// this is interesting - there could be 4 instance, but as the count value of the
// repeat rule has been kept intact, we still get 3 instances,
// but they are shifted .
/* store is successful with modified time - now we shall change rrule */
RPointerArray<CCalEntry> entryarr4 ;
iCalEntryView->FetchL(KGUID(), entryarr4) ;
test(entryarr4.Count() == 3) ;
CleanupStack::PushL(TCleanupItem(CleanupCCalEntryArray, &entryarr4));
CCalEntry *entry = entryarr4[0] ;
TCalTime startTime1 ;
TCalTime endTime1 ;
TCalTime untilTime1 ;
startTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 16, 10, 1, 0, 0))) ;
endTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 16, 11, 1, 0, 0))) ;
untilTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 26, 10, 5, 0, 0))) ;
TCalRRule rrule(TCalRRule::EWeekly) ;
rrule.SetDtStart(startTime1);
rrule.SetUntil(untilTime1);
rrule.SetInterval(1);
RArray<TDay> days;
CleanupClosePushL(days);
days.AppendL(ETuesday);
rrule.SetByDay(days);
CleanupStack::PopAndDestroy(&days);
entry->SetStartAndEndTimeL(startTime1, endTime1);
entry->SetRRuleL(rrule) ;
TRAP(err, iCalEntryView->StoreL(entryarr4, num)) ;
test(err == -1) ; // due to change in rrule store should fail
test(num == 2) ; // only parent + child2 have been saved
CleanupStack::PopAndDestroy(&entryarr4) ;
}
void CBadRRule::CreateParentL()
{
RPointerArray<CCalEntry> entryarr ;
CleanupResetAndDestroyPushL(entryarr);
TInt num ;
HBufC8* guid = KGUID().AllocLC(); // ownership of guid gets transferred
CCalEntry *entry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0) ;
CleanupStack::Pop(guid);
CleanupStack::PushL(entry) ;
TCalTime startTime ;
TCalTime endTime ;
startTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 7, 10, 1, 0, 0))) ;
endTime.SetTimeUtcL(startTime.TimeUtcL() + TTimeIntervalHours(1)) ;
entry->SetStartAndEndTimeL(startTime, endTime) ;
TCalTime endTime1;
endTime1.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 23, 10, 5, 0, 0))) ;
TCalRRule rrule(TCalRRule::EWeekly) ;
rrule.SetDtStart(startTime);
rrule.SetUntil(endTime1);
rrule.SetInterval(1);
RArray<TDay> days;
CleanupClosePushL(days);
days.AppendL(ETuesday);
rrule.SetByDay(days);
CleanupStack::PopAndDestroy(&days);
entry->SetRRuleL(rrule) ;
TCalRRule setRRule ;
entry->GetRRuleL(setRRule) ;
test(setRRule.DtStart().TimeUtcL() == rrule.DtStart().TimeUtcL()) ;
entryarr.AppendL(entry) ;
CleanupStack::Pop(entry);
iCalEntryView->StoreL(entryarr, num) ;
entryarr.ResetAndDestroy() ;
iCalEntryView->FetchL(KGUID(), entryarr);
TCalRRule savedRRule ;
entryarr[0]->GetRRuleL(savedRRule) ;
TCalTime matchTime ; /* Jan 10, 2006 is the first Tuesday */
matchTime.SetTimeUtcL(TTime(TDateTime(2006, EJanuary, 9, 10, 1, 0, 0))) ;
//When the entry is stored, the repeat start time is adjusted so that it fits the rule (10th January is Tuesday
test(savedRRule.DtStart().TimeUtcL() == matchTime.TimeUtcL()) ;
test(entryarr[0]->StartTimeL().TimeUtcL() == (matchTime.TimeUtcL())) ;
CleanupStack::PopAndDestroy(&entryarr) ;
RArray<TTime> insTimes ;
insTimes.Append(TTime(TDateTime(2006, EJanuary, 9, 10, 1, 0, 0))) ;
insTimes.Append(TTime(TDateTime(2006, EJanuary, 16, 10, 1, 0, 0))) ;
insTimes.Append(TTime(TDateTime(2006, EJanuary, 23, 10, 1, 0, 0))) ;
CleanupClosePushL(insTimes) ;
CheckInstancesL(insTimes) ;
CleanupStack::PopAndDestroy(&insTimes) ;
}
void CDummyCalendarApp::AddEntryL(TInt aNumToAdd, TBool isParent, TBool isRepeat)
{
test.Next(_L("Adding entries"));
TBuf<50> summary;
TBuf<50> location;
TBuf<50> description;
iEntries.ResetAndDestroy();
for (TInt index=0; index<aNumToAdd; index++)
{
TBuf8<255> buf;
buf.Append(_L("GuidId"));
buf.AppendNum(index);
HBufC8* guid = buf.AllocLC(); // need to be pushed to ...
CCalEntry::TType entryType=(index%2==0)?CCalEntry::ETodo:CCalEntry::EAppt;
CCalEntry* entry = NULL;
if(isParent)
{
entry = CreateCalEntryL(entryType, guid);
}
else
{
TTime localTime(KRecurrIdLocalTime);
TCalTime recurrenceId;
recurrenceId.SetTimeLocalL(localTime);
entry = CCalEntry::NewL(entryType, guid, CCalEntry::EMethodAdd, 1, recurrenceId, CalCommon::EThisAndFuture);
}
CleanupStack::Pop(guid);
iEntries.AppendL(entry);
TInt year = -1;
TInt month = -1;
TInt day = -1;
if (isParent)
{
year = index % 5 + 2001; // Any year in the range: 2001 - 2005
month = index % 12;
day = index % 28;
}
else
{
// if this is a child entry, use the recurrence local time as the entry start time
// so it won't be out of range
TCalTime recurrId = entry->RecurrenceIdL();
TDateTime localTime = recurrId.TimeLocalL().DateTime();
year = localTime.Year();
month = localTime.Month();
day = localTime.Day();
}
TTime start(TDateTime(year, (TMonth)month, day, 0, 0, 0, 0));
TTime end(TDateTime(year, (TMonth)month, day, 0, 0, 0, 0));
end += TTimeIntervalDays(1);
SetEntryStartAndEndTimeL(entry,start,end);
RandomText(summary);
entry->SetSummaryL(summary);
RandomText(location);
entry->SetLocationL(location);
RandomText(description);
entry->SetDescriptionL(description);
if(isRepeat)
{
//create a daily repeat rule and make sure its repeat start\end date is within the deleting time range
TCalRRule rpt(TCalRRule::EDaily);
rpt.SetInterval(1);
TCalTime repeatStart;
TCalTime repeatend;
if(isParent)
{
//make sure the repeat time is within the delete time range
repeatStart.SetTimeLocalL(TDateTime(2000, EJune, 0, 0, 0, 0, 0));
repeatend.SetTimeLocalL(TDateTime(2006, EJune, 0, 0, 0, 0, 0));
}
else if (index<aNumToAdd/2)
{
// if this is a child entry, use the entry's recurrance time as repeating rule
// start time
TCalTime recurrId = entry->RecurrenceIdL();
// make sure the repeat time is within the delete time range for the first half entries
repeatStart.SetTimeLocalL(recurrId.TimeLocalL()); // June 1, 2003 00:00:00
repeatend.SetTimeLocalL(recurrId.TimeLocalL() + TTimeIntervalMonths(1)); // July 1, 2003 00:00:00
}
else
{
//make sure the repeat time is out of the delete time range for the second half entries
repeatStart.SetTimeLocalL(TDateTime(2003, EJune, 0, 0, 0, 0, 0));
repeatend.SetTimeLocalL(TDateTime(2007, EJune, 0, 0, 0, 0, 0));
}
rpt.SetDtStart(repeatStart);
rpt.SetUntil(repeatend);
entry->SetRRuleL(rpt);
}
}
TInt entriesStored(0);
iLocalEntryView->StoreL(iEntries, entriesStored); //temp
test(entriesStored == iEntries.Count());
}
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;
}
}
}
void CCalAlarmAttachTest::TestUpdateEntryHavingAlarmcontentL()
{
test.Printf(_L("Test updating an entry having AlarmContent \n"));
//Create a Calendar entry with Alarm Content
RPointerArray<CCalEntry> entries;
CleanupResetAndDestroyPushL(entries);
HBufC8* guid = KGUID1().AllocLC();
CCalEntry* calentry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0);
CleanupStack::Pop(guid);
CleanupStack::PushL(calentry);
TCalTime calTime1;
calTime1.SetTimeUtcL(TDateTime(2007,EFebruary,15, 13, 30, 0, 0));
TCalTime calTime2;
calTime2.SetTimeUtcL(TDateTime(2007,EFebruary,15, 14, 30, 0, 0));
calentry->SetStartAndEndTimeL(calTime1, calTime2);
calentry->SetSummaryL(_L("Test for Alarms"));
CCalAlarm* alarm = CCalAlarm::NewL();
CleanupStack::PushL(alarm);
alarm->SetTimeOffset(1);
CCalContent* almContent = CCalContent::NewL();
CleanupStack::PushL(almContent);
// Add content and mimetype for the alarm.
HBufC8* content = KContent().AllocLC();
HBufC8* mimetype = KMimeType().AllocLC();
// Takes ownership of content and mimetype.
almContent->SetContentL(content, mimetype, CCalContent::EDispositionInline);
alarm->SetAlarmAction(almContent); // Takes ownership of almContent.
calentry->SetAlarmL(alarm);
CleanupStack::Pop(mimetype);
CleanupStack::Pop(content);
CleanupStack::Pop(almContent);
CleanupStack::PopAndDestroy(alarm);
TCalRRule rptRule;
rptRule.SetDtStart( calTime1 );
rptRule.SetType( TCalRRule::EYearly );
rptRule.SetCount(5);
calentry->SetRRuleL(rptRule);
entries.AppendL(calentry);
// Store entry with Alarm content
TInt entriesStored = 0;
iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored);
CleanupStack::Pop(calentry);
CleanupStack::PopAndDestroy(&entries);
//Fetch stored entry and modify alarm time.
CleanupResetAndDestroyPushL(entries);
iTestLib->SynCGetEntryViewL().FetchL(KGUID1(), entries);
CCalEntry* entry = entries[0];
alarm = entry->AlarmL();
CleanupStack::PushL(alarm);
alarm->SetTimeOffset(1);
entry->SetAlarmL(alarm);
CleanupStack::PopAndDestroy(alarm);
//Update the entry with changes.
iTestLib->SynCGetEntryViewL().UpdateL(entries, entriesStored);
CleanupStack::PopAndDestroy(&entries);
//Fetch updated entry and check if Alarm content is intact.
CleanupResetAndDestroyPushL(entries);
iTestLib->SynCGetEntryViewL().FetchL(KGUID1(), entries);
TestAlarmL(entries[0], KContent(), KMimeType());
CleanupStack::PopAndDestroy(&entries);
}
/**
* Tests behaviour of the alarm attachments.
*
* Create 3 entries, a parent, and two child entries. The first child entry has
* an alarm attachment and stores the entry. The second child also has an
* attachment and stores the entry. The second child's alarm attachment data
* should overwrite the first child's alarm data.
*/
void CCalAlarmAttachTest::CreateEntriesL()
{
//-----------------------------------------------------------------------
// Create parent entry with repeat rule
//-----------------------------------------------------------------------
RPointerArray<CCalEntry> entries;
CleanupResetAndDestroyPushL(entries);
HBufC8* guid = KGUID1().AllocLC();
CCalEntry* parentEntry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0);
CleanupStack::Pop(guid);
CleanupStack::PushL(parentEntry);
TCalTime calTime1;
calTime1.SetTimeUtcL(TDateTime(2007,EFebruary,15, 13, 30, 0, 0));
TCalTime calTime2;
calTime2.SetTimeUtcL(TDateTime(2007,EFebruary,15, 14, 30, 0, 0));
parentEntry->SetStartAndEndTimeL(calTime1, calTime2);
parentEntry->SetSummaryL(_L("Test for Alarms"));
TCalRRule rptRule;
rptRule.SetDtStart( calTime1 );
rptRule.SetType( TCalRRule::EDaily );
rptRule.SetInterval( 1 );
rptRule.SetCount(5);
parentEntry->SetRRuleL(rptRule);
entries.AppendL(parentEntry);
// Store parent entry.
TInt entriesStored = 0;
iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored);
CleanupStack::Pop(parentEntry);
CleanupStack::PopAndDestroy(&entries);
//-----------------------------------------------------------------------
// Create child entry with recurrence id on 17th and with alarm attachment.
//-----------------------------------------------------------------------
RPointerArray<CCalEntry> entriesToStore1;
CleanupResetAndDestroyPushL(entriesToStore1);
TCalTime recurrenceId;
recurrenceId.SetTimeUtcL(TDateTime(2007,EFebruary,17, 13, 30, 0, 0));
HBufC8* parentGuid = KGUID1().AllocLC();
CCalEntry* childEntry1 = CCalEntry::NewL(CCalEntry::EEvent, parentGuid,
CCalEntry::EMethodNone, 0, recurrenceId, CalCommon::EThisOnly);
CleanupStack::Pop(parentGuid);
CleanupStack::PushL(childEntry1);
TCalTime calTime3;
calTime3.SetTimeUtcL(TDateTime(2007,EFebruary,21, 13, 30, 0, 0));
TCalTime calTime4;
calTime4.SetTimeUtcL(TDateTime(2007,EFebruary,21, 14, 30, 0, 0));
childEntry1->SetStartAndEndTimeL(calTime3, calTime4);
// Add an attachment to the alarm.
CCalAlarm* alarm = CCalAlarm::NewL();
CleanupStack::PushL(alarm);
alarm->SetTimeOffset(1);
CCalContent* almContent = CCalContent::NewL();
CleanupStack::PushL(almContent);
// Add content and mimetype for the alarm.
_LIT8(KContent, "C:\\test.jpg");
_LIT8(KMimeType, "mime type");
HBufC8* content = KContent().AllocLC();
HBufC8* mimetype = KMimeType().AllocLC();
// Takes ownership of content and mimetype.
almContent->SetContentL(content, mimetype, CCalContent::EDispositionInline);
alarm->SetAlarmAction(almContent); // Takes ownership of almContent.
childEntry1->SetAlarmL(alarm);
CleanupStack::Pop(mimetype);
CleanupStack::Pop(content);
CleanupStack::Pop(almContent);
CleanupStack::PopAndDestroy(alarm);
TInt entriesStored1 = 0;
entriesToStore1.AppendL(childEntry1);
iTestLib->SynCGetEntryViewL().StoreL(entriesToStore1, entriesStored1);
CleanupStack::Pop(childEntry1);
// Test if the alarm details retrieved are as expected.
CCalEntry* entry1 = entriesToStore1[0];
TestAlarmL(entry1, KContent(), KMimeType());
// Fetch the entry and ensure the alarm details are still as expected.
FetchEntryL( KContent(), KMimeType() );
CleanupStack::PopAndDestroy(&entriesToStore1);
//-----------------------------------------------------------------------
// Create another child entry with recurrence id and range same as above.
// The entry should be updated.
//-----------------------------------------------------------------------
RPointerArray<CCalEntry> entriesToStore2;
CleanupResetAndDestroyPushL(entriesToStore2);
HBufC8* parentGuid1 = KGUID1().AllocLC();
TCalTime recurrenceId1;
recurrenceId1.SetTimeUtcL(TDateTime(2007,EFebruary,17, 13, 30, 0, 0));
CCalEntry* childEntry2 = CCalEntry::NewL(CCalEntry::EEvent, parentGuid1,
CCalEntry::EMethodNone, 0, recurrenceId1, CalCommon::EThisOnly);
CleanupStack::Pop(parentGuid1);
CleanupStack::PushL(childEntry2);
TCalTime calTime5;
calTime5.SetTimeUtcL(TDateTime(2007,EFebruary,22, 13, 30, 0, 0));
TCalTime calTime6;
calTime6.SetTimeUtcL(TDateTime(2007,EFebruary,22, 14, 30, 0, 0));
childEntry2->SetStartAndEndTimeL(calTime5, calTime6);
childEntry2->SetSummaryL(_L("Update the child entry1"));
childEntry2->SetPriorityL(2);
// Add attachment to the alarm.
CCalAlarm* alarm1 = CCalAlarm::NewL();
CleanupStack::PushL(alarm1);
alarm1->SetTimeOffset(1);
CCalContent* almContent1 = CCalContent::NewL();
CleanupStack::PushL(almContent1);
// Add alarm attachment to the entry.
_LIT8(KContent1, "C:\\longtail.jpg");
_LIT8(KMimeType1, "mime type 2");
HBufC8* content1 = KContent1().AllocLC();
HBufC8* mimetype1 = KMimeType1().AllocLC();
almContent1->SetContentL(content1, mimetype1, CCalContent::EDispositionInline);
alarm1->SetAlarmAction(almContent1);
childEntry2->SetAlarmL(alarm1);
CleanupStack::Pop(mimetype1);
CleanupStack::Pop(content1);
CleanupStack::Pop(almContent1);
CleanupStack::PopAndDestroy(alarm1);
entriesToStore2.AppendL(childEntry2);
// Store the child entry.
TInt entriesStored2 = 0;
iTestLib->SynCGetEntryViewL().StoreL(entriesToStore2, entriesStored2);
// Store the entry again. The stream id for the alarm action will be
// re-used (in CAgnEntry). RAgendaServ::UpdateEntryL() will call
// CAgnEntry::UpdateAlarmAction() instead of StoreAlarmAction().
iTestLib->SynCGetEntryViewL().StoreL(entriesToStore2, entriesStored2);
CleanupStack::Pop(childEntry2);
CCalEntry* entry2 = entriesToStore2[0];
// Test if the alarm details are retrieved as expected.
TestAlarmL(entry2, KContent1(), KMimeType1());
// Fetch the entry and ensure the alarm details are still as expected.
FetchEntryL( KContent1(), KMimeType1() );
CleanupStack::PopAndDestroy(&entriesToStore2);
}
void CCalAlarmAttachTest::TestDeleteAlarmL()
{
CCalEntryView &view = iTestLib->SynCGetEntryViewL() ;
CCalEntryView *calentryview = &view ;
TInt num ;
ClearAllAlarmsL() ;
test.Printf(_L("Going to check deletion of non-snoozed alarms\n")) ;
/* create repeating parent entry */
HBufC8* guid = KGUID3().AllocLC(); // ownership of guid gets transferred
CCalEntry *entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0) ;
CleanupStack::Pop(guid);
CleanupStack::PushL(entry) ;
TTime now1;
now1.UniversalTime();
now1 += TTimeIntervalSeconds(30);
TCalTime startTime ;
TCalTime endTime ;
startTime.SetTimeUtcL(now1) ;
endTime.SetTimeUtcL(now1 + TTimeIntervalSeconds(30)) ;
entry->SetStartAndEndTimeL(startTime, endTime) ;
TCalRRule rrule(TCalRRule::EDaily) ;
rrule.SetDtStart(startTime);
TCalTime endRTime ;
endRTime.SetTimeUtcL(now1 + TTimeIntervalDays(7)) ;
rrule.SetUntil(endRTime);
rrule.SetInterval(1);
entry->SetRRuleL(rrule) ;
CCalAlarm *alarm = CCalAlarm::NewL() ;
CleanupStack::PushL(alarm) ;
alarm->SetTimeOffset(TTimeIntervalMinutes(0)) ;
entry->SetAlarmL(alarm) ; //ownership does not get transferred
RPointerArray<CCalEntry> entryarr ;
entryarr.AppendL(entry) ; //ownership does not got transferred
calentryview->StoreL(entryarr, num) ;
entryarr.Close() ;
CleanupStack::PopAndDestroy(alarm) ;
CleanupStack::PopAndDestroy(entry) ;
/* Now let the alarm go off */
RArray< TAlarmId > alarmIdArr ;
iAlarmServer.GetAlarmIdListL(alarmIdArr) ;
TInt cnt = alarmIdArr.Count() ;
test(cnt > 0) ;
TRequestStatus status = 0;
TAlarmId alarmId = alarmIdArr[0];
alarmIdArr.Close() ;
test.Printf(_L("Waiting one minute for the alarm to go off...\n")) ;
for(;;)
{
iAlarmServer.NotifyChange(status, alarmId);
User::WaitForRequest(status);
PrintEventDetails(status.Int());
if (status.Int() == EAlarmChangeEventTimerExpired)
{
break; // alarm expired
}
}
/* delete this entry - without snoozing */
RPointerArray< CCalEntry > calEntryArray ;
calentryview->FetchL(KGUID3(), calEntryArray) ;
test(calEntryArray.Count() == 1) ;
CCalEntry *entry1 = calEntryArray[0] ;
entry1->SetCompletedL(ETrue, startTime) ;
calentryview->StoreL(calEntryArray, num) ;
delete entry1 ;
calEntryArray.Close() ;
/* now check if the alarm still exists or not */
RArray< TAlarmId > alarmIdArr1 ;
iAlarmServer.GetAlarmIdListL(alarmIdArr1) ;
TInt cnt1 = alarmIdArr1.Count() ;
test(cnt1 < cnt) ;
if (cnt1 > 0)
{
TAlarmId alarmId1 = alarmIdArr1[0];
test(alarmId != alarmId1) ;
}
alarmIdArr1.Close() ;
ClearAllAlarmsL() ;
test.Printf(_L("Checking of non snoozed alarms successful\n")) ;
}
void CCalOOMTest::CreateEntriesL()
{
_LIT8(KGuid1, "Reminder-1");
_LIT8(KGuid2, "Appt-1");
_LIT(KEntryStartTime, "20121119:013000.000000"); // 20-12-2012 01.30
_LIT(KEntryEndTime, "20121119:090000.000000"); // 20-12-2012 09.00
_LIT(KTimeUntil, "20131119:013000.000000"); // 20-12-2013 01.30
_LIT(KSummary1, "THIS SUMMARY");
_LIT(KSummary2, "Appt summary");
//entry 1
HBufC8* guid8 = HBufC8::NewL(KGuid1().Length());
guid8->Des().Copy(KGuid1);
CleanupStack::PushL(guid8);
CCalEntry* entry = CCalEntry::NewL(CCalEntry::EReminder, guid8, CCalEntry::EMethodAdd, (TUint)0);
CleanupStack::Pop(guid8);
entry->SetSummaryL(KSummary1);
// entry2
guid8 = HBufC8::NewL(KGuid2().Length());
guid8->Des().Copy(KGuid2);
CleanupStack::PushL(guid8);
CCalEntry* entry2 = CCalEntry::NewL(CCalEntry::EAppt, guid8, CCalEntry::EMethodAdd, (TUint)0);
CleanupStack::Pop(guid8);
entry2->SetSummaryL(KSummary2);
TTime time1(KEntryStartTime());
TTime time2(KEntryEndTime());
TCalTime st;
st.SetTimeUtcL(time1);
TCalTime end;
end.SetTimeUtcL(time2);
entry->SetStartAndEndTimeL(st, end);
entry2->SetStartAndEndTimeL(st, end);
TCalRRule* rRule=new (ELeave) TCalRRule(TCalRRule::EDaily);
TCalTime calTime = entry->StartTimeL();
rRule->SetDtStart(calTime);
rRule->SetInterval(1);
TTime until(KTimeUntil());
TCalTime untilTime;
untilTime.SetTimeUtcL(until);
rRule->SetUntil(untilTime);
entry->SetRRuleL(*rRule);
entry2->SetRRuleL(*rRule);
TInt entriesStored(0);
RPointerArray<CCalEntry> entriesToStore;
CleanupResetAndDestroyPushL(entriesToStore);
entriesToStore.AppendL(entry);
entriesToStore.AppendL(entry2);
iTestLib->SynCGetEntryViewL().StoreL(entriesToStore, entriesStored);
delete rRule;
CleanupStack::PopAndDestroy(&entriesToStore);
// Find
_LIT(KFindSt, "20131117:013000.000000"); // The event "overlaps" with this search range, hence must be caught. The reminder must not be caught (its end time = start time).
_LIT(KFindEnd, "20131119:093000.000000");
CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll;
TestFindInstancesL(KFindSt, KFindEnd, filter); // calling OOM test function
}
