diff -r 48060abbbeaf -r b3cee849fa46 creator/engine/src/creator_calendar.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/creator/engine/src/creator_calendar.cpp Tue Aug 31 15:15:20 2010 +0300 @@ -0,0 +1,1340 @@ +/* +* Copyright (c) 2010 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: +* +*/ + + +#include "engine.h" +#include "enginewrapper.h" + +#include "creator_calendar.h" +#include "creator_traces.h" +#include "creator_scriptentry.h" +#include +#include +#include +#include + +static const TInt KCalendarFieldLength = 128; + + +CCreatorCalenderAttendee::CCreatorCalenderAttendee() + {} + +CCreatorCalenderAttendee::~CCreatorCalenderAttendee() + { + delete iCommonName; + delete iEmailAddress; + } + +CCreatorCalenderAttendee* CCreatorCalenderAttendee::NewL() + { + CCreatorCalenderAttendee* self = new (ELeave) CCreatorCalenderAttendee; + return self; + } + +void CCreatorCalenderAttendee::SetCommonNameL(const TDesC& aName) + { + delete iCommonName; + iCommonName = 0; + iCommonName = HBufC::NewL(aName.Length()); + iCommonName->Des().Copy(aName); + } + +void CCreatorCalenderAttendee::SetEmailAddressL(const TDesC& aEmail) + { + delete iEmailAddress; + iEmailAddress = 0; + iEmailAddress = HBufC::NewL(aEmail.Length()); + iEmailAddress->Des().Copy(aEmail); + } + +void CCreatorCalenderAttendee::SetRole(CCalAttendee::TCalRole aRole) + { + iRole = aRole; + } + +void CCreatorCalenderAttendee::SetStatus(CCalAttendee::TCalStatus aStatus) + { + iStatus = aStatus; + } + +const TDesC& CCreatorCalenderAttendee::CommonName() const + { + if( iCommonName == 0 ) + return iDummy; + return *iCommonName; + } + +const TDesC& CCreatorCalenderAttendee::EmailAddress() const + { + if( iEmailAddress == 0 ) + return iDummy; + + return *iEmailAddress; + } + +CCalAttendee::TCalRole CCreatorCalenderAttendee::Role() const + { + return iRole; + } + +CCalAttendee::TCalStatus CCreatorCalenderAttendee::Status() const + { + return iStatus; + } + +TBool CCalenderInterimParameters::IsAllowedEntryStatus(CCalEntry::TType aType, CCalEntry::TStatus aStatus) + { + if( aType == CCalEntry::ETodo ) + { + return aStatus == CCalEntry::ECancelled || + aStatus == CCalEntry::ETodoNeedsAction || + aStatus == CCalEntry::ETodoCompleted || + aStatus == CCalEntry::ETodoInProcess; + } + + return aStatus == CCalEntry::ETentative || + aStatus == CCalEntry::EConfirmed || + aStatus == CCalEntry::ECancelled; + } + +//---------------------------------------------------------------------------- + +CCalenderInterimParameters::CCalenderInterimParameters ( ) + { + LOGSTRING("Creator: CCalenderInterimParameters::CCalenderInterimParameters"); + + iAppointmentLocation = HBufC::New (KCalendarFieldLength ); + iAppointmentReason = HBufC::New (KCalendarFieldLength ); + iEventReason = HBufC::New (KCalendarFieldLength ); + iAnniversaryReason = HBufC::New (KCalendarFieldLength ); + iTodoTask = HBufC::New (KCalendarFieldLength ); + iReminderReason = HBufC::New (KCalendarFieldLength ); + iDescription = HBufC::New (KCalendarFieldLength ); + iSummary = HBufC::New (KCalendarFieldLength ); + iLocation = HBufC::New (KCalendarFieldLength ); + iOrganizerName = HBufC::New (KCalendarFieldLength ); + iOrganizerEmail = HBufC::New (KCalendarFieldLength ); + + // set defaults, start date today and end date = today + 1 month + iRandomModeStartTime.HomeTime ( ); + iRandomModeEndTime = iRandomModeStartTime; + iRandomModeEndTime += TTimeIntervalMonths (1 ); + iAlarmTime = Time::NullTTime(); + iUseRandomAlarmTime = EFalse; + iStatus = CCalEntry::ENullStatus; + } + +CCalenderInterimParameters::~CCalenderInterimParameters ( ) + { + LOGSTRING("Creator: CCalenderInterimParameters::~CCalenderInterimParameters"); + + delete iTodoTask; + delete iAnniversaryReason; + delete iEventReason; + delete iAppointmentReason; + delete iAppointmentLocation; + delete iReminderReason; + delete iDescription; + delete iSummary; + delete iLocation; + delete iOrganizerName; + delete iOrganizerEmail; + iAttendees.ResetAndDestroy(); + iAttendees.Close(); + iAttendeeLinkIds.Reset(); + iAttendeeLinkIds.Close(); + } + +void CCalenderInterimParameters::ParseL (CCommandParser* parser, + TParseParams aCase ) + { + LOGSTRING("Creator: CCalenderInterimParameters::ParseL"); + + HBufC* tempBuf= NULL; + + switch (aCase ) + { + + case MCreatorModuleBaseParameters::ECalendarTodo: + { + + parser->StrParserL (tempBuf, '|' ); + + CleanupStack::PushL (tempBuf ); + + this->iTodoDueTime = TTime (tempBuf->Des ( ) ); + + parser->StrParserL (this->iTodoTask, '|' ); + + parser->StrParserL (tempBuf, ';' ); + this->iTodoPriority = 2; + if (tempBuf->Compare (_L("LOW") ) == 0 ) + this->iTodoPriority = 3; + else + if (tempBuf->Compare (_L("HIGH") ) == 0 ) + this->iTodoPriority = 1; + + CleanupStack::PopAndDestroy (tempBuf ); + + } + + case MCreatorModuleBaseParameters::ECalendarMemo: + { + + parser->StrParserL (tempBuf, '|' ); + + this->iStartTime = TTime (tempBuf->Des ( ) ); + + parser->StrParserL (tempBuf, '|' ); + this->iEndTime = TTime (tempBuf->Des ( ) ); + + parser->StrParserL (this->iDescription, ';' ); + + CleanupStack::PopAndDestroy (tempBuf ); + } + + case MCreatorModuleBaseParameters::ECalendarMeeting: + { + + parser->StrParserL (tempBuf, '|' ); + + CleanupStack::PushL (tempBuf ); + + this->iStartTime = TTime (tempBuf->Des ( ) ); + + parser->StrParserL (tempBuf, '|' ); + this->iEndTime = TTime (tempBuf->Des ( ) ); + + parser->StrParserL (this->iLocation, '|' ); + parser->StrParserL (this->iDescription, ';' ); + + CleanupStack::PopAndDestroy (tempBuf ); + } + + case MCreatorModuleBaseParameters::ECalendarAnniv: + { + + parser->StrParserL (tempBuf, '|' ); + + CleanupStack::PushL (tempBuf ); + + this->iStartTime = TTime (tempBuf->Des ( ) ); + + parser->StrParserL (this->iDescription, ';' ); + + CleanupStack::PopAndDestroy (tempBuf ); + + } + default: + { + //implement + } + } + } +//---------------------------------------------------------------------------- + +CCreatorInterimCalendar* CCreatorInterimCalendar::NewL (CCreatorEngine* aEngine ) + { + CCreatorInterimCalendar* self = CCreatorInterimCalendar::NewLC (aEngine ); + CleanupStack::Pop (self ); + return self; + } + +CCreatorInterimCalendar* CCreatorInterimCalendar::NewLC (CCreatorEngine* aEngine ) + { + CCreatorInterimCalendar* self = new (ELeave) CCreatorInterimCalendar; + CleanupStack::PushL (self ); + self->ConstructL (aEngine ); + return self; + } + +CCreatorInterimCalendar::CCreatorInterimCalendar ( ) + { + } + +void CCreatorInterimCalendar::ConstructL (CCreatorEngine* aEngine ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::ConstructL"); + + iEngine = aEngine; + + // set defaults, start date today and end date = today + 1 month + iRandomModeStartTime.HomeTime ( ); + iRandomModeEndTime = iRandomModeStartTime; + iRandomModeEndTime += TTimeIntervalMonths (1 ); + + iCalSession = CCalSession::NewL ( ); + // Create and open a calendar file + const TDesC& fileName = iCalSession->DefaultFileNameL ( );//default filename is: "C:Calendar" + TRAPD(err, iCalSession->CreateCalFileL(fileName)) + ; + // ignore KErrAlreadyExists leave code + if (err != KErrAlreadyExists ) + { + User::LeaveIfError (err ); + } + // Open the calendar file + iCalSession->OpenL (fileName ); + iCalEntryView = CCalEntryView::NewL (*iCalSession, *this ); + iNumberRepeatingEntries = 0; + iNumberOfAttendees = 0; //iEngine->RandomNumber(2, 15); + iSetAlarm = EFalse; + iWaiter = CAsyncWaiter::NewL(); + } + +CCreatorInterimCalendar::~CCreatorInterimCalendar ( ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::~CCreatorInterimCalendar"); + + if ( iEngine && iEntryIds.Count() ) + { + TRAP_IGNORE( iEngine->WriteEntryIdsToStoreL( iEntryIds, KUidDictionaryUidCalendar ) ); + } + + iEntryIds.Reset(); + iEntryIds.Close(); + + if (iParameters ) + { + delete iParameters; + } + + if (iCalEntryView ) + { + delete iCalEntryView; + } + + if (iCalSession ) + { + delete iCalSession; + } + delete iSoundFileArray; + delete iWaiter; + delete iTmpCN; + delete iTmpEmail; + } + +//---------------------------------------------------------------------------- + +void CCreatorInterimCalendar::QueryDialogClosedL(TBool aPositiveAction, TInt aUserData) + { + LOGSTRING("Creator: CCreatorInterimCalendar::QueryDialogClosedL"); + + if( aPositiveAction == EFalse && aUserData != ECreatorCalendarAddDefaultAlarm ) + { + iEngine->ShutDownEnginesL(); + return; + } + + const TDesC* showText = &KSavingText; + TBool finished(EFalse); + TBool retval(ETrue); + switch(aUserData) + { + case ECreatorCalendarDelete: + iEntriesToBeCreated = 1; + showText = &KDeletingText; + finished = ETrue; + break; + case ECreatorCalendarStart: + if( iCommand == ECmdCreateCalendarEntryEvents || iCommand == ECmdCreateCalendarEntryAppointments ) + { + _LIT(KRepeatingNum, "How many repeating (weekly) entries"); + retval = iEngine->GetEngineWrapper()->EntriesQueryDialog(&iNumberRepeatingEntries, KRepeatingNum, ETrue, this, ECreatorCalendarGetWeeklyEntries); + } + else + { + _LIT(KStartPeriodDate, "Start date of creation period");// \n dd/mm/yyyy + retval = iEngine->GetEngineWrapper()->TimeQueryDialog(&iRandomModeStartTime, KStartPeriodDate, this, ECreatorCalendarGetStartDate); // ask start date + } + break; + case ECreatorCalendarGetWeeklyEntries: + _LIT(KAttendeesNum, "How many attendees to create"); + retval = iEngine->GetEngineWrapper()->EntriesQueryDialog(&iNumberOfAttendees, KAttendeesNum, ETrue, this, ECreatorCalendarGetAttendies); + break; + case ECreatorCalendarGetAttendies: + { + // ask start date + _LIT(KStartPeriodDate, "Start date of creation period"); + retval = iEngine->GetEngineWrapper()->TimeQueryDialog(&iRandomModeStartTime, KStartPeriodDate, this, ECreatorCalendarGetStartDate ); + } + break; + case ECreatorCalendarGetStartDate: + { + _LIT(KEndPeriodDate, "End date of creation period\n dd/mm/yyyy"); + iEngine->GetEngineWrapper()->TimeQueryDialog (&iRandomModeEndTime, KEndPeriodDate, this, ECreatorCalendarGetEndDate ); // ask end date + } + break; + case ECreatorCalendarGetEndDate: + if (iRandomModeStartTime > iRandomModeEndTime ) // check end date is ok + { + iEngine->GetEngineWrapper()->ShowNote(_L("End date must be after start date") ); + retval = EFalse; + } + else + { + retval = iEngine->GetEngineWrapper()->YesNoQueryDialog(_L("Add default alarm?"), this, ECreatorCalendarAddDefaultAlarm); + } + break; + case ECreatorCalendarAddDefaultAlarm: + iSetAlarm = aPositiveAction; + finished = ETrue; + break; + default: + //some error + retval = EFalse; + break; + } + if( retval == EFalse ) + { + iEngine->ShutDownEnginesL(); + } + else if( finished ) + { + // add this command to command array + iEngine->AppendToCommandArrayL(iCommand, NULL, iEntriesToBeCreated); + // started exucuting commands + iEngine->ExecuteFirstCommandL( *showText ); + } + } + +//---------------------------------------------------------------------------- + +TBool CCreatorInterimCalendar::AskDataFromUserL( TInt aCommand ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::AskDataFromUserL"); + + CCreatorModuleBase::AskDataFromUserL( aCommand );//ignore retval + + if( aCommand == ECmdDeleteCalendarEntries ) + { + return iEngine->GetEngineWrapper()->YesNoQueryDialog(_L("Delete all calendar entries?"), this, ECreatorCalendarDelete ); + } + if( aCommand == ECmdDeleteCreatorCalendarEntries ) + { + return iEngine->GetEngineWrapper()->YesNoQueryDialog(_L("Delete all calendar entries created with Creator?"), this, ECreatorCalendarDelete ); + } + + // display queries + return iEngine->GetEngineWrapper()->EntriesQueryDialog(&iEntriesToBeCreated, _L("How many entries to create?"), EFalse, this, ECreatorCalendarStart ); // ask number of entries to create + } + +//---------------------------------------------------------------------------- + +TInt CCreatorInterimCalendar::CreateAppointmentEntryL ( + CCreatorModuleBaseParameters *aParameters ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::CreateAppointmentEntryL"); + + delete iParameters; + iParameters = 0; + + CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters; + + if( !parameters ) + { + iParameters = new(ELeave) CCalenderInterimParameters; + parameters = iParameters; + parameters->iRandomModeStartTime = iRandomModeStartTime; + parameters->iRandomModeEndTime = iRandomModeEndTime; + + // difference between start and end times + TTimeIntervalMinutes differenceInMinutes; + parameters->iRandomModeEndTime.MinutesFrom ( + parameters->iRandomModeStartTime, differenceInMinutes ); + + // start time (= something between the period start and end date) + parameters->iStartTime = parameters->iRandomModeStartTime; + parameters->iStartTime + += TTimeIntervalMinutes (iEngine->RandomNumber (differenceInMinutes.Int ( ) ) ); + // set end time (= start time + some random time) + parameters->iEndTime = parameters->iStartTime; + parameters->iEndTime + += TTimeIntervalMinutes (iEngine->RandomNumber (5, 500 ) ); + + + // strings + parameters->iLocation->Des ( ) + = iEngine->RandomString (CCreatorEngine::EMeetingPlace ); + parameters->iDescription->Des ( ) + = iEngine->RandomString (CCreatorEngine::EMeetingReason ); + + parameters->iSummary->Des() + = parameters->iDescription->Des(); + + parameters->iNumberRepeatingEntries = iNumberRepeatingEntries; + parameters->iNumberOfAttendees = iNumberOfAttendees; + } + + TInt err = KErrNone; + HBufC8* guid = HBufC8::NewLC (255 ); + TPtr8 uidP=guid->Des ( ); + GenerateRandomId (uidP ); + CCalEntry* entry = CCalEntry::NewL (CCalEntry::EAppt, guid, + CCalEntry::EMethodAdd, 0 ); + CleanupStack::PushL (entry ); + + //Using same text as description and summary + entry->SetDescriptionL (parameters->iDescription->Des ( ) ); + entry->SetSummaryL (parameters->iSummary->Des ( ) ); + entry->SetLocationL (parameters->iLocation->Des ( ) ); + + TCalTime startTime; + TCalTime endTime; + // Set the start and end times using time values local to the current system time zone + TInt month = (TInt) parameters->iStartTime.DateTime().Month(); + TInt date = parameters->iStartTime.DateTime().Day(); + startTime.SetTimeLocalL (parameters->iStartTime ); + endTime.SetTimeLocalL (parameters->iEndTime ); + entry->SetStartAndEndTimeL (startTime, endTime ); + + if( parameters->IsAllowedEntryStatus(CCalEntry::EAppt, parameters->iStatus)) + { + LOGSTRING2("Creator: CCreatorInterimCalendar::CreateAppointmentEntryL setting entry status: %d", parameters->iStatus); + entry->SetStatusL(parameters->iStatus); + } + + // Repeating times: + AddRepeatingRuleL(startTime, *entry, parameters); + SetOrganizerL(*entry, parameters); + + // Alarm: + if( iSetAlarm || parameters->iUseRandomAlarmTime ) + { + SetRandomAlarmL(*entry); + } + else + { + SetAlarmL(*entry, parameters); + } + + // Add attendees: + AddAttendeesL(*entry, parameters); + + RPointerArray array; + CleanupClosePushL (array ); + array.AppendL (entry ); + + TInt success(0); + //If StoreL() leaves, 'success' contains the number of entries that were stored before it failed + iCalEntryView->StoreL (array, success ); + + // id has been generated, store it for being able to delete + // entries created only with Creator + iEntryIds.Append( entry->LocalUidL() ); + + //One item should be added at time + if (success != 1 ) + { + err = 1; + } + + CleanupStack::PopAndDestroy (&array ); + CleanupStack::PopAndDestroy (entry ); + CleanupStack::Pop (guid );//guid has been destroyed by entry, which has ownership to guid + + return err; + } + +void CCreatorInterimCalendar::SetOrganizerL(CCalEntry& aCalEntry, CCalenderInterimParameters* parameters ) + { + HBufC* orgName = 0; + HBufC* orgEmail = 0; + _LIT(KSpace, " "); + + // + // Common name + // + if( parameters == 0 || + parameters->iOrganizerName == 0 || + parameters->iOrganizerName->Length() == 0 ) + { + // Random: + TPtrC firstname = iEngine->RandomString(CCreatorEngine::EFirstName); + TPtrC lastname = iEngine->RandomString(CCreatorEngine::ESurname); + orgName = HBufC::NewL(firstname.Length() + lastname.Length() + 1 ); + CleanupStack::PushL(orgName); + orgName->Des().Copy(firstname); + orgName->Des().Append(KSpace); + orgName->Des().Append(lastname); + } + else + { + orgName = HBufC::NewL(parameters->iOrganizerName->Length()); + CleanupStack::PushL(orgName); + orgName->Des().Copy(parameters->iOrganizerName->Des()); + } + + // + // Email + // + if( parameters == 0 || + parameters->iOrganizerEmail == 0 || + parameters->iOrganizerEmail->Length() == 0 ) + { + // Random: + TDesC* tmp = iEngine->CreateEmailAddressLC(); + orgEmail = HBufC::NewL(tmp->Length()); + orgEmail->Des().Copy(*tmp); + CleanupStack::PopAndDestroy(); // tmp + CleanupStack::PushL(orgEmail); + } + else + { + orgEmail = HBufC::NewL(parameters->iOrganizerEmail->Length()); + CleanupStack::PushL(orgEmail); + orgEmail->Des().Copy(parameters->iOrganizerEmail->Des()); + } + + SetOrganizerL(aCalEntry, orgName->Des(), orgEmail->Des(), orgEmail->Des()); + CleanupStack::PopAndDestroy(); // orgName + CleanupStack::PopAndDestroy(); // orgEmail + } + +void CCreatorInterimCalendar::AddRepeatingRuleL(const TCalTime& aStartTime, CCalEntry& aCalEntry, CCalenderInterimParameters* parameters ) + { + RArray days; + CleanupClosePushL(days); + + // Recurrence rule. Weekly event. + if( parameters->iNumberRepeatingEntries > 0 ) + { + TCalRRule calRepeat(TCalRRule::EWeekly); + calRepeat.SetDtStart(aStartTime); + calRepeat.SetCount(parameters->iNumberRepeatingEntries); + calRepeat.SetInterval(1); + //days.AppendL((TDay) iEngine->RandomNumber((TInt)EMonday, (TInt) ESunday)); + TDay tempDay(aStartTime.TimeLocalL().DayNoInWeek()); + days.AppendL(tempDay); + calRepeat.SetByDay(days); + aCalEntry.SetRRuleL(calRepeat); + } + else if(parameters->iRecurrentFrequency > TCalRRule::EInvalid) + { + TCalTime calTime; + // Recurrent frequency + TCalRRule calRepeat(parameters->iRecurrentFrequency); + // Recurrent start + calRepeat.SetDtStart(aStartTime); + if( parameters->iRecurrentFrequency == TCalRRule::EWeekly ) + { + TDay tempDay(aStartTime.TimeLocalL().DayNoInWeek()); + days.AppendL(tempDay); + calRepeat.SetByDay(days); + } + else if( parameters->iRecurrentFrequency == TCalRRule::EMonthly ) + { + RArray< TInt > daysInMonth; + CleanupClosePushL(daysInMonth); + daysInMonth.AppendL(aStartTime.TimeLocalL().DayNoInMonth()); + calRepeat.SetByMonthDay(daysInMonth); + CleanupStack::PopAndDestroy(&daysInMonth); + } + else if( parameters->iRecurrentFrequency == TCalRRule::EYearly) + { + RArray< TMonth > monthsInYear; + CleanupClosePushL(monthsInYear); + monthsInYear.AppendL(aStartTime.TimeLocalL().DateTime().Month()); + calRepeat.SetByMonth(monthsInYear); + CleanupStack::PopAndDestroy(&monthsInYear); + } + + // Recurrent interval + if( parameters->iRecurrentInterval > 0 ) + calRepeat.SetInterval(parameters->iRecurrentInterval); + + // Recurrent end. End can be given as a number of repeating entries or as an end date. + // End date must be later than the start date, otherwise CCalEntry::SetRRuleL() panics. + if( parameters->iRepeatingCount > 0 ) + { + calRepeat.SetCount(parameters->iRepeatingCount); + aCalEntry.SetRRuleL(calRepeat); + } + else + { + TCalTime endTime; + endTime.SetTimeLocalL(parameters->iRecurrentEndTime); + if( endTime.TimeLocalL() > aStartTime.TimeLocalL()) + { + calRepeat.SetUntil(endTime); + aCalEntry.SetRRuleL(calRepeat); + } + } + } + CleanupStack::PopAndDestroy(&days); + } + +void CCreatorInterimCalendar::SetAlarmL(CCalEntry& aCalEntry, CCalenderInterimParameters* params) + { + if( params->iAlarmTime != Time::NullTTime() ) + { + CCalAlarm* alarm = CCalAlarm::NewL(); + CleanupStack::PushL(alarm); + //if( params->iAlarmTime <= params->iStartTime ) + // { + TTimeIntervalMinutes diff; + TInt err = params->iStartTime.MinutesFrom(params->iAlarmTime, diff); + if( err == KErrNone) + { + alarm->SetTimeOffset(diff); + TRAP(err, aCalEntry.SetAlarmL(alarm)); + if( err != KErrNone && err != KErrNotSupported ) + { + User::Leave(err); + } + } + // } + CleanupStack::PopAndDestroy(alarm); + } + } + +void CCreatorInterimCalendar::SetRandomAlarmL(CCalEntry& aCalEntry) + { + CCalAlarm* alarm = CCalAlarm::NewL(); + CleanupStack::PushL(alarm); + alarm->SetTimeOffset(TTimeIntervalMinutes(iEngine->RandomNumber(0, 60))); + + TRAPD(err, aCalEntry.SetAlarmL(alarm)); + if( err != KErrNone && err != KErrNotSupported ) + { + User::Leave(err); + } + CleanupStack::PopAndDestroy(alarm); + } + +void CCreatorInterimCalendar::SetPhoneOwnerL(CCalEntry& aCalEntry, const TDesC& aCN, const TDesC& aEmail, const TDesC& aSentBy ) + { + CCalUser* phOwner = CCalUser::NewL(aEmail, aSentBy); + CleanupStack::PushL(phOwner); + TRAPD(err, aCalEntry.SetPhoneOwnerL(phOwner)); + CleanupStack::Pop(phOwner); + if( err == KErrNone ) + { + phOwner->SetCommonNameL(aCN); + } + else + { + delete phOwner; + } + } + +void CCreatorInterimCalendar::SetOrganizerL(CCalEntry& aCalEntry, const TDesC& aCN, const TDesC& aEmail, const TDesC& aSentBy) + { + CCalUser* organizer = CCalUser::NewL(aEmail, aSentBy); + CleanupStack::PushL(organizer); + TRAPD(err, aCalEntry.SetOrganizerL(organizer)); + CleanupStack::Pop(organizer); + if( err == KErrNone ) + { + organizer->SetCommonNameL(aCN); + } + else + { + delete organizer; + } + } + +void CCreatorInterimCalendar::AddAttendeesL(CCalEntry& aCalEntry, CCalenderInterimParameters* parameters ) + { + if( !parameters ) + return; + + // Random attendees: + TInt numOfAttendees = parameters->iNumberOfAttendees; + for( TInt i = 0; i < numOfAttendees; ++i ) + { + TPtrC firstname = iEngine->RandomString(CCreatorEngine::EFirstName); + TPtrC lastname = iEngine->RandomString(CCreatorEngine::ESurname); + TPtrC company = iEngine->RandomString(CCreatorEngine::ECompany); + _LIT(KCountry, "com"); + TDesC* emailAddr = iEngine->CreateEmailAddressLC(firstname, lastname, company, KCountry); + CCalAttendee* attendee = CCalAttendee::NewL(*emailAddr); + CleanupStack::PushL(attendee); + aCalEntry.AddAttendeeL(attendee); + CleanupStack::Pop(attendee); + attendee->SetCommonNameL(firstname); + + // Set phone owner: + if( i == 1 ) + { + SetPhoneOwnerL(aCalEntry, firstname, *emailAddr, *emailAddr); + attendee->SetRoleL(CCalAttendee::EReqParticipant); + } + // Set organizer: + else if ( i == 0 ) + { + // Organizer is the chairman of the meeting: + SetOrganizerL(aCalEntry, firstname, *emailAddr, *emailAddr); + attendee->SetRoleL(CCalAttendee::EChair); + } + else if( i % 3 == 0 ) + { + // every third attendee is optional: + attendee->SetRoleL(CCalAttendee::EOptParticipant); + } + else + { + // Others are required attendees: + attendee->SetRoleL(CCalAttendee::EReqParticipant); + } + + TInt attStatus = iEngine->RandomNumber(0,5); + attendee->SetStatusL((CCalAttendee::TCalStatus) attStatus); + + CleanupStack::PopAndDestroy(emailAddr); + } + + // Explicit attendees: + for( TInt i = 0; i < parameters->iAttendees.Count(); ++i ) + { + CCreatorCalenderAttendee* attendeeInfo = parameters->iAttendees[i]; + if( attendeeInfo && attendeeInfo->EmailAddress().Length() > 0) + { + CCalAttendee* attendee = CCalAttendee::NewL(attendeeInfo->EmailAddress()); + CleanupStack::PushL(attendee); + if( attendeeInfo->CommonName().Length() > 0 ) + attendee->SetCommonNameL(attendeeInfo->CommonName()); + attendee->SetRoleL(attendeeInfo->Role()); + attendee->SetStatusL(attendeeInfo->Status()); + attendee->SetResponseRequested(ETrue); + aCalEntry.AddAttendeeL(attendee); + CleanupStack::Pop(); // attendee + } + } + } +//---------------------------------------------------------------------------- + +TInt CCreatorInterimCalendar::CreateEventEntryL ( + CCreatorModuleBaseParameters *aParameters ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::CreateEventEntryL"); + + delete iParameters; + iParameters = 0; + + CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters; + + // random data needed if no predefined data available + if (!parameters ) + { + iParameters = new(ELeave) CCalenderInterimParameters; + + iParameters->iRandomModeStartTime = iRandomModeStartTime; + iParameters->iRandomModeEndTime = iRandomModeEndTime; + iParameters->iNumberRepeatingEntries = iNumberRepeatingEntries; + iParameters->iNumberOfAttendees = iNumberOfAttendees; + + // difference between start and end times + TTimeIntervalMinutes differenceInMinutes; + iParameters->iRandomModeEndTime.MinutesFrom ( + iParameters->iRandomModeStartTime, differenceInMinutes ); + + // start time (= something between the period start and end date) + iParameters->iStartTime = iParameters->iRandomModeStartTime; + iParameters->iStartTime + += TTimeIntervalMinutes (iEngine->RandomNumber (differenceInMinutes.Int ( ) ) ); + + // set end time (= start time + some random time) + iParameters->iEndTime = iParameters->iStartTime; + iParameters->iEndTime + += TTimeIntervalMinutes (iEngine->RandomNumber (5, 500 ) ); + + // strings + iParameters->iDescription->Des() + = iEngine->RandomString (CCreatorEngine::EMemoText ); + + iParameters->iSummary->Des() = iParameters->iDescription->Des(); + + // Random event status: + iParameters->iStatus = + (CCalEntry::TStatus) iEngine->RandomNumber(0, (TInt) CCalEntry::ECancelled); + + parameters = iParameters; + } + + TInt err = KErrNone; + HBufC8* guid = HBufC8::NewLC (255 ); + TPtr8 uidP=guid->Des ( ); + GenerateRandomId (uidP ); + CCalEntry* entry = CCalEntry::NewL (CCalEntry::EEvent, guid, + CCalEntry::EMethodAdd, 0 ); + CleanupStack::PushL (entry ); + // iEntryUids->AppendL( *guid->Alloc() ); + + entry->SetDescriptionL (parameters->iDescription->Des ( ) ); + entry->SetSummaryL (parameters->iSummary->Des ( ) ); + + TCalTime startTime; + TCalTime endTime; + // Set the start and end times using time values local to the current system time zone + startTime.SetTimeLocalL (parameters->iStartTime ); + endTime.SetTimeLocalL (parameters->iEndTime ); + entry->SetStartAndEndTimeL (startTime, endTime ); + + // Repeating times: + AddRepeatingRuleL(startTime, *entry, parameters); + + if( iSetAlarm || parameters->iUseRandomAlarmTime ) + { + SetRandomAlarmL(*entry); + } + else + { + SetAlarmL(*entry, parameters); + } + + // Add attendees: + AddAttendeesL(*entry, parameters); + + if( parameters->IsAllowedEntryStatus(CCalEntry::EEvent, parameters->iStatus)) + { + LOGSTRING2("Creator: CCreatorInterimCalendar::CreateEventEntryL setting entry status: %d", parameters->iStatus); + entry->SetStatusL(parameters->iStatus); + } + + RPointerArray array; + CleanupClosePushL (array ); + array.AppendL (entry ); + + TInt success(0); + //If StoreL() leaves, 'success' contains the number of entries that were stored before it failed + iCalEntryView->StoreL (array, success ); + + // id has been generated, store it for being able to delete + // entries created only with Creator + iEntryIds.Append( entry->LocalUidL() ); + + //One item should be added at time + if (success != 1 ) + { + err = 1; + } + + CleanupStack::PopAndDestroy (&array ); + CleanupStack::PopAndDestroy (entry ); + CleanupStack::Pop (guid );//guid has been destroyed by entry, which has ownership to guid + return err; + + } + +//---------------------------------------------------------------------------- + + +TInt CCreatorInterimCalendar::CreateReminderEntryL ( + CCreatorModuleBaseParameters *aParameters ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::CreateReminderEntryL"); + + delete iParameters; + iParameters = NULL; + + CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters; + + // random data needed if no predefined data available + if (!parameters ) + { + iParameters = new(ELeave) CCalenderInterimParameters; + + iParameters->iRandomModeStartTime = iRandomModeStartTime; + iParameters->iRandomModeEndTime = iRandomModeEndTime; + + // difference between start and end times + TTimeIntervalDays + differenceInDays = iParameters->iRandomModeEndTime.DaysFrom (iParameters->iRandomModeStartTime ); + + // due time (= something between the period start and end date) + iParameters->iStartTime = iParameters->iRandomModeStartTime; + iParameters->iStartTime + += TTimeIntervalDays (iEngine->RandomNumber (differenceInDays.Int ( ) ) ); + + // strings + iParameters->iDescription->Des() + = iEngine->RandomString (CCreatorEngine::EReminderText ); + + iParameters->iSummary->Des() = iParameters->iDescription->Des(); + + parameters = iParameters; + } + + TInt err = KErrNone; + + HBufC8* guid = HBufC8::NewLC (255 ); + TPtr8 uidP=guid->Des ( ); + GenerateRandomId (uidP ); + + CCalEntry* entry = CCalEntry::NewL (CCalEntry::EReminder, guid, + CCalEntry::EMethodAdd, 0 ); + CleanupStack::PushL (entry ); + + //Using same text as description and summary + entry->SetDescriptionL (parameters->iDescription->Des ( ) ); + entry->SetSummaryL (parameters->iSummary->Des ( ) ); + + TCalTime startTime; + TCalTime endTime; + // Set the start and end times using time values local to the current system time zone + startTime.SetTimeLocalL (parameters->iStartTime ); + TTime nullTime = Time::NullTTime ( ); + endTime.SetTimeLocalL (nullTime ); + entry->SetStartAndEndTimeL (startTime, endTime ); + + if( parameters->IsAllowedEntryStatus(CCalEntry::EReminder, parameters->iStatus)) + { + LOGSTRING2("Creator: CCreatorInterimCalendar::CreateReminderEntryL setting entry status: %d", parameters->iStatus); + entry->SetStatusL(parameters->iStatus); + } + + if( iSetAlarm || parameters->iUseRandomAlarmTime ) + { + SetRandomAlarmL(*entry); + } + else + { + SetAlarmL(*entry, parameters); + } + + RPointerArray array; + CleanupClosePushL (array ); + array.AppendL (entry ); + + TInt success(0); + //If StoreL() leaves, 'success' contains the number of entries that were stored before it failed + iCalEntryView->StoreL (array, success ); + + // id has been generated, store it for being able to delete + // entries created only with Creator + iEntryIds.Append( entry->LocalUidL() ); + + //One item should be added at time + if (success != 1 ) + { + err = 1; + } + + CleanupStack::PopAndDestroy (&array ); + CleanupStack::PopAndDestroy (entry ); + CleanupStack::Pop (guid );//guid has been destroyed by entry, which has ownership to guid + + return err; + } + +//---------------------------------------------------------------------------- + +TInt CCreatorInterimCalendar::CreateAnniversaryEntryL ( + CCreatorModuleBaseParameters *aParameters ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::CreateAnniversaryEntryL"); + + delete iParameters; + iParameters = NULL; + + CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters; + + // random data needed if no predefined data available + if (!parameters ) + { + iParameters = new(ELeave) CCalenderInterimParameters; + + iParameters->iRandomModeStartTime = iRandomModeStartTime; + iParameters->iRandomModeEndTime = iRandomModeEndTime; + + // difference between start and end times + TTimeIntervalDays differenceInDays = iParameters->iRandomModeEndTime.DaysFrom(iParameters->iRandomModeStartTime); + + // start time (= something between the period start and end date) + iParameters->iStartTime = iParameters->iRandomModeStartTime; + iParameters->iStartTime += TTimeIntervalDays( iEngine->RandomNumber(differenceInDays.Int()) ); + + // strings + iParameters->iDescription->Des().Copy (iEngine->RandomString (CCreatorEngine::EFirstName ) ); + iParameters->iDescription->Des().Append ( _L("'s ") ); + iParameters->iDescription->Des().Append (iEngine->RandomString (CCreatorEngine::EAnniversaryReason ) ); + iParameters->iSummary->Des() = iParameters->iDescription->Des(); + parameters = iParameters; + } + + TInt err = KErrNone; + + HBufC8* guid = HBufC8::NewLC (255 ); + TPtr8 uidP=guid->Des ( ); + GenerateRandomId (uidP ); + + CCalEntry* entry = CCalEntry::NewL (CCalEntry::EAnniv, guid, + CCalEntry::EMethodNone, 0 ); + CleanupStack::PushL (entry ); + + //Using same text as description and summary + entry->SetDescriptionL (parameters->iDescription->Des ( ) ); + entry->SetSummaryL (parameters->iSummary->Des ( ) ); + + TCalTime startTime; + TCalTime endTime; + TTime nullTime = Time::NullTTime ( ); + endTime.SetTimeLocalL (nullTime ); + + // Set the start time using time value local to the current system time zone + startTime.SetTimeLocalL (parameters->iStartTime ); + + entry->SetStartAndEndTimeL (startTime, endTime ); + + if( iSetAlarm || parameters->iUseRandomAlarmTime ) + { + SetRandomAlarmL(*entry); + } + else + { + SetAlarmL(*entry, parameters); + } + + //set repeating rule + TCalRRule yearlyRptRule(TCalRRule::EYearly); + yearlyRptRule.SetDtStart (startTime ); + //Set repeating until forever, not setting it to stop + //yearlyRptRule.SetUntil(endTime); + entry->SetRRuleL (yearlyRptRule ); + + RPointerArray array; + CleanupClosePushL (array ); + array.AppendL (entry ); + + TInt success(0); + //If StoreL() leaves, 'success' contains the number of entries that were stored before it failed + iCalEntryView->StoreL (array, success ); + + // id has been generated, store it for being able to delete + // entries created only with Creator + iEntryIds.Append( entry->LocalUidL() ); + + //One item should be added at time + if (success != 1 ) + { + err = 1; + } + + CleanupStack::PopAndDestroy (&array ); + CleanupStack::PopAndDestroy (entry ); + CleanupStack::Pop (guid );//guid has been destroyed by entry, which has ownership to guid + + return err; + } + +//---------------------------------------------------------------------------- + +TInt CCreatorInterimCalendar::CreateTodoEntryL ( + CCreatorModuleBaseParameters *aParameters ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::CreateTodoEntryL"); + + delete iParameters; + iParameters = NULL; + + CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters; + + // random data needed if no predefined data available + if (!parameters ) + { + iParameters = new(ELeave) CCalenderInterimParameters; + + iParameters->iRandomModeStartTime = iRandomModeStartTime; + iParameters->iRandomModeEndTime = iRandomModeEndTime; + + // difference between start and end times + TTimeIntervalDays + differenceInDays = iParameters->iRandomModeEndTime.DaysFrom (iParameters->iRandomModeStartTime ); + + // due time (= something between the period start and end date) + iParameters->iTodoDueTime = iParameters->iRandomModeStartTime; + iParameters->iTodoDueTime + += TTimeIntervalDays (iEngine->RandomNumber (differenceInDays.Int ( ) ) ); + + // strings + iParameters->iDescription->Des ( ) + = iEngine->RandomString (CCreatorEngine::EToDoText ); + + iParameters->iSummary->Des() = iParameters->iDescription->Des(); + + //priority + iParameters->iTodoPriority = iEngine->RandomNumber (1, 3 ); + iParameters->iStatus = (CCalEntry::TStatus) iEngine->RandomNumber((TInt) CCalEntry::ETodoNeedsAction, (TInt) CCalEntry::ETodoInProcess); + parameters = iParameters; + + } + + TInt err = KErrNone; + + HBufC8* guid = HBufC8::NewLC (255 ); + TPtr8 uidP=guid->Des ( ); + GenerateRandomId (uidP ); + + CCalEntry* entry = CCalEntry::NewL (CCalEntry::ETodo, guid, + CCalEntry::EMethodAdd, 0 ); + CleanupStack::PushL (entry ); + + //Using same text as description and summary + entry->SetDescriptionL (parameters->iDescription->Des ( ) ); + entry->SetSummaryL (parameters->iSummary->Des ( ) ); + + entry->SetPriorityL (parameters->iTodoPriority ); + + if( parameters->IsAllowedEntryStatus(CCalEntry::ETodo, parameters->iStatus)) + { + LOGSTRING2("Creator: CCreatorInterimCalendar::CreateTodoEntryL setting entry status: %d", parameters->iStatus); + entry->SetStatusL(parameters->iStatus); + } + + TCalTime startTime; + TCalTime endTime; + // Set the start and end times using time values local to the current system time zone + startTime.SetTimeLocalL (parameters->iTodoDueTime ); + endTime.SetTimeLocalL (parameters->iTodoDueTime ); + entry->SetStartAndEndTimeL (startTime, endTime ); + + if( iSetAlarm || parameters->iUseRandomAlarmTime ) + { + SetRandomAlarmL(*entry); + } + else + { + SetAlarmL(*entry, parameters); + } + + RPointerArray array; + CleanupClosePushL (array ); + array.AppendL (entry ); + + TInt success(0); + //If StoreL() leaves, 'success' contains the number of entries that were stored before it failed + iCalEntryView->StoreL (array, success ); + + // id has been generated, store it for being able to delete + // entries created only with Creator + iEntryIds.Append( entry->LocalUidL() ); + + //One item should be added at time + if (success != 1 ) + { + err = 1; + } + + CleanupStack::PopAndDestroy (&array ); + CleanupStack::PopAndDestroy (entry ); + CleanupStack::Pop (guid );//guid has been destroyed by entry, which has ownership to guid + + return err; + } + +//---------------------------------------------------------------------------- + +void CCreatorInterimCalendar::Progress (TInt /*aPercentageCompleted*/) + { + //Not really needed but observer need to be implement + } + +void CCreatorInterimCalendar::Completed (TInt aError ) + { + //Not really needed but observer need to be implement + LOGSTRING2("Creator: CCreatorInterimCalendar::Completed err=%d", aError); + } + +TBool CCreatorInterimCalendar::NotifyProgress ( ) + { + //Not really needed but observer need to be implement + return NULL; + } + +//---------------------------------------------------------------------------- + + +void CCreatorInterimCalendar::GenerateRandomId (TDes8& aText ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::GenerateRandomId"); + + aText.Zero ( ); + + TTime now; + now.UniversalTime ( ); + TInt64 time = now.Int64 ( ); + + // The number of characters in the guid should be + // more than 8 (to ensure the guids are not too small) + // less than 255 (this is the maximum length of a guid) + // less than MaxLength of the descriptor passed in + TInt numChar(0); + do + { + numChar = Math::Rand (time ) % (aText.MaxLength ( ) - 1); + } + while (numChar > 255|| numChar < 8 ); + + for (TInt i(0); i < numChar ; ++i ) + { + TInt character = Math::Rand (time )%6; + character = Math::Rand (time ) % 26+ ((character == 2) ? 'A' : 'a'); + aText.Append (character ); + } + + } + +//---------------------------------------------------------------------------- +void CCreatorInterimCalendar::DeleteAllL() + { + LOGSTRING("Creator: CCreatorInterimCalendar::DeleteAllL"); + TCalTime zeroTime; + zeroTime.SetTimeUtcL( TCalTime::MinTime() ); + RArray allIds; + CleanupClosePushL( allIds ); + iCalEntryView->GetIdsModifiedSinceDateL( zeroTime, allIds ); + if ( allIds.Count() ) + { + TInt successCount( KErrNotFound ); + iCalEntryView->DeleteL( allIds, successCount ); + if ( successCount != allIds.Count() ) + { + User::Leave( KErrGeneral ); + } + } + CleanupStack::PopAndDestroy( &allIds ); + + // reset must be done here, because iEntryIds is stored in destructor + iEntryIds.Reset(); + + // all entries deleted, remove the Calendar related registry + iEngine->RemoveStoreL( KUidDictionaryUidCalendar ); + } + +//---------------------------------------------------------------------------- +void CCreatorInterimCalendar::DeleteAllCreatedByCreatorL() + { + LOGSTRING("Creator: CCreatorInterimCalendar::DeleteAllCreatedByCreatorL"); + iEntryIds.Reset(); + + // fetch ids of entries created by Creator + iEngine->ReadEntryIdsFromStoreL( iEntryIds, KUidDictionaryUidCalendar ); + + // delete entries + TInt successCount(0); // ignore + TRAP_IGNORE( iCalEntryView->DeleteL( iEntryIds, successCount ) ); + + // reset must be done here, because iEntryIds is stored in destructor + iEntryIds.Reset(); + + // all entries deleted, remove the Calendar related registry + iEngine->RemoveStoreL( KUidDictionaryUidCalendar ); + } + +//---------------------------------------------------------------------------- +