// ----------------------------------------------------------------------------- // 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 OrganizerItemTimeStampTransform::transformToDetailL(const CCalEntry& entry, QOrganizerItem *item) { QOrganizerItemTimestamp timeStamp = item->detail<QOrganizerItemTimestamp>(); timeStamp.setCreated(toQDateTimeL(entry.DTStampL())); timeStamp.setLastModified(toQDateTimeL(entry.LastModifiedDateL())); item->saveDetail(&timeStamp); }
// ----------------------------------------------------------------------------- // 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 } } }
void CCalAlarmAttachTest::TestFetchEntryAlarmContentL() { test.Printf(_L("Test fetching entry twice and check it alarm conten\n")); _LIT8(KEntryUidFetchEntry, "FetchEntryUid"); CCalAlarm* alarm = StoreEntryWithAlarmContentLC(KEntryUidFetchEntry()); RPointerArray<CCalEntry> entries; CleanupResetAndDestroyPushL(entries); //Fetch the entry and test the alarm content iTestLib->SynCGetEntryViewL().FetchL(KEntryUidFetchEntry(), entries); TInt entriesStored = 0; iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored); entries.ResetAndDestroy(); iTestLib->SynCGetEntryViewL().FetchL(KEntryUidFetchEntry(), entries); CCalEntry* entry = entries[0]; test( KSummary() == entry->SummaryL() ); test( KDescription() == entry->DescriptionL()); TestAlarmL(entry, KContent(), KMimeType()); entries.ResetAndDestroy(); //Close the serve and fetch the entry again iTestLib->CloseAgendaServer(); iTestLib->OpenFileL(KCalName()); iTestLib->SynCGetEntryViewL().FetchL(KEntryUidFetchEntry(), entries); TestAlarmL(entries[0], KContent(), KMimeType()); CleanupStack::PopAndDestroy(&entries); CleanupStack::PopAndDestroy(alarm); }
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); }
// ----------------------------------------------------------------------------- // 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::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<TPIMField>* 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<TPIMToDoField>(fields->At(i)); ConvertToAgnL(field, aEntry, itemData); } CleanupStack::PopAndDestroy(fields); }
// ----------------------------------------------------------------------------- // 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); } }
// ----------------------------------------------------------------------------- // 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); }
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; } }
// ----------------------------------------------------------------------------- // 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)); } } }
void CMultiThreadTestApp::AddEntryL(CCalEntryView& aView, const TInt aNumToAdd) { // Add Entries for Test RTest test(KTestName); test.Next(_L("Adding entries")); TBuf<50> summary; TBuf<50> location; TBuf<50> description; RPointerArray<CCalEntry> entriesToStore; CleanupResetAndDestroyPushL(entriesToStore); for (TInt index = 0; index < aNumToAdd; ++index) { CCalEntry* entry; HBufC8* guid = HBufC8::NewL(255); TPtr8 uidP = guid->Des(); RandomText8(uidP); if( (index %2) == 0 ) { entry = CreateCalEntryL(CCalEntry::ETodo, guid); } else { entry = CreateCalEntryL(CCalEntry::EAppt, guid); } TInt err = entriesToStore.Append(entry); test(err == KErrNone); SetEntryStartAndEndTimeL(entry); RandomText(summary); entry->SetSummaryL(summary); RandomText(location); entry->SetLocationL(location); RandomText(description); entry->SetDescriptionL(description); } TInt entriesStored(0); aView.StoreL(entriesToStore, entriesStored); //temp test(entriesStored == aNumToAdd); test.Close(); CleanupStack::PopAndDestroy(&entriesToStore); }
/** Fetch the entry and check the properties that are set. @param aGuid Data for fetching the entry. @param aEntryProperties Structure containing the entry properties */ void CTestCalInterimApiFetchEntryAndCheckData::FetchAndCheckDataL(const TPtrC& aGuid, const TInt& aExpectedCount, const TEntryProperties& aEntryProperties, const TPtrC& aTimeMode) { RPointerArray<CCalEntry> entriesFetched; CleanupStack::PushL(TCleanupItem(ResetAndDestroyEntryArray, &entriesFetched)); HBufC8* entryId = HBufC8::NewLC(aGuid.Length()); entryId->Des().Copy(aGuid); iCalEntryView->FetchL(entryId->Des(), entriesFetched); CleanupStack::PopAndDestroy(entryId); TBool matchInRecurrenceId = EFalse; if ( entriesFetched.Count() == aExpectedCount ) { for ( TInt i = 0; i < entriesFetched.Count(); i++ ) { CCalEntry* calEntry = entriesFetched[i]; if ( aEntryProperties.iRecurrenceId == KNullDesC16() ) // Parent Entry { if ( calEntry->RecurrenceIdL().TimeUtcL() == Time::NullTTime() ) { // Checks the data for the parent entry CheckDataL(calEntry, aEntryProperties); } } else // Child Entry { TTime recurrenceIdValue; recurrenceIdValue.Set(aEntryProperties.iRecurrenceId); TCalTime recurrenceId; // Sets the time mode to floating or Utc based on the time mode given SetCalTimeL(recurrenceIdValue, iRecurrenceId, SetTimeMode(aTimeMode)); if (iRecurrenceId.TimeUtcL() == (calEntry->RecurrenceIdL().TimeUtcL()) ) { matchInRecurrenceId = ETrue; // Checks the data for the child entry CheckDataL(calEntry, aEntryProperties); } } } INFO_PRINTF3(KInfoEntryFetched, entriesFetched.Count(), aExpectedCount) ; } else { ERR_PRINTF3(KErrExpectedCount, entriesFetched.Count(), aExpectedCount); SetTestStepResult(EFail); } /* If the recurrence Id doesn't match with the recurrenceId of the child entry then, print a warning message */ if (aEntryProperties.iRecurrenceId != KNullDesC16() && matchInRecurrenceId == 0) { WARN_PRINTF1(KWarnNoMatchInRecurrenceId); } CleanupStack::PopAndDestroy(&entriesFetched); }
void OrganizerJournalTimeTransform::transformToDetailL(const CCalEntry& entry, QOrganizerItem *item) { if (item->type() == QOrganizerItemType::TypeJournal) { TCalTime dtstamp = entry.DTStampL(); // TODO: is DTStamp correct? if (dtstamp.TimeUtcL() != Time::NullTTime()) { QOrganizerJournalTime range; range.setEntryDateTime(toQDateTimeL(entry.DTStampL())); item->saveDetail(&range); } } }
TInt CheckTimezoneRules(const CCalEntry& aCalEntry) { //See if timezone rules are present, if they are then times should be UTC and not floating // CTzRules* tzRules = aCalEntry.TzRulesL(); TCalTime startTime = aCalEntry.StartTimeL(); if (tzRules) { test (startTime.TimeMode() != TCalTime::EFloating); } return KErrNone; }
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()); }
// ----------------------------------------------------------------------------- // 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()); } }
// ----------------------------------------------------------------------------- // 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); }
// ----------------------------------------------------------------------------- // CPIMAgnApptAdapter::UpdateItemToAgnL // Reads an Agenda Model Appt item and updates it based on the PIM item data. // ----------------------------------------------------------------------------- // void CPIMAgnApptAdapter::UpdateItemToAgnL(const MPIMEventItem& aItem, // PIM Item Data CCalEntry& aEntry) // Agenda Model entry { JELOG2(EPim); // Before updating values, empty the fields or set default values for the // fields that PIM api supports ClearPIMFieldsL(aEntry, KPIMSupportedApptFields, KPIMSupportedApptFieldsCount); // Convert fields from Java side to the native side ConvertFieldsToAgnL(aItem, aEntry); // If there is a defined repeat rule, convert it also if (aItem.IsRepeating()) { if (aItem.GetRepeat()->IsModified()) { ConvertRepeatToAgnL(aItem, aEntry); } } else { // Clear the repeat, as it might have been removed. aEntry.ClearRepeatingPropertiesL(); } }
void OrganizerTodoTimeTransform::transformToDetailL(const CCalEntry& entry, QOrganizerItem *item) { if(item->type() == QOrganizerItemType::TypeTodo || item->type() == QOrganizerItemType::TypeTodoOccurrence) { TCalTime startTime = entry.StartTimeL(); TCalTime endTime = entry.EndTimeL(); QOrganizerTodoTime range; if (startTime.TimeUtcL() != Time::NullTTime()) range.setStartDateTime(toQDateTimeL(startTime)); if (endTime.TimeUtcL() != Time::NullTTime()) range.setDueDateTime(toQDateTimeL(endTime)); if (!range.isEmpty()) item->saveDetail(&range); } }
// ----------------------------------------------------------------------------- // 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); } } } }
void CDummyCalendarApp::AddFloatingEntryWithMinStartTimeL() {//Defect fix for PDEF111562 - when a floating entry with miniman start time will never get deleted. iEntries.ResetAndDestroy(); _LIT8(KUid, "UID_MinEntry"); HBufC8* guid = KUid().AllocLC(); CCalEntry* entry = iTestLib->CreateCalEntryL(CCalEntry::EReminder, guid); CleanupStack::Pop(guid); CleanupStack::PushL(entry); TCalTime caltimestart,caltimeend; TTime min(TDateTime(1900, EJanuary, 0, 0, 0, 0, 0)); caltimestart.SetTimeLocalFloatingL(min); entry->SetStartAndEndTimeL(caltimestart,caltimestart); iEntries.AppendL(entry); CleanupStack::Pop(entry); TInt entriesStored(0); SynCGetEntryViewL().StoreL(iEntries, entriesStored); //temp iEntries.ResetAndDestroy(); }
// ----------------------------------------------------------------------------- // 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); } }
// ----------------------------------------------------------------------------- // 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); }
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; }
// ----------------------------------------------------------------------------- // 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); } }
// ----------------------------------------------------------------------------- // CPIMAgnApptAdapter::ReadEndFromAgnL // Reads Agenda entry's end field and converts it into PIM Item field. // ----------------------------------------------------------------------------- // void CPIMAgnApptAdapter::ReadEndFromAgnL(MPIMEventItem& aItem, CCalEntry& aEntry) { JELOG2(EPim); TTime agnEndTime = aEntry.EndTimeL().TimeUtcL(); if (agnEndTime != Time::NullTTime()) { TPIMFieldData fieldData(EPIMEventEnd, KPIMAttrNone, agnEndTime); aItem.ItemData().AddValueL(fieldData); } }
// ----------------------------------------------------------------------------- // 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); }
// Helper method // Extract all entries given by Guids in iCurrentTestData void CDummyCalendarApp::ExtractEntriesL(TBool aCompareWithExpectedNum, TInt aExpectedNum) { // Extract entries by the GUIDs given in current-test-data's iGuids for(TInt a = 0; a < iCurrentTestData->iGuidsToExtract.Count(); a++) { TPtrC8 guid = iCurrentTestData->iGuidsToExtract[a]; RPointerArray<CCalEntry> entryArray; CleanupStack::PushL(TCleanupItem(ResetAndDestroyCalEntryArray, &entryArray)); iEntryView->FetchL(guid, entryArray); test.Printf(_L("%d GS entries fetched\n"), entryArray.Count()); if (aCompareWithExpectedNum) { test.Printf(_L("%d entries were expected"), aExpectedNum); test(entryArray.Count() == aExpectedNum); } CCalEntry* entryPtr; for(TInt a = 0; a < entryArray.Count(); a++) { entryPtr = entryArray[a]; if(a==0) { test.Printf(_L("Parent -> SeqNum:%d\n"), entryPtr->SequenceNumberL()); } else { TBuf<16> recIdTimeBuf; TTime recIdTime = entryPtr->RecurrenceIdL().TimeLocalL(); recIdTime.FormatL(recIdTimeBuf, KFormatDate()); test.Printf(_L("Child -> SeqNum:%d, RecID: %S\n"), entryPtr->SequenceNumberL(), &recIdTimeBuf); } } CleanupStack::Pop(); // TCleanupItem(ResetAndDestroyCalEntryArray, &entryArray) entryArray.ResetAndDestroy(); } }