--- a/omads/omadsappui/AspSyncUtil/src/AspSchedule.cpp Thu Aug 19 09:41:17 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2481 +0,0 @@
-/*
-* 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 <s32mem.h> // RDesWriteStream
-#include <s32file.h> // RFileReadStream
-#include <bautils.h> // BaflUtils
-#include <centralrepository.h> // CRepository
-#include <rconnmon.h>
-#include <SyncMLClientDS.h>
-
-
-
-/*******************************************************************************
- * 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<KBufSize> 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<KBufSize> aLocalDatabase;
- TBuf<KBufSize> 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<KBufSize> asLocaldb;
- TBuf<KBufSize> 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<KBufSize> 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<KTestCount; count++)
- {
- TRAP(err, InternalizeL());
- if (err != KErrNone)
- {
- User::Leave(err);
- }
-
- if (s)
- {
- CompareValues(s);
- CleanupStack::PopAndDestroy(s);
- s = NULL;
- }
-
- TRAP(err, UpdateValuesL(count));
- if (err != KErrNone)
- {
- User::Leave(err);
- }
-
- s = CreateCopyLC();
-
- TRAP(err, ExternalizeL());
- if (err != KErrNone)
- {
- User::Leave(err);
- }
- }
-
- if (s)
- {
- CleanupStack::PopAndDestroy(s);
- }
-
- TBuf<KBufSize> 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
-