diff -r 000000000000 -r d6fe6244b863 creator/src/creator_calendar.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/creator/src/creator_calendar.cpp Tue Feb 02 00:17:27 2010 +0200 @@ -0,0 +1,1601 @@ +/* +* Copyright (c) 2008 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 "creator_calendar.h" +#include "creator_traces.h" +#include "creator_scriptentry.h" +#if(!defined __SERIES60_30__ && !defined __SERIES60_31__) +#include "creator_contactsetcache.h" +#include "creator_virtualphonebook.h" +#endif +#include +#include +#include +#include + +#if(!defined __SERIES60_30__ && !defined __SERIES60_31__) +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif + +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; +#if(!defined __SERIES60_30__ && !defined __SERIES60_31__) + delete iExistingContacts; + delete iTempContact; + delete iContactManager; +#endif + } + +//---------------------------------------------------------------------------- + +TBool CCreatorInterimCalendar::AskDataFromUserL (TInt aCommand, + TInt& aNumberOfEntries ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::AskDataFromUserL"); + + if( aCommand == ECmdDeleteCalendarEntries ) + { + return iEngine->YesNoQueryDialogL(_L("Delete all calendar entries?") ); + } + if( aCommand == ECmdDeleteCreatorCalendarEntries ) + { + return iEngine->YesNoQueryDialogL(_L("Delete all calendar entries created with Creator?") ); + } + + // display queries + if (iEngine->EntriesQueryDialogL (aNumberOfEntries, _L("How many entries to create?") ) ) // ask number of entries to create + { + if( aCommand == ECmdCreateCalendarEntryEvents || + aCommand == ECmdCreateCalendarEntryAppointments) + { + _LIT(KRepeatingNum, "How many repeating (weekly) entries"); + if( !iEngine->EntriesQueryDialogL(iNumberRepeatingEntries, KRepeatingNum, ETrue)) + { + return EFalse; + } + _LIT(KAttendeesNum, "How many attendees to create"); + if( !iEngine->EntriesQueryDialogL(iNumberOfAttendees, KAttendeesNum, ETrue)) + { + return EFalse; + } + } + if (iEngine->TimeQueryDialogL (iRandomModeStartTime, R_START_DATE_QUERY ) ) // ask start date + { + if (iEngine->TimeQueryDialogL (iRandomModeEndTime, R_END_DATE_QUERY ) ) // ask end date + { + if (iRandomModeStartTime > iRandomModeEndTime ) // check end date is ok + { + CAknInformationNote* note = new (ELeave) CAknInformationNote; + note->ExecuteLD (_L("End date must be after start date") ); + + return EFalse; + } + else + { + if( iEngine->YesNoQueryDialogL(_L("Add default alarm?"))) + { + iSetAlarm = ETrue; + } + } + return ETrue; + } + else + return EFalse; + } + else + return EFalse; + } + else + return EFalse; + } + +//---------------------------------------------------------------------------- + +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 + } + } + + // Linked attendees: +#if(!defined __SERIES60_30__ && !defined __SERIES60_31__) + + CVPbkContactStoreUriArray* uriArray = CVPbkContactStoreUriArray::NewLC(); + uriArray->AppendL( TVPbkContactStoreUriPtr(VPbkContactStoreUris::DefaultCntDbUri())); + + if( iContactManager == 0 ) + { + iContactManager = CVPbkContactManager::NewL( *uriArray, &CCoeEnv::Static()->FsSession()); + } + CleanupStack::PopAndDestroy(uriArray); + + if( iContactManager ) + { + MVPbkContactStoreList& storeList = iContactManager->ContactStoresL(); + storeList.OpenAllL(*this); + iWaiter->StartAndWait(); + + // Sum number of existing contacts: + for( TInt i = 0; i < parameters->iAttendeeLinkIds.Count(); ++i ) + { + TLinkIdParam id = parameters->iAttendeeLinkIds[i]; + parameters->iNumberOfExistingAttendees += ContactLinkCache::Instance()->ContactSet(id.iLinkId).NumberOfExistingContacts(); + } + + // Existing attendees: + if( parameters->iNumberOfExistingAttendees > 0 ) + { + _LIT(dbUri, "cntdb://c:contacts.cdb"); + TVPbkContactStoreUriPtr uri(dbUri); + MVPbkContactStore* store = storeList.Find(uri); + if( store ) + { + const MVPbkFieldTypeList& fieldList = store->StoreProperties().SupportedFields(); + + // get contacts, results will be set to iContactResults + MVPbkContactOperationBase* operation = iContactManager->FindL(_L(""), fieldList , *this); + if (operation) + { + CleanupDeletePushL( operation ); + iWaiter->StartAndWait();//Making asynchronous FindL to synchronous + CleanupStack::Pop(operation); + delete operation; + } + if( iExistingContacts ) + { + for( TInt i = 0; i < iExistingContacts->Count() && i < parameters->iNumberOfExistingAttendees; ++i ) + { + MVPbkContactOperationBase* operation = iContactManager->RetrieveContactL( iExistingContacts->At(i), *this ); + + if (operation) + { + CleanupDeletePushL( operation ); + iWaiter->StartAndWait(); // Making asynchronous RetrieveContactL to synchronous + CleanupStack::Pop(); // operation + delete operation; + operation = 0; + HandleSingleContactResultL(); + CCalAttendee* attendee = 0; + if( iTmpEmail && iTmpEmail->Length() > 0 ) + { + attendee = CCalAttendee::NewL(*iTmpEmail); + } + else + { + _LIT(KDummy, ""); + attendee = CCalAttendee::NewL(KDummy); + } + CleanupStack::PushL(attendee); + if( iTmpCN && iTmpCN->Length() > 0 ) + { + attendee->SetCommonNameL(*iTmpCN); + } + attendee->SetRoleL(CCalAttendee::EReqParticipant); + attendee->SetStatusL(CCalAttendee::EAccepted); + attendee->SetResponseRequested(ETrue); + aCalEntry.AddAttendeeL(attendee); + CleanupStack::Pop(attendee); + } + } + } + } + } + + for( TInt i = 0; i < parameters->iAttendeeLinkIds.Count(); ++i ) + { + TLinkIdParam id = parameters->iAttendeeLinkIds[i]; + RPointerArray& links = ContactLinkCache::Instance()->ContactLinks(id.iLinkId); + for( TInt j = 0; j < links.Count() && (id.iLinkAmount < 0 || j < id.iLinkAmount); ++j ) + { + MVPbkContactOperationBase* operation = iContactManager->RetrieveContactL( *(links[j]), *this ); + if (operation) + { + CleanupDeletePushL( operation ); + iWaiter->StartAndWait(); // Making asynchronous RetrieveContactL to synchronous + CleanupStack::Pop(operation); + delete operation; + operation = 0; + HandleSingleContactResultL(); + CCalAttendee* attendee = 0; + if( iTmpEmail && iTmpEmail->Length() > 0 ) + { + attendee = CCalAttendee::NewL(*iTmpEmail); + } + else + { + _LIT(KDummy, ""); + attendee = CCalAttendee::NewL(KDummy); + } + CleanupStack::PushL(attendee); + if( iTmpCN && iTmpCN->Length() > 0 ) + { + attendee->SetCommonNameL(*iTmpCN); + } + attendee->SetRoleL(CCalAttendee::EReqParticipant); + attendee->SetStatusL(CCalAttendee::EAccepted); + attendee->SetResponseRequested(ETrue); + aCalEntry.AddAttendeeL(attendee); + CleanupStack::Pop(attendee); + } + } + } + + storeList.CloseAll(*this); + } +#endif + } +//---------------------------------------------------------------------------- + +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 ); + } + + +#if(!defined __SERIES60_30__ && !defined __SERIES60_31__) +void CCreatorInterimCalendar::VPbkSingleContactOperationComplete( + MVPbkContactOperationBase& /*aOperation*/, + MVPbkStoreContact* aContact ) + { + LOGSTRING("Creator: CCreatorInterimCalendar::VPbkSingleContactOperationComplete" ); + iWaiter->Cancel(); + delete iTempContact; + iTempContact = aContact; + } +void CCreatorInterimCalendar::HandleSingleContactResultL() + { + if( iTempContact ) + { + TPtrC firstName; + TPtrC lastName; + TPtrC email; + + // Put contact's name to temporary member: + delete iTmpCN; + iTmpCN = 0; + delete iTmpEmail; + iTmpEmail = 0; + + MVPbkStoreContactFieldCollection& fields = iTempContact->Fields(); + TInt fieldCount = fields.FieldCount(); + for (TInt i = 0; i < fieldCount; ++i) + { + MVPbkStoreContactField& field = fields.FieldAt(i); + MVPbkContactFieldData& fieldData = field.FieldData(); + const MVPbkFieldType* fieldType = field.BestMatchingFieldType(); + + if( fieldType ) + { + TInt fieldId( fieldType->FieldTypeResId() ); + + TVPbkFieldStorageType dataType = fieldData.DataType(); + if( dataType == EVPbkFieldStorageTypeText) + { + MVPbkContactFieldTextData& textData = MVPbkContactFieldTextData::Cast(fieldData); + if( fieldId == R_VPBK_FIELD_TYPE_FIRSTNAME ) + { + firstName.Set(textData.Text()); + } + else if( fieldId == R_VPBK_FIELD_TYPE_LASTNAME ) + { + lastName.Set(textData.Text()); + } + else if( fieldId == R_VPBK_FIELD_TYPE_EMAILGEN || + fieldId == R_VPBK_FIELD_TYPE_EMAILHOME || + fieldId == R_VPBK_FIELD_TYPE_EMAILWORK ) + { + email.Set(textData.Text()); + } + } + } + } + if( firstName.Length() > 0 && lastName.Length() > 0 ) + { + _LIT(KSpace, " "); + TRAPD(err, iTmpCN = HBufC::NewL(firstName.Length() + lastName.Length() + 1 )); + if( err == KErrNone ) + { + iTmpCN->Des().Copy(firstName); + iTmpCN->Des().Append(KSpace); + iTmpCN->Des().Append(lastName); + } + } + else if( firstName.Length() > 0 ) + { + TRAPD(err, iTmpCN = HBufC::NewL(firstName.Length())); + if( err == KErrNone ) + { + iTmpCN->Des().Copy(firstName); + } + } + else if( lastName.Length() > 0 ) + { + TRAPD(err, iTmpCN = HBufC::NewL(lastName.Length())); + if( err == KErrNone ) + { + iTmpCN->Des().Copy(lastName); + } + } + + if( email.Length() > 0 ) + { + TRAPD(err, iTmpEmail = HBufC::NewL(email.Length())); + if( err == KErrNone ) + { + iTmpEmail->Des().Copy(email); + } + } + delete iTempContact; + iTempContact = 0; + } + } + +void CCreatorInterimCalendar::VPbkSingleContactOperationFailed( + MVPbkContactOperationBase& /*aOperation*/, + TInt aError ) + { + LOGSTRING2("Creator: CCreatorInterimCalendar::VPbkSingleContactOperationFailed - Error: %d", aError ); + iWaiter->Cancel(); + delete iTempContact; + iTempContact = 0; + } + + + +void CCreatorInterimCalendar::OpenComplete() + { + LOGSTRING("Creator: CreatorInterimCalendar::OpenComplete()"); + iWaiter->Cancel(); + } + +void CCreatorInterimCalendar::StoreReady(MVPbkContactStore& /*aContactStore*/) + { + LOGSTRING("Creator: CreatorInterimCalendar::StoreReady()"); + iWaiter->Cancel(); + } + +void CCreatorInterimCalendar::StoreUnavailable(MVPbkContactStore& /*aContactStore*/, + TInt /*aReason*/) + { + LOGSTRING("Creator: CreatorInterimCalendar::StoreUnavailable()"); + iWaiter->Cancel(); + } + + +void CCreatorInterimCalendar::HandleStoreEventL( + MVPbkContactStore& /*aContactStore*/, + TVPbkContactStoreEvent /*aStoreEvent*/) + { + LOGSTRING("Creator: CreatorInterimCalendar::HandleStoreEventL()"); + iWaiter->Cancel(); + } + +void CCreatorInterimCalendar::FindCompleteL( MVPbkContactLinkArray* aResults ) + { + LOGSTRING("Creator: CreatorInterimCalendar::FindCompleteL()"); + iWaiter->Cancel(); + iExistingContacts = aResults; + } + +void CCreatorInterimCalendar::FindFailed( TInt aError ) + { + LOGSTRING2("Creator: CreatorInterimCalendar::FindFailed() - Error: %d", aError); + iWaiter->Cancel(); + delete iExistingContacts; + iExistingContacts = 0; + } +#endif +//---------------------------------------------------------------------------- +