CCalAlarm* CCalAlarmAttachTest::StoreEntryWithAlarmContentLC(const TDesC8& aUid)
{
test.Printf(_L("Store an alarmed entry with alarm content\n"));
// Create 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.
HBufC8* content = KContent().AllocLC();
HBufC8* mimetype = KMimeType().AllocLC();
almContent->SetContentL(content, mimetype, CCalContent::EDispositionInline);
CleanupStack::Pop(mimetype);
CleanupStack::Pop(content);
alarm->SetAlarmAction(almContent); // Takes ownership of almContent.
CleanupStack::Pop(almContent);
//Create the entry with the alarm and store it
RPointerArray<CCalEntry> entries;
CleanupResetAndDestroyPushL(entries);
HBufC8* guid = aUid.AllocLC();
CCalEntry* entry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0);
CleanupStack::Pop(guid);
CleanupStack::PushL(entry);
entries.AppendL(entry);
CleanupStack::Pop(entry);
TCalTime calTime;
calTime.SetTimeUtcL(TDateTime(2007,EFebruary,15, 13, 30, 0, 0));
entry->SetStartAndEndTimeL(calTime, calTime);
entry->SetSummaryL(KSummary());
entry->SetDescriptionL(KDescription());
entry->SetAlarmL(alarm);
TInt entriesStored = 0;
iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored);
CleanupStack::PopAndDestroy(&entries);
return alarm;
}
void CCalAlarmAttachTest::TestDeleteAlarmWithAlarmContentL()
{
test.Printf(_L("Test deleting alarm from an entry \n"));
_LIT8(KEntryUidDeleteAlarm, "DeleteAlarmUid");
CCalAlarm* alarm = StoreEntryWithAlarmContentLC(KEntryUidDeleteAlarm());
RPointerArray<CCalEntry> entries;
CleanupResetAndDestroyPushL(entries);
//Update the entry by deleting its alarm
iTestLib->SynCGetEntryViewL().FetchL(KEntryUidDeleteAlarm(), entries);
CCalEntry* entry = entries[0];
entry->SetAlarmL(NULL);
TInt entriesStored = 0;
iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored);
//Update the entry by adding an alarm but without alarm content
entries.ResetAndDestroy();
iTestLib->SynCGetEntryViewL().FetchL(KEntryUidDeleteAlarm(), entries);
alarm->SetAlarmAction(NULL);
entry = entries[0];
entry->SetAlarmL(alarm);
iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored);
entries.ResetAndDestroy();
//Fetch the entry and test the entry has an alarm but not alarm content
iTestLib->SynCGetEntryViewL().FetchL(KEntryUidDeleteAlarm(), entries);
CCalAlarm* almEntry = entries[0]->AlarmL();
CleanupStack::PushL(almEntry);
test( almEntry != NULL );
CCalContent* alarmcontent = almEntry->AlarmAction();
test( alarmcontent == NULL );
CleanupStack::PopAndDestroy(almEntry);
CleanupStack::PopAndDestroy(&entries);
CleanupStack::PopAndDestroy(alarm);
}
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);
}
