diff -r 8e7494275d3a -r 4f0867e42d62 omads/omadsappui/AspSyncUtil/src/AspSchedule.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/omads/omadsappui/AspSyncUtil/src/AspSchedule.cpp Wed Sep 01 12:30:02 2010 +0100 @@ -0,0 +1,2481 @@ +/* +* Copyright (c) 2002-2005 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 FILES + +#include "AspSchedule.h" +#include "AspUtil.h" +#include "AspDialogUtil.h" +#include "AspDebug.h" +#include "AspProfile.h" +#include "AspLogDialog.h" +#include "AspAutoSyncHandler.h" + +#include "schinfo.h" // TScheduleEntryInfo2 +#include // RDesWriteStream +#include // RFileReadStream +#include // BaflUtils +#include // CRepository +#include +#include + + + +/******************************************************************************* + * class CAspSchedule + *******************************************************************************/ + + +// ----------------------------------------------------------------------------- +// CAspSchedule::NewL +// +// ----------------------------------------------------------------------------- +// +CAspSchedule* CAspSchedule::NewL() + { + CAspSchedule* self = new (ELeave) CAspSchedule(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + + return(self); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::NewLC +// +// ----------------------------------------------------------------------------- +// +CAspSchedule* CAspSchedule::NewLC() + { + CAspSchedule* self = new (ELeave) CAspSchedule(); + CleanupStack::PushL(self); + self->ConstructL(); + + return(self); + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::CAspSchedule +// +// ----------------------------------------------------------------------------- +// +CAspSchedule::CAspSchedule() + { + iSettingChanged = EFalse; + iSyncSessionOpen = EFalse; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::ConstructL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::ConstructL() + { + InternalizeL(); + + if(iAutoSyncProfileId == KErrNotFound) + { + CreateAutoSyncProfileL(); + } + + + } + + +// ---------------------------------------------------------------------------- +// Destructor +// +// ---------------------------------------------------------------------------- +// +CAspSchedule::~CAspSchedule() + { + iList.Close(); + CloseSyncSession(); + } + + +// ---------------------------------------------------------------------------- +// InitializeL +// +// ---------------------------------------------------------------------------- +// +void CAspSchedule::InitializeL() + { + + FLOG( _L("CAspSchedule::InitializeL START") ); + iError = KErrNone; + iProfileId = KErrNotFound; + iRoamingAllowed = EFalse; + iDailySyncEnabled = EFalse; + iPeakSyncEnabled = EFalse; + iOffPeakSyncEnabled = EFalse; + + + iContentFlags = 0xFF; + iSyncFrequency = EIntervalManual; + iSyncPeakSchedule = EIntervalManual; + iSyncOffPeakSchedule = EIntervalManual; + + iPeakScheduleHandle = KErrNotFound; + iOffPeakScheduleHandle = KErrNotFound; + + iStartPeakTimeHr = KStartPeakHour; + iStartPeakTimeMin = KStartPeakMin; + iEndPeakTimeHr = KEndPeakHour; + iEndPeakTimeMin = KEndPeakMin; + + iAutoSyncProfileId = KErrNotFound; + iAutoSyncScheduleTimeHr = KDefaultStartHour; + iAutoSyncScheduleTimeMin = 0; + + SetWeekdayEnabled(EMonday, ETrue); + SetWeekdayEnabled(ETuesday, ETrue); + SetWeekdayEnabled(EWednesday, ETrue); + SetWeekdayEnabled(EThursday, ETrue); + SetWeekdayEnabled(EFriday, ETrue); + SetWeekdayEnabled(ESaturday, EFalse); + SetWeekdayEnabled(ESunday, EFalse); + + InitializeContentsL(); + FLOG( _L("CAspSchedule::InitializeL END") ); + + } + +// ---------------------------------------------------------------------------- +// InitializeContentsL +// +// ---------------------------------------------------------------------------- +// +void CAspSchedule::InitializeContentsL() + { + OpenSyncSessionL(); + TAspParam param(EApplicationIdSync, &iSyncSession); + param.iMode = CAspContentList::EInitDataProviders; + CAspContentList* asContentList = CAspContentList::NewLC(param); + + TInt providerCount = asContentList->ProviderCount(); + + for (TInt index = 0; index < providerCount; index++) + { + TAspProviderItem& provider = asContentList->ProviderItem(index); + + if (provider.iDataProviderId == KUidNSmlAdapterEMail.iUid) + { + if (MailboxExistL()) + { + SetContentEnabled(index, ETrue); + } + else + { + SetContentEnabled(index, EFalse); + } + } + else + { + SetContentEnabled(index, ETrue); + } + + } + CleanupStack::PopAndDestroy(asContentList); + + + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::DoInternalizeL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::DoInternalizeL() + { + const TInt KMaxLength = 1024; + + HBufC8* hBuf = HBufC8::NewLC(KMaxLength); + TPtr8 ptr = hBuf->Des(); + + ReadRepositoryL(ERepositoryKeyBin, ptr); + + RDesReadStream stream(ptr); + stream.PushL(); + + InternalizeL(stream); + + stream.Pop(); + stream.Close(); + + CleanupStack::PopAndDestroy(hBuf); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::InternalizeL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::InternalizeL() + { + FLOG( _L("CAspSchedule::InternalizeL START") ); + TRAPD(err, DoInternalizeL()); + + if (err == KErrNoMemory || err == KErrLocked || err == KErrAlreadyExists) + { + FLOG( _L("CAspSchedule::InternalizeL Error 1: %d"),err ); + User::Leave(err); + } + + else if (err != KErrNone) + { + FLOG( _L("CAspSchedule::InternalizeL Error 2: %d"),err ); + ResetRepositoryL(); // settings corrupted + InitializeL(); + } + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::InternalizeL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::InternalizeL(RReadStream& aStream) + { + const TInt KAutoSyncSettingCount = 20; + + iList.Reset(); + + // total setting count + TInt32 count = 0; + + TRAPD(err, count = aStream.ReadInt32L()); + + if (err != KErrNone && err != KErrEof) + { + User::Leave(err); + } + + if (count != KAutoSyncSettingCount) + { + InitializeL(); // settings not found - use defaults + SaveL(); + return; + } + + + iError = aStream.ReadInt32L(); + iProfileId = aStream.ReadInt32L(); + iWeekdayFlags = aStream.ReadInt32L(); + TInt roamingAllowed = aStream.ReadInt32L(); + + + + iPeakScheduleHandle = aStream.ReadInt32L(); + iOffPeakScheduleHandle = aStream.ReadInt32L(); + iContentFlags = aStream.ReadInt32L(); + iSyncPeakSchedule = aStream.ReadInt32L(); + iSyncOffPeakSchedule = aStream.ReadInt32L(); + iStartPeakTimeHr = aStream.ReadInt32L(); + iStartPeakTimeMin = aStream.ReadInt32L(); + iEndPeakTimeHr = aStream.ReadInt32L(); + iEndPeakTimeMin = aStream.ReadInt32L(); + iSyncFrequency = aStream.ReadInt32L(); + iDailySyncEnabled = aStream.ReadInt32L(); + iPeakSyncEnabled = aStream.ReadInt32L(); + iOffPeakSyncEnabled = aStream.ReadInt32L(); + + iAutoSyncProfileId = aStream.ReadInt32L(); + + iAutoSyncScheduleTimeHr = aStream.ReadInt32L(); + iAutoSyncScheduleTimeMin = aStream.ReadInt32L(); + +#ifdef _DEBUG + LogSettings(); +#endif + + iRoamingAllowed = EFalse; + if (roamingAllowed) + { + iRoamingAllowed = ETrue; + } + + CheckEmailSelectionL(); + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::CheckEmailSelectionL() +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::CheckEmailSelectionL() + { + TRAPD(err, OpenSyncSessionL()); + if (err != KErrNone) + { + + /*OpenSynSessionL() may leave when system time is changed so that peak and off-peak syncs are + scheduled simulataneously.In that case also next sync time has to be updated. So a leave here should be + trapped and return to the time update function. + */ + + FLOG( _L("Session cannot be opened now : return") ); + return; + } + TAspParam param(EApplicationIdSync, &iSyncSession); + param.iMode = CAspContentList::EInitDataProviders; + CAspContentList* asContentList = CAspContentList::NewLC(param); + + TInt providerCount = asContentList->ProviderCount(); + + TInt emailIndex = asContentList->FindProviderIndex(KUidNSmlAdapterEMail.iUid); + + if (!MailboxExistL()) + { + SetContentEnabled(emailIndex, EFalse); + } + else if (!IsAutoSyncEnabled()) + { + SetContentEnabled(emailIndex, ETrue); + } + + if (iProfileId != KErrNotFound + && !ProtocolL()) + { + SetContentEnabled(emailIndex, EFalse); + } + + CleanupStack::PopAndDestroy(asContentList); + + } + + + +// ----------------------------------------------------------------------------- +// CAspSchedule::ExternalizeL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::ExternalizeL() + { + const TInt KMaxLength = 1024; + + HBufC8* hBuf = HBufC8::NewLC(KMaxLength); + TPtr8 ptr = hBuf->Des(); + RDesWriteStream stream(ptr); + stream.PushL(); + + ExternalizeL(stream); + + stream.CommitL(); + stream.Pop(); + stream.Close(); + + TRAPD (err,WriteRepositoryL(ERepositoryKeyBin, ptr)); + User::LeaveIfError(err); + + CleanupStack::PopAndDestroy(hBuf); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::ExternalizeL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::ExternalizeL(RWriteStream& aStream) + { + const TInt KAutoSyncSettingCount = 20; + + + TInt roamingAllowed = 0; + if (iRoamingAllowed) + { + roamingAllowed = 1; + } + + + aStream.WriteInt32L(KAutoSyncSettingCount); + aStream.WriteInt32L(iError); + aStream.WriteInt32L(iProfileId); + aStream.WriteInt32L(iWeekdayFlags); + aStream.WriteInt32L(roamingAllowed); + + aStream.WriteInt32L(iPeakScheduleHandle); + aStream.WriteInt32L(iOffPeakScheduleHandle); + aStream.WriteInt32L(iContentFlags); + aStream.WriteInt32L(iSyncPeakSchedule); + aStream.WriteInt32L(iSyncOffPeakSchedule); + aStream.WriteInt32L(iStartPeakTimeHr); + aStream.WriteInt32L(iStartPeakTimeMin); + aStream.WriteInt32L(iEndPeakTimeHr); + aStream.WriteInt32L(iEndPeakTimeMin); + aStream.WriteInt32L(iSyncFrequency); + aStream.WriteInt32L(iDailySyncEnabled); + aStream.WriteInt32L(iPeakSyncEnabled); + aStream.WriteInt32L(iOffPeakSyncEnabled); + aStream.WriteInt32L(iAutoSyncProfileId); + + aStream.WriteInt32L(iAutoSyncScheduleTimeHr); + aStream.WriteInt32L(iAutoSyncScheduleTimeMin); + +#ifdef _DEBUG + LogSettings(); +#endif + + + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::WriteRepositoryL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::WriteRepositoryL(TInt aKey, const TDesC8& aValue) + { + const TUid KRepositoryId = KCRUidNSmlDSApp; // 0x101F9A1D + + CRepository* rep = CRepository::NewLC(KRepositoryId); + TInt err = rep->Set(aKey, aValue); + User::LeaveIfError(err); + + CleanupStack::PopAndDestroy(rep); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::ReadRepositoryL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::ReadRepositoryL(TInt aKey, TDes8& aValue) + { + const TUid KRepositoryId = KCRUidNSmlDSApp; + + CRepository* rep = CRepository::NewLC(KRepositoryId); + TInt err = rep->Get(aKey, aValue); + User::LeaveIfError(err); + + CleanupStack::PopAndDestroy(rep); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::ResetRepositoryL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::ResetRepositoryL() + { + const TUid KRepositoryId = KCRUidNSmlDSApp; + + CRepository* rep = CRepository::NewLC(KRepositoryId); + TInt err = rep->Reset(); + User::LeaveIfError(err); + + CleanupStack::PopAndDestroy(rep); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::SaveL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SaveL() + { + ExternalizeL(); + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::PeakScheduleHandle +// +// ----------------------------------------------------------------------------- +// +TInt CAspSchedule::PeakScheduleHandle() + { + return iPeakScheduleHandle; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetPeakScheduleHandle +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SetPeakScheduleHandle(TInt aScheduleHandle) + { + iPeakScheduleHandle = aScheduleHandle; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetPeakScheduleHandle +// +// ----------------------------------------------------------------------------- +// +TInt CAspSchedule::OffPeakScheduleHandle() + { + return iOffPeakScheduleHandle; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetPeakScheduleHandle +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SetOffPeakScheduleHandle(TInt aScheduleHandle) + { + iOffPeakScheduleHandle = aScheduleHandle; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::ProfileId +// +// ----------------------------------------------------------------------------- +// +TInt CAspSchedule::ProfileId() + { + return iProfileId; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetProfileId +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SetProfileId(TInt aProfileId) + { + iProfileId = aProfileId; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::DailySyncEnabled +// +// ----------------------------------------------------------------------------- +// +TBool CAspSchedule::DailySyncEnabled() + { + return iDailySyncEnabled; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetDailySyncEnabled +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SetDailySyncEnabled(TBool aSyncEnabled) + { + iDailySyncEnabled = aSyncEnabled; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::PeakSyncEnabled +// +// ----------------------------------------------------------------------------- +// +TBool CAspSchedule::PeakSyncEnabled() + { + return iPeakSyncEnabled; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetPeakSyncEnabled +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SetPeakSyncEnabled(TBool aSyncEnabled) + { + iPeakSyncEnabled = aSyncEnabled; + } +// ----------------------------------------------------------------------------- +// CAspSchedule::OffPeakSyncEnabled +// +// ----------------------------------------------------------------------------- +// + +TBool CAspSchedule::OffPeakSyncEnabled() + { + return iOffPeakSyncEnabled; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetOffPeakSyncEnabled +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SetOffPeakSyncEnabled(TBool aSyncEnabled) + { + iOffPeakSyncEnabled = aSyncEnabled; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::WeekdayEnabled +// +// ----------------------------------------------------------------------------- +// +TBool CAspSchedule::WeekdayEnabled(TInt aWeekday) + { + TInt dayFlag = WeekdayFlag(aWeekday); + + TFlag flag(iWeekdayFlags); + + return flag.IsOn(dayFlag); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetWeekdayEnabled +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SetWeekdayEnabled(TInt aWeekday, TInt aEnabled) + { + TInt dayFlag = WeekdayFlag(aWeekday); + + TFlag flag(iWeekdayFlags); + + if (aEnabled) + { + flag.SetOn(dayFlag); + } + else + { + flag.SetOff(dayFlag); + } + iSettingChanged = ETrue; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::WeekdayFlag +// +// ----------------------------------------------------------------------------- +// +TInt CAspSchedule::WeekdayFlag(TInt aWeekday) + { + TInt ret = EFlagMonday; + + switch (aWeekday) + { + case EMonday: + ret = EFlagMonday; + break; + case ETuesday: + ret = EFlagTuesday; + break; + case EWednesday: + ret = EFlagWednesday; + break; + case EThursday: + ret = EFlagThursday; + break; + case EFriday: + ret = EFlagFriday; + break; + case ESaturday: + ret = EFlagSaturday; + break; + case ESunday: + ret = EFlagSunday; + break; + default: + TUtil::Panic(KErrArgument); + break; + } + + return ret; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::SelectedDayInfo +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SelectedDayInfo(TInt& aDayCount, TInt& aWeekday) + { + aDayCount = 0; + + for (TInt i=EMonday; i<=ESunday; i++) + { + if (WeekdayEnabled(i)) + { + aDayCount++; + aWeekday = i; + } + } + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetContentEnabled +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SetContentEnabled(TInt aContent, TInt aEnabled) + { + TInt contentFlag = 1 << aContent; + TFlag flag(iContentFlags); + if (aEnabled) + { + flag.SetOn(contentFlag); + } + else + { + flag.SetOff(contentFlag); + } + iSettingChanged = ETrue; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::ContentEnabled +// +// ----------------------------------------------------------------------------- +// + +TBool CAspSchedule::ContentEnabled(TInt aContent) + { + TInt contentFlag = 1 << aContent; + TFlag flag(iContentFlags); + return flag.IsOn(contentFlag); + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::ContentSelectionInfo +// +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::ContentSelectionInfo(TInt& aContentCnt, TInt& aContent) + { + aContentCnt = 0; + OpenSyncSessionL(); + TAspParam param(EApplicationIdSync, &iSyncSession); + param.iMode = CAspContentList::EInitDataProviders; + CAspContentList* asContentList = CAspContentList::NewLC(param); + + //contents are saved in the sorted order of data providers + TInt providerCount = asContentList->ProviderCount(); + for (TInt i= 0; i < providerCount; i++) + { + if (ContentEnabled(i)) + { + aContentCnt++; + aContent = i; + } + } + CleanupStack::PopAndDestroy(asContentList); + + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::StartPeakTime +// +// ----------------------------------------------------------------------------- +// + +TTime CAspSchedule::StartPeakTime() + { + TDateTime time(0, EJanuary, 0, iStartPeakTimeHr, iStartPeakTimeMin, 0, 0); + TTime startTime(time); + return startTime; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetStartPeakTime +// +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::SetStartPeakTime(TTime aStartTime) + { + TDateTime startTime = aStartTime.DateTime(); + if (iStartPeakTimeHr != startTime.Hour() || iStartPeakTimeMin != startTime.Minute()) + { + iStartPeakTimeHr = startTime.Hour(); + iStartPeakTimeMin = startTime.Minute(); + iSettingChanged = ETrue; + } + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::EndPeakTime +// +// ----------------------------------------------------------------------------- +// + + +TTime CAspSchedule::EndPeakTime() + { + TDateTime time(0, EJanuary, 0, iEndPeakTimeHr, iEndPeakTimeMin, 0, 0); + TTime endTime(time); + return endTime; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetEndPeakTime +// +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::SetEndPeakTime(TTime aEndTime) + { + TDateTime endTime = aEndTime.DateTime(); + + if (iEndPeakTimeHr != endTime.Hour() || iEndPeakTimeMin != endTime.Minute()) + { + iEndPeakTimeHr = endTime.Hour(); + iEndPeakTimeMin = endTime.Minute(); + iSettingChanged = ETrue; + } + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SyncFrequency +// +// ----------------------------------------------------------------------------- +// + +TInt CAspSchedule::SyncFrequency() + { + return iSyncFrequency; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetSyncFrequency +// +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::SetSyncFrequency(TInt aSchedule) + { + if (aSchedule != iSyncFrequency) + { + iSyncFrequency = aSchedule; + iSettingChanged = ETrue; + } + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SyncPeakSchedule +// +// ----------------------------------------------------------------------------- +// + +TInt CAspSchedule::SyncPeakSchedule() + { + return iSyncPeakSchedule; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetSyncPeakSchedule +// +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::SetSyncPeakSchedule(TInt aSchedule) + { + if (aSchedule != iSyncPeakSchedule) + { + iSyncPeakSchedule = aSchedule; + iSettingChanged = ETrue; + } + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SyncOffPeakSchedule +// +// ----------------------------------------------------------------------------- +// + +TInt CAspSchedule::SyncOffPeakSchedule() + { + return iSyncOffPeakSchedule; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetSyncOffPeakSchedule +// +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::SetSyncOffPeakSchedule(TInt aSchedule) + { + if (aSchedule != iSyncOffPeakSchedule) + { + iSyncOffPeakSchedule = aSchedule; + iSettingChanged = ETrue; + } + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::AutoSyncScheduleTime +// +// ----------------------------------------------------------------------------- +// + +TTime CAspSchedule::AutoSyncScheduleTime() + { + TDateTime time(0, EJanuary, 0, iAutoSyncScheduleTimeHr, iAutoSyncScheduleTimeMin, 0, 0); + TTime scheduleTime(time); + return scheduleTime; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetAutoSyncScheduleTime +// +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::SetAutoSyncScheduleTime(TTime aSchedule) + { + TDateTime schedule = aSchedule.DateTime(); + + //To do- check value + if (iAutoSyncScheduleTimeHr != schedule.Hour() || iAutoSyncScheduleTimeMin != schedule.Minute()) + { + iAutoSyncScheduleTimeHr = schedule.Hour(); + iAutoSyncScheduleTimeMin = schedule.Minute(); + iSettingChanged = ETrue; + } + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::RoamingAllowed +// +// ----------------------------------------------------------------------------- +// +TBool CAspSchedule::RoamingAllowed() + { + return iRoamingAllowed; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetRoamingAllowed +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SetRoamingAllowed(TBool aRoamingAllowed) + { + iRoamingAllowed = aRoamingAllowed; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::Error +// +// ----------------------------------------------------------------------------- +// +TInt CAspSchedule::Error() + { + return iError; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetError +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::SetError(TInt aError) + { + iError = aError; + } + + + +// ---------------------------------------------------------------------------- +// CAspSchedule::UniversalStartTime +// +// ---------------------------------------------------------------------------- +// +TTime CAspSchedule::UniversalStartTime(TInt& aStartHour) + { + // add two hours to current universal time and + // set minutes to 0 (eg. 13:45 -> 15:00) + TTime time; + time.UniversalTime(); + + TTimeIntervalHours twoHours(2); + time += twoHours; + + TDateTime dateTime = time.DateTime(); + dateTime.SetMinute(0); + dateTime.SetSecond(0); + dateTime.SetMicroSecond(0); + + aStartHour = dateTime.Hour(); // return start hour to caller + + TTime time2(dateTime); + return time2; + } + + +// ---------------------------------------------------------------------------- +// CAspSchedule::LocalStartTime +// +// ---------------------------------------------------------------------------- +// +TTime CAspSchedule::LocalStartTime(TInt aStartHour) + { + TTime time; + time.HomeTime(); + + TDateTime dateTime = time.DateTime(); + dateTime.SetMinute(0); + dateTime.SetSecond(0); + dateTime.SetMicroSecond(0); + dateTime.SetHour(aStartHour); + + TTime time2(dateTime); + TTime now; + now.HomeTime(); + if (now > time2) + { + TTimeIntervalDays oneDay(1); + time2 += oneDay; + } + + return time2; + } + + +// ---------------------------------------------------------------------------- +// CAspSchedule::IsDaySelected +// +// ---------------------------------------------------------------------------- +// +TBool CAspSchedule::IsDaySelected(TTime aTime) + { + TDay day = aTime.DayNoInWeek(); + TBool ret = WeekdayEnabled(day); + + return ret; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::UpdateSyncScheduleL +// Called when any auto sync setting is changed +// ----------------------------------------------------------------------------- +// +void CAspSchedule::UpdateSyncScheduleL() + { + FLOG( _L("CAspSchedule::UpdateSyncScheduleL START") ); + + CAspSyncSchedule* schedule = CAspSyncSchedule::NewLC(); + + TInt profileId = ProfileId(); + TBool contentStatus = IsContentSelected(); + + if (profileId == KErrNotFound || !contentStatus) + { + SetDailySyncEnabled(EFalse); + SetPeakSyncEnabled(EFalse); + SetOffPeakSyncEnabled(EFalse); + schedule->DeleteScheduleL(this); + CleanupStack::PopAndDestroy(schedule); + return; + } + + if (!IsAutoSyncEnabled()) + { + //Manual Sync selected ---->Delete schedule, if exists + schedule->DeleteScheduleL(this); + } + else + { + if (iDailySyncEnabled) + { + //Daily sync enabled ,use peak scheduling with intervals more than a day + schedule->DeleteScheduleL(this); + SetDailySyncEnabled(ETrue); + schedule->CreatePeakScheduleL(this); + } + else + { + if (iPeakSyncEnabled != 0 && iOffPeakSyncEnabled ==0) + { + //Only peak sync enabled + schedule->DeleteScheduleL(this); + SetPeakSyncEnabled(ETrue); + schedule->CreatePeakScheduleL(this); + } + else if (iPeakSyncEnabled == 0 && iOffPeakSyncEnabled !=0) + { + //Only peak sync enabled + schedule->DeleteScheduleL(this); + SetOffPeakSyncEnabled(ETrue); + schedule->CreateOffPeakScheduleL(this); + } + else if (iPeakSyncEnabled && iOffPeakSyncEnabled) + { + schedule->DeleteScheduleL(this); + SetPeakSyncEnabled(ETrue); + SetOffPeakSyncEnabled(ETrue); + schedule->CreatePeakScheduleL(this); + schedule->CreateOffPeakScheduleL(this); + } + } + } + + + CleanupStack::PopAndDestroy(schedule); + +#ifdef _DEBUG + + CAspSyncSchedule* s = CAspSyncSchedule::NewLC(); + FLOG( _L("") ); + LogScheduleL(); + FLOG( _L("") ); + s->LogSchedule(this); + FLOG( _L("") ); + CleanupStack::PopAndDestroy(s); + +#endif // _DEBUG + + FLOG( _L("CAspSchedule::UpdateSyncScheduleL END") ); + } + + + +// ----------------------------------------------------------------------------- +// CAspSchedule::UpdateSyncSchedule +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::UpdateSyncSchedule() + { + TRAPD(err, UpdateSyncScheduleL()); + + if (err != KErrNone) + { + FLOG( _L("### CAspSchedule::UpdateSyncScheduleL failed (err=%d) ###"), err ); + } + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::GetStartTimeL +// -Get next auto sync start time ,peak/off-peak whichever is earlier and enabled +// ----------------------------------------------------------------------------- +// +void CAspSchedule::GetStartTimeL(TTime& aTime, TBool aHomeTime) + { + + CAspSyncSchedule* s = CAspSyncSchedule::NewLC(); + + if (iDailySyncEnabled) + { + s->GetPeakStartTimeL(this, aTime, aHomeTime); + } + else if (iPeakSyncEnabled != 0 && iOffPeakSyncEnabled ==0) + { + s->GetPeakStartTimeL(this, aTime, aHomeTime); + } + else if (iPeakSyncEnabled == 0 && iOffPeakSyncEnabled !=0) + { + s->GetOffPeakStartTimeL(this, aTime, aHomeTime); + } + else //peak & off-peak schedules enabled + { + TTime peakStart; + TTime offPeakStart; + + s->GetPeakStartTimeL(this, peakStart, aHomeTime); + s->GetOffPeakStartTimeL(this, offPeakStart, aHomeTime); + + if (peakStart < offPeakStart) + { + aTime = peakStart; + } + else + { + aTime = offPeakStart; + } + } + CleanupStack::PopAndDestroy(s); + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::CanSynchronizeL +// Check primary auto sync settings +// ----------------------------------------------------------------------------- +// +TBool CAspSchedule::CanSynchronizeL() + { + if (iProfileId == KErrNotFound && iAutoSyncProfileId == KErrNotFound) + { + FLOG( _L("CAspSchedule::CanSynchronizeL Failed :CP1") ); + return EFalse; + } + OpenSyncSessionL(); + TAspParam param(EApplicationIdSync, &iSyncSession); + CAspProfile* profile = CAspProfile::NewLC(param); + + TRAPD (err, profile->OpenL(iProfileId, CAspProfile::EOpenRead, + CAspProfile::EBaseProperties)); + if (err == KErrNotFound) + { + SetProfileId(KErrNotFound); + if (iAutoSyncProfileId != KErrNotFound) + { + TRAPD (err1, profile->OpenL(iAutoSyncProfileId, CAspProfile::EOpenRead, + CAspProfile::EBaseProperties)); + if (err1 == KErrNotFound) + { + SetAutoSyncProfileId(KErrNotFound); + } + } + UpdateSyncSchedule(); + SaveL(); + CleanupStack::PopAndDestroy(profile); + FLOG( _L("CAspSchedule::CanSynchronizeL Failed :CP2") ); + return EFalse; + } + CleanupStack::PopAndDestroy(profile); + + if (!IsContentSelected()) + { + UpdateSyncSchedule(); + SaveL(); + FLOG( _L("CAspSchedule::CanSynchronizeL Failed :CP3") ); + return EFalse; + } + + if (!IsAutoSyncEnabled()) + { + FLOG( _L("CAspSchedule::CanSynchronizeL Failed :CP4") ); + return EFalse; + } + + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::IsValidPeakScheduleL +// Check if current time is peak +// ----------------------------------------------------------------------------- +// +TInt CAspSchedule::IsValidPeakScheduleL() + { + //convert all time values to same day and comapre + const TInt KPositive = 1; + const TInt KZero = 0; + const TInt KNegative = -1; + + TTime startPeak = StartPeakTime(); + TTime endPeak = EndPeakTime(); + + TInt retVal = 0; + TTime now; + now.HomeTime(); + + if (!WeekdayEnabled(now.DayNoInWeek())) + { + retVal = KPositive; + return retVal; + } + + TDateTime timenow = now.DateTime(); + TDateTime date = startPeak.DateTime(); + TInt nowHr = timenow.Hour(); + TInt nowMin = timenow.Minute(); + TInt day = date.Day(); + + TDateTime time(0, EJanuary, day, nowHr, nowMin, 0, 0); + TTime curTime(time); + + if ( curTime >= startPeak && curTime < endPeak) + { + retVal = KZero; //In peak period + } + else if (curTime < startPeak) + { + retVal = KPositive; + } + else if (curTime > endPeak) + { + retVal = KNegative; + } + + return retVal; + + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::IsValidOffPeakScheduleL +// Check if the current time off-peak +// ----------------------------------------------------------------------------- +// + +TInt CAspSchedule::IsValidOffPeakScheduleL() + { + //convert all time values to same day and comapre + const TInt KPositive = 1; + const TInt KZero = 0; + + TTime startOffPeak = EndPeakTime()+ (TTimeIntervalMinutes)1; + TTime endOffPeak = StartPeakTime() + (TTimeIntervalDays)1 -(TTimeIntervalMinutes)1 ; + TInt retVal = 0; + TTime now; + now.HomeTime(); + + if (!WeekdayEnabled(now.DayNoInWeek())) + { + retVal = KZero; + return retVal; + } + + TDateTime timenow = now.DateTime(); + TDateTime date = startOffPeak.DateTime(); + TInt nowHr = timenow.Hour(); + TInt nowMin = timenow.Minute(); + TInt day = date.Day(); + + TDateTime time(0, EJanuary, day, nowHr, nowMin, 0, 0); + TTime curTime(time); + + if (curTime < StartPeakTime() || (curTime >= startOffPeak && curTime < endOffPeak )) + { + retVal = KZero; + } + else if (curTime < startOffPeak) + { + retVal = KPositive; + } + + return retVal; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::IsValidNextPeakScheduleL +// -Add sync interval to current time and checks if the next schedule will be in peak period. +// -otherwise sync can be postponed until next peak start +// ----------------------------------------------------------------------------- +// +TBool CAspSchedule::IsValidNextPeakScheduleL() + { + //convert all time vakues to same day and compare + TTime startPeak = StartPeakTime(); + TTime endPeak = EndPeakTime(); + + TTime now; + now.HomeTime(); + + CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC(); + TInt interval = SyncPeakSchedule(); + TIntervalType intervalType = syncSchedule->IntervalType(interval); + + TInt intervalVal = syncSchedule->Interval(interval); + + if (interval == EInterval15Mins + || interval == EInterval30Mins) + { + now = now + (TTimeIntervalMinutes)intervalVal; + } + else if (intervalType == EHourly) + { + now = now + (TTimeIntervalHours)intervalVal; + } + + CleanupStack::PopAndDestroy(syncSchedule); + if (!WeekdayEnabled(now.DayNoInWeek())) + { + return EFalse; + } + TDateTime timenow = now.DateTime(); + TDateTime date = startPeak.DateTime(); + TInt nowHr = timenow.Hour(); + TInt nowMin = timenow.Minute(); + TInt day = date.Day(); + + TDateTime time(0, EJanuary, day, nowHr, nowMin, 0, 0); + TTime nextPeakSync(time); + + if ( nextPeakSync >= startPeak && nextPeakSync < endPeak) + { + return ETrue; //In peak period + } + + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::IsValidNextOffPeakScheduleL +// -Add sync interval to current time and checks if the next schedule will be in off-peak period. +// -otherwise sync can be postponed until next off-peak start +// ----------------------------------------------------------------------------- +// +TBool CAspSchedule::IsValidNextOffPeakScheduleL() + { + + TTime startOffPeak = EndPeakTime()+ (TTimeIntervalMinutes)1; + TTime endOffPeak = StartPeakTime() + (TTimeIntervalDays)1 -(TTimeIntervalMinutes)1 ; + + TTime now; + now.HomeTime(); + + CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC(); + TInt interval = SyncOffPeakSchedule(); + TIntervalType intervalType = syncSchedule->IntervalType(interval); + + TInt intervalVal = syncSchedule->Interval(interval); + + if (interval == EInterval15Mins + || interval == EInterval30Mins) + { + now = now + (TTimeIntervalMinutes)intervalVal; + } + else if (intervalType == EHourly) + { + now = now + (TTimeIntervalHours)intervalVal; + } + + CleanupStack::PopAndDestroy(syncSchedule); + + if (!WeekdayEnabled(now.DayNoInWeek())) + { + return ETrue; + } + + TDateTime timenow = now.DateTime(); + TDateTime date = startOffPeak.DateTime(); + TInt nowHr = timenow.Hour(); + TInt nowMin = timenow.Minute(); + TInt day = date.Day(); + + TDateTime time(0, EJanuary, day, nowHr, nowMin, 0, 0); + TTime nextOffPeakSync(time); + + if (nextOffPeakSync < StartPeakTime() || (nextOffPeakSync >= startOffPeak && nextOffPeakSync < endOffPeak )) + { + return ETrue; //in off-peak period + } + return EFalse; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::CreateAutoSyncProfileL +// -Creates a hidden profile that is used for auto sync. +// -It is created when auto sync is used for first time +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::CreateAutoSyncProfileL() + { + if (iAutoSyncProfileId != KErrNotFound) + { + return; + } + OpenSyncSessionL(); + + TBuf aBufName(KAutoSyncProfileName); + + TAspParam param(EApplicationIdSync, &iSyncSession); + CAspProfile* profile = CAspProfile::NewLC(param); + + profile->CreateL(CAspProfile::EAllProperties); + CAspProfile::SetDefaultValuesL(profile); + profile->SetNameL(aBufName); + profile->SetSASyncStateL(ESmlDisableSync); + profile->SaveL(); + + iAutoSyncProfileId = profile->ProfileId(); + SaveL(); + + CleanupStack::PopAndDestroy(profile); + + + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::AutoSyncProfileId +// ----------------------------------------------------------------------------- +// + +TInt CAspSchedule::AutoSyncProfileId() + { + return iAutoSyncProfileId; + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::SetAutoSyncProfileId +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::SetAutoSyncProfileId(TInt aProfileId) + { + iAutoSyncProfileId = aProfileId; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::CopyAutoSyncContentsL +// -Copy contents selected in Automatic sync settings view to the profiles content list +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::CopyAutoSyncContentsL() + { + FLOG( _L("CAspSchedule::CopyAutoSyncContentsL START") ); + if (iAutoSyncProfileId == KErrNotFound) + { + return; + } + OpenSyncSessionL(); + TAspParam param(EApplicationIdSync, &iSyncSession); + + param.iMode = CAspContentList::EInitDataProviders; + CAspContentList* asContentList = CAspContentList::NewLC(param); + + CAspProfile* profile = CAspProfile::NewLC(param); + + TRAPD (err, profile->OpenL(iAutoSyncProfileId, CAspProfile::EOpenReadWrite, + CAspProfile::EAllProperties)); + User::LeaveIfError(err); + + asContentList->SetProfile(profile); + asContentList->InitAllTasksL(); + + TBool aEnabled; + + TInt providerCount = asContentList->ProviderCount(); + + for (TInt i= 0; i < providerCount; i++) + { + if(ContentEnabled(i)) + { + aEnabled = ETrue; + } + else + { + aEnabled = EFalse; + } + TAspProviderItem& provider = asContentList->ProviderItem(i); + if (provider.iDataProviderId != KErrNotFound) + { + asContentList->ModifyTaskIncludedL(provider.iDataProviderId, aEnabled, KNullDesC); + } + } + CleanupStack::PopAndDestroy(profile); + CleanupStack::PopAndDestroy(asContentList); + FLOG( _L("CAspSchedule::CopyAutoSyncContentsL END") ); + + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::UpdateProfileSettingsL +// -Copy latest settings from profile selected for sync to auto sync profile. +// -Called before every scheduled sync to get updated settings +// -Also called when any settings changed +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::UpdateProfileSettingsL() + { + FLOG( _L("CAspSchedule::UpdateProfileSettingsL START") ); + if (iProfileId == KErrNotFound || iAutoSyncProfileId == KErrNotFound) + { + return; + } + OpenSyncSessionL(); + TAspParam param(EApplicationIdSync, &iSyncSession); + + param.iMode = CAspContentList::EInitDataProviders; + + CAspContentList* asContentList = CAspContentList::NewL(param); + CleanupStack::PushL(asContentList); + CAspContentList* contentList = CAspContentList::NewL(param); + CleanupStack::PushL(contentList); + + CAspProfile* selectedProfile = CAspProfile::NewLC(param); + selectedProfile->OpenL(iProfileId, CAspProfile::EOpenRead, CAspProfile::EAllProperties); + + CAspProfile* autosyncProfile = CAspProfile::NewLC(param); + autosyncProfile->OpenL(iAutoSyncProfileId, CAspProfile::EOpenReadWrite, CAspProfile::EAllProperties); + + autosyncProfile->CopyValuesL(selectedProfile); + autosyncProfile->SetSASyncStateL(ESmlDisableSync); + autosyncProfile->SaveL(); + + //Copy database names. + contentList->SetProfile(selectedProfile); + contentList->InitAllTasksL(); + + TBuf aLocalDatabase; + TBuf aRemoteDatabase; + TInt aSyncDirection; + TBool aTaskEnabled; + + asContentList->SetProfile(autosyncProfile); + asContentList->InitAllTasksL(); + + TInt providerCount = asContentList->ProviderCount(); + + for (TInt i= 0; i < providerCount; i++) + { + TAspProviderItem& provider = asContentList->ProviderItem(i); + + contentList->ReadTaskL(provider.iDataProviderId, aLocalDatabase, aRemoteDatabase, + aTaskEnabled, aSyncDirection); + + + if(ContentEnabled(i)) + { + aTaskEnabled = ETrue; + } + else + { + aTaskEnabled = EFalse; + } + + if (provider.iDataProviderId == KUidNSmlAdapterEMail.iUid) + { + if (!MailboxExistL()) + { + continue; + } + RSyncMLDataProvider provider; + TInt err; + TRAP(err, provider.OpenL(iSyncSession, KUidNSmlAdapterEMail.iUid)); + aLocalDatabase = provider.DefaultDataStoreName(); + } + + if (aTaskEnabled) + { + TBuf asLocaldb; + TBuf asRemotedb; + TBool asTask; + TInt asDirection; + + asContentList->ReadTaskL(provider.iDataProviderId,asLocaldb,asRemotedb, + asTask,asDirection); + + if (asLocaldb != aLocalDatabase || asRemotedb != aRemoteDatabase || + asTask != aTaskEnabled || asDirection != aSyncDirection ) + { + TRAPD(err, asContentList->CreateTaskL(provider.iDataProviderId, aLocalDatabase, aRemoteDatabase, + aTaskEnabled, aSyncDirection)); + User::LeaveIfError(err); + } + } + + } + CleanupStack::PopAndDestroy(autosyncProfile); + CleanupStack::PopAndDestroy(selectedProfile); + + CleanupStack::PopAndDestroy(contentList); + CleanupStack::PopAndDestroy(asContentList); + FLOG( _L("CAspSchedule::UpdateProfileSettingsL END") ); + + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::UpdatePeakSchedule +// ----------------------------------------------------------------------------- +// +void CAspSchedule::UpdatePeakScheduleL() + { + //Today's peak time ended ,postpone the peak scheduling until tomorrow peak start time + CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC(); + TIntervalType intervalType = syncSchedule->IntervalType(SyncPeakSchedule()); + if(intervalType == EDaily ) + { + CleanupStack::PopAndDestroy(syncSchedule); + return; + } + syncSchedule->UpdatePeakScheduleL(this); + CleanupStack::PopAndDestroy(syncSchedule); + + } +// ----------------------------------------------------------------------------- +// CAspSchedule::UpdateOffPeakSchedule +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::UpdateOffPeakScheduleL() + { + //postpone the off-peak scheduling until tomorrow off-peak start time + CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC(); + TIntervalType intervalType = syncSchedule->IntervalType(SyncOffPeakSchedule()); + if (intervalType == EDaily ) + { + CleanupStack::PopAndDestroy(syncSchedule); + return; + } + syncSchedule->UpdateOffPeakScheduleL(this); + CleanupStack::PopAndDestroy(syncSchedule); + + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::EnableSchedule +// ----------------------------------------------------------------------------- +// +void CAspSchedule::EnableScheduleL() + { + if ( iPeakScheduleHandle == KErrNotFound && iOffPeakScheduleHandle == KErrNotFound) + { + return; + } + CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC(); + syncSchedule->EnableSchedule(this); + CleanupStack::PopAndDestroy(syncSchedule); + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::UpdateOffPeakSchedule +// ----------------------------------------------------------------------------- +// +TIntervalType CAspSchedule::IntervalType(TInt aInterval) + { + if (aInterval == EInterval24hours + || aInterval == EInterval2days + || aInterval == EInterval4days + || aInterval == EInterval7days + || aInterval == EInterval14days + || aInterval == EInterval30days) + { + return EDaily; + } + + return EHourly; + } + +// ---------------------------------------------------------------------------- +// CAspSchedule::MailboxExistL() +// Return ETrue if any mail box exists, EFlase otherwise +// ---------------------------------------------------------------------------- +// +TBool CAspSchedule::MailboxExistL() + { + OpenSyncSessionL(); + TBool mailboxExist = EFalse; + TAspParam param(EApplicationIdSync, &iSyncSession); + param.iMode = CAspContentList::EInitDataProviders; + CAspContentList* contentList = CAspContentList::NewL(param); + CleanupStack::PushL(contentList); + // get email syncml mailboxes + CDesCArray* localDataStores = new (ELeave) CDesCArrayFlat(KDefaultArraySize); + CleanupStack::PushL(localDataStores); + contentList->GetLocalDatabaseList(KUidNSmlAdapterEMail.iUid, localDataStores); + + if (localDataStores->Count() > 0) + { + mailboxExist = ETrue; + } + + CleanupStack::PopAndDestroy(localDataStores); + CleanupStack::PopAndDestroy(contentList); + + return mailboxExist; + } + + +// ---------------------------------------------------------------------------- +// CAspSchedule::ProtocolL() +// Return server protocol version +// ---------------------------------------------------------------------------- +// +TInt CAspSchedule::ProtocolL() + { + OpenSyncSessionL(); + TAspParam param(EApplicationIdSync, &iSyncSession); + CAspProfile* profile = CAspProfile::NewLC(param); + profile->OpenL(iProfileId, CAspProfile::EOpenRead, + CAspProfile::EBaseProperties); + TInt protocol = profile->ProtocolVersion(); + CleanupStack::PopAndDestroy(profile); + return protocol; + } + + +// ---------------------------------------------------------------------------- +// CAspSchedule::IsAutoSyncEnabled() +// Return ETrue if autosync enable ,EFalse otherwise +// ---------------------------------------------------------------------------- +// +TBool CAspSchedule::IsAutoSyncEnabled() + { + if (iDailySyncEnabled || iPeakSyncEnabled || iOffPeakSyncEnabled) + { + return ETrue; + } + return EFalse; + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::OpenSyncSessionL +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::OpenSyncSessionL() + { + if (!iSyncSessionOpen) + { + TRAPD(err, iSyncSession.OpenL()); + + if (err != KErrNone) + { + FLOG( _L("### CAspSchedule: RSyncMLSession::OpenL failed (%d) ###"), err ); + User::Leave(err); + } + + iSyncSessionOpen = ETrue; + } + } + +// ----------------------------------------------------------------------------- +// CAspSchedule::CloseSyncSession +// ----------------------------------------------------------------------------- +// + +void CAspSchedule::CloseSyncSession() + { + if (iSyncSessionOpen) + { + iSyncSession.Close(); + iSyncSessionOpen = EFalse; + } + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::CheckMandatoryData +// +// ----------------------------------------------------------------------------- +// +TInt CAspSchedule::CheckMandatoryDataL(TInt& count,TInt& firstItem) + { + FLOG( _L("CAspSchedule::CheckMandatoryDataL START") ); + OpenSyncSessionL(); + TAspParam param(EApplicationIdSync, &iSyncSession); + + CAspProfile* profile = CAspProfile::NewLC(param); + profile->OpenL(iProfileId, CAspProfile::EOpenRead, CAspProfile::EAllProperties); + + param.iProfile = profile; + param.iMode = CAspContentList::EInitAll; + CAspContentList* list = CAspContentList::NewLC(param); + + TInt index = 0; + count = 0; + firstItem = 0; + + TInt providerCount = list->ProviderCount(); + + for (TInt i= 0; i < providerCount; i++) + { + if (ContentEnabled(i)) + { + FLOG( _L("Content Id : %d"),i ); + TAspProviderItem& provider = list->ProviderItem(i); + index = list->FindTaskIndexForProvider(provider.iDataProviderId); + if (index == KErrNotFound ) + { + FLOG( _L("Index not found , Id : %d"),i ); + count++; + if(count == 1) + { + firstItem = i; + } + continue; + } + TAspTaskItem& task = list->TaskItem(index); + if (provider.iDataProviderId == KUidNSmlAdapterEMail.iUid) + { + if(!task.iRemoteDatabaseDefined || !task.iLocalDatabaseDefined) + { + count++; + if(count == 1) + { + firstItem = i; + } + } + } + else + { + if (!task.iRemoteDatabaseDefined) + { + count++; + if(count == 1) + { + firstItem = i; + } + } + } + } + } + + CleanupStack::PopAndDestroy(list); + CleanupStack::PopAndDestroy(profile); + + if (count) + { + return EFalse; + } + + FLOG( _L("CAspSchedule::CheckMandatoryDataL END") ); + return ETrue; + + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::ShowAutoSyncLogL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::ShowAutoSyncLogL() + { + FLOG( _L("CAspSchedule::ShowAutoSyncLogL START") ); + OpenSyncSessionL(); + TAspParam param(EApplicationIdSync, &iSyncSession); + param.iProfileId = iProfileId; + + CAspProfile* asProfile = CAspProfile::NewLC(param); + asProfile->OpenL(iAutoSyncProfileId, CAspProfile::EOpenRead, CAspProfile::EAllProperties); + + CAspProfile* profile = CAspProfile::NewLC(param); + profile->OpenL(iProfileId, CAspProfile::EOpenRead, CAspProfile::EAllProperties); + + if (asProfile->LastSync() > profile->LastSync()) + { + param.iProfileId = iAutoSyncProfileId; + } + CleanupStack::PopAndDestroy(profile); + CleanupStack::PopAndDestroy(asProfile); + + CAspLogDialog* dialog = CAspLogDialog::NewL(param); + CleanupStack::PushL(dialog); + + dialog->ShowDialogL(); + + CleanupStack::PopAndDestroy(dialog); + FLOG( _L("CAspSchedule::ShowAutoSyncLogL END") ); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::UpdateServerIdL +// Do server id modifications so that SAN selectes correct profile instead of hidden +// auto sync profile. +// ----------------------------------------------------------------------------- +// +void CAspSchedule::UpdateServerIdL() + { + FLOG( _L("CAspSchedule::ClearAutoSyncProfileServerL START") ); + OpenSyncSessionL(); + TAspParam param(EApplicationIdSync, &iSyncSession); + + CAspProfile* asprofile = CAspProfile::NewLC(param); + TRAPD (err, asprofile->OpenL(iAutoSyncProfileId, CAspProfile::EOpenReadWrite, + CAspProfile::EAllProperties)); + User::LeaveIfError(err); + + CAspProfile* profile = CAspProfile::NewLC(param); + TRAPD (err1, profile->OpenL(iProfileId, CAspProfile::EOpenReadWrite, + CAspProfile::EAllProperties)); + User::LeaveIfError(err1); + + asprofile->GetServerId(iBuf); + profile->SetServerIdL(iBuf); + asprofile->SetServerIdL(KNullDesC); + profile->SaveL(); + asprofile->SaveL(); + + CleanupStack::PopAndDestroy(profile); + CleanupStack::PopAndDestroy(asprofile); + FLOG( _L("CAspSchedule::ClearAutoSyncProfileServerL END") ); + } +// ----------------------------------------------------------------------------- +// CAspSchedule::IsContentSelected +// +// ----------------------------------------------------------------------------- +// +TBool CAspSchedule::IsContentSelected() + { + TInt selectedContentCnt = 0; + TInt selectedContentIndex = 0; + + ContentSelectionInfo(selectedContentCnt, selectedContentIndex); + if (selectedContentCnt) + { + return ETrue; + } + return EFalse; + } + + +#ifdef _DEBUG + +void CAspSchedule::LogSettings() + { + FLOG( _L("iProfileId %d"),iProfileId); + FLOG( _L("iPeakScheduleHandle %d"),iPeakScheduleHandle); + FLOG( _L("iOffPeakScheduleHandle %d"),iOffPeakScheduleHandle); + FLOG( _L("iStartPeakTimeHr %d"),iStartPeakTimeHr); + FLOG( _L("iStartPeakTimeMin %d"),iStartPeakTimeMin); + FLOG( _L("iEndPeakTimeHr %d"),iEndPeakTimeHr); + FLOG( _L("iEndPeakTimeMin %d"),iEndPeakTimeMin); + FLOG( _L("iSyncPeakSchedule %d"),iSyncPeakSchedule); + FLOG( _L("iSyncOffPeakSchedule %d"),iSyncOffPeakSchedule); + FLOG( _L("iDailySyncEnabled %d"),iDailySyncEnabled); + FLOG( _L("iPeakSyncEnabled %d"),iPeakSyncEnabled); + FLOG( _L("iOffPeakSyncEnabled %d"),iOffPeakSyncEnabled); + FLOG( _L("iAutoSyncProfileId %d"),iAutoSyncProfileId); + FLOG( _L("iAutoSyncScheduleTimeHr %d"),iAutoSyncScheduleTimeHr); + FLOG( _L("iAutoSyncScheduleTimeMin %d"),iAutoSyncScheduleTimeMin); + + + } + + + +// ----------------------------------------------------------------------------- +// CAspSchedule::LogScheduleL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::LogScheduleL() + { + TBuf<128> buf; TBuf<128> buf2; + + FLOG( _L("---- automatic sync settings ----") ); + + TTime time; + time.HomeTime(); + TUtil::GetDateTimeTextL(buf, time); + buf2.Format(_L("current time: %S"), &buf); + FLOG(buf2); + + if (PeakSyncEnabled()) + { + buf = _L("Peak sync enabled"); + } + + FLOG(buf); + + if (OffPeakSyncEnabled()) + { + buf = _L("Off-Peak sync enabled"); + } + FLOG(buf); + + TInt id = ProfileId(); + FLOG(_L("profile id: %d"), id); + + LogSyncInterval(); + LogSyncDays(); + +#if 0 + if (RoamingAllowed()) + { + buf = _L("roaming allowed: yes"); + } + else + { + buf = _L("roaming allowed: no"); + } + FLOG(buf); +#endif + FLOG( _L("---- automatic sync settings ----") ); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::LogSyncDays +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::LogSyncDays() + { + TBuf<128> buf; TBuf<128> buf2; + + buf = KNullDesC; + + if (WeekdayEnabled(EMonday)) + { + buf.Append(_L("monday ")); + } + if (WeekdayEnabled(ETuesday)) + { + buf.Append(_L("tuesday ")); + } + if (WeekdayEnabled(EWednesday)) + { + buf.Append(_L("wednesday ")); + } + if (WeekdayEnabled(EThursday)) + { + buf.Append(_L("thursday ")); + } + if (WeekdayEnabled(EFriday)) + { + buf.Append(_L("friday ")); + } + if (WeekdayEnabled(ESaturday)) + { + buf.Append(_L("saturday ")); + } + if (WeekdayEnabled(ESunday)) + { + buf.Append(_L("sunday ")); + } + if (buf.Length() == 0) + { + buf.Append(_L("none")); + } + + buf2.Format(_L("sync days: %S"), &buf); + FLOG(buf2); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::LogSyncInterval +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::LogSyncInterval() + { + TBuf<128> buf; TBuf<128> buf2; + + switch (iSyncPeakSchedule) + { + case CAspSchedule::EIntervalManual: + buf = _L("Manual"); + break; + case CAspSchedule::EInterval15Mins: + buf = _L("15 minutes"); + break; + case CAspSchedule::EInterval30Mins: + buf = _L("30 minutes"); + break; + case CAspSchedule::EInterval1hour: + buf = _L("1 hour"); + break; + case CAspSchedule::EInterval2hours: + buf = _L("2 hours"); + break; + case CAspSchedule::EInterval4hours: + buf = _L("4 hours"); + break; + case CAspSchedule::EInterval8hours: + buf = _L("8 hours"); + break; + case CAspSchedule::EInterval12hours: + buf = _L("12 hours"); + break; + case CAspSchedule::EInterval24hours: + buf = _L("24 hours"); + break; + case CAspSchedule::EInterval2days: + buf = _L("2 days"); + break; + case CAspSchedule::EInterval4days: + buf = _L("4 days"); + break; + case CAspSchedule::EInterval7days: + buf = _L("7 days"); + break; + case CAspSchedule::EInterval14days: + buf = _L("14 days"); + break; + case CAspSchedule::EInterval30days: + buf = _L("30 days"); + break; + default: + buf = _L("unknown sync interval"); + break; + } + + buf2.Format(_L("sync interval: %S"), &buf); + FLOG(buf2); + } + +#endif // _DEBUG + + +#ifdef _DEBUG + + +// ---------------------------------------------------------------------------- +// CAspSchedule::PrintTimeL +// +// ---------------------------------------------------------------------------- +// +void CAspSchedule::PrintTimeL(TTime aTime) + { + TBuf<128> buf; + TUtil::GetDateTimeTextL(buf, aTime); + TDialogUtil::ShowInformationQueryL(buf); + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::TestL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::TestL() + { + TRAPD(err, DoTestL()); + + if (err != KErrNone) + { + TBuf buf; + buf.Format(_L("TestL failed (%d)"), err); + TDialogUtil::ShowErrorNoteL(buf); + } + } + + +// ----------------------------------------------------------------------------- +// CAspSchedule::DoTestL +// +// ----------------------------------------------------------------------------- +// +void CAspSchedule::DoTestL() + { + const TInt KTestCount = 500; + + TInt err = KErrNone; + + ResetRepositoryL(); + + CAspSchedule* s = NULL; + TInt count = 0; + for (; count buf; + buf.Format(_L("centrep test ok (%d)"), count); + TDialogUtil::ShowErrorNoteL(buf); + + + return; + } + + +// ---------------------------------------------------------------------------- +// UpdateValuesL +// +// ---------------------------------------------------------------------------- +// +void CAspSchedule::UpdateValuesL(TInt aCount) + { + TInt num = 100 * aCount; + TBool isEven = aCount % 2; + + iPeakScheduleHandle = num+1; + iOffPeakScheduleHandle = num +1; + + iError = num+3; + + iPeakSyncEnabled = isEven; + iOffPeakSyncEnabled = isEven; + iProfileId = num+4; + + iRoamingAllowed = isEven; + + if (isEven) + { + SetWeekdayEnabled(EMonday, ETrue); + SetWeekdayEnabled(ETuesday, ETrue); + SetWeekdayEnabled(EWednesday, ETrue); + SetWeekdayEnabled(EThursday, ETrue); + SetWeekdayEnabled(EFriday, ETrue); + SetWeekdayEnabled(ESaturday, EFalse); + SetWeekdayEnabled(ESunday, EFalse); + } + else + { + SetWeekdayEnabled(EMonday, EFalse); + SetWeekdayEnabled(ETuesday, EFalse); + SetWeekdayEnabled(EWednesday, EFalse); + SetWeekdayEnabled(EThursday, EFalse); + SetWeekdayEnabled(EFriday, EFalse); + SetWeekdayEnabled(ESaturday, ETrue); + SetWeekdayEnabled(ESunday, ETrue); + } + } + + +// ---------------------------------------------------------------------------- +// CreateCopyLC +// +// ---------------------------------------------------------------------------- +// +CAspSchedule* CAspSchedule::CreateCopyLC() + { + CAspSchedule* s = CAspSchedule::NewL(); + CleanupStack::PushL(s); + + s->iPeakScheduleHandle = iPeakScheduleHandle; + s->iOffPeakScheduleHandle = iOffPeakScheduleHandle; + s->iError = iError; + s->SetProfileId(ProfileId()); + s->SetPeakSyncEnabled(PeakSyncEnabled()); + s->SetRoamingAllowed(RoamingAllowed()); + + + TBool enabled = EFalse; + if (WeekdayEnabled(EMonday)) + { + enabled = ETrue; + } + s->SetWeekdayEnabled(EMonday, enabled); + + enabled = EFalse; + if (WeekdayEnabled(ETuesday)) + { + enabled = ETrue; + } + s->SetWeekdayEnabled(ETuesday, enabled); + + enabled = EFalse; + if (WeekdayEnabled(EWednesday)) + { + enabled = ETrue; + } + s->SetWeekdayEnabled(EWednesday, enabled); + + enabled = EFalse; + if (WeekdayEnabled(EThursday)) + { + enabled = ETrue; + } + s->SetWeekdayEnabled(EThursday, enabled); + + enabled = EFalse; + if (WeekdayEnabled(EFriday)) + { + enabled = ETrue; + } + s->SetWeekdayEnabled(EFriday, enabled); + + enabled = EFalse; + if (WeekdayEnabled(ESaturday)) + { + enabled = ETrue; + } + s->SetWeekdayEnabled(ESaturday, enabled); + + enabled = EFalse; + if (WeekdayEnabled(ESunday)) + { + enabled = ETrue; + } + s->SetWeekdayEnabled(ESunday, enabled); + + return s; + } + + +// ---------------------------------------------------------------------------- +// CompareValues +// +// ---------------------------------------------------------------------------- +// +void CAspSchedule::CompareValues(CAspSchedule* aSchedule) + { + CAspSchedule* s = aSchedule; + + AssertEqual(s->PeakScheduleHandle(), PeakScheduleHandle()); + AssertEqual(s->OffPeakScheduleHandle(), OffPeakScheduleHandle()); + AssertEqual(s->Error(), Error()); + AssertEqual(s->ProfileId(), ProfileId()); + + AssertEqual(s->PeakSyncEnabled(), PeakSyncEnabled()); + AssertEqual(s->OffPeakSyncEnabled(), OffPeakSyncEnabled()); + + AssertEqual(s->RoamingAllowed(), RoamingAllowed()); + + AssertEqual(s->iWeekdayFlags, iWeekdayFlags); + + AssertEqual(s->WeekdayEnabled(EMonday), WeekdayEnabled(EMonday)); + AssertEqual(s->WeekdayEnabled(ETuesday), WeekdayEnabled(ETuesday)); + AssertEqual(s->WeekdayEnabled(EWednesday), WeekdayEnabled(EWednesday)); + AssertEqual(s->WeekdayEnabled(EThursday), WeekdayEnabled(EThursday)); + AssertEqual(s->WeekdayEnabled(EFriday), WeekdayEnabled(EFriday)); + AssertEqual(s->WeekdayEnabled(ESaturday), WeekdayEnabled(ESaturday)); + AssertEqual(s->WeekdayEnabled(ESunday), WeekdayEnabled(ESunday)); + } + + +// ---------------------------------------------------------------------------- +// AssertEqual +// +// ---------------------------------------------------------------------------- +// +void CAspSchedule::AssertEqual(TInt aValue1, TInt aValue2) + { + __ASSERT_DEBUG(aValue1 == aValue2, TUtil::Panic(KErrArgument)); + } + +#endif // _DEBUG + + + +// End of file +