diff -r 2bb96f4ecad8 -r 8e7494275d3a omads/omadsappui/AspSyncUtil/src/AspAutoSyncHandler.cpp --- a/omads/omadsappui/AspSyncUtil/src/AspAutoSyncHandler.cpp Thu Aug 19 09:41:17 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1597 +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 "AspAutoSyncHandler.h" -#include "AspUtil.h" -#include "AspDialogUtil.h" -#include "AspDebug.h" - -#include // TScheduleEntryInfo2 -#include // RDesWriteStream -#include // RFileReadStream -//#include // CRepository -#include - - - - -_LIT(KPeakTaskData, "aspschedulehandler peak task"); -_LIT(KOffPeakTaskData, "aspschedulehandler off-peak task"); - - -// ============================ MEMBER FUNCTIONS =============================== - - - -/******************************************************************************* - * class CAspAutoSyncHandler - *******************************************************************************/ - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::NewL -// -// ----------------------------------------------------------------------------- -// -CAspAutoSyncHandler* CAspAutoSyncHandler::NewL() - { - CAspAutoSyncHandler* self = new (ELeave) CAspAutoSyncHandler(); - CleanupStack::PushL(self); - self->ConstructL(); - CleanupStack::Pop(self); - - return(self); - } - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::CAspAutoSyncHandler -// -// ----------------------------------------------------------------------------- -// -CAspAutoSyncHandler::CAspAutoSyncHandler() - { - iSyncError = KErrNone; - iSyncSessionOpen = EFalse; - iSyncRunning = EFalse; - } - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::ConstructL -// -// ----------------------------------------------------------------------------- -// -void CAspAutoSyncHandler::ConstructL() - { - iWait = new (ELeave) CActiveSchedulerWait(); - - iSchedule = CAspSchedule::NewL(); - } - - -// ---------------------------------------------------------------------------- -// Destructor -// -// ---------------------------------------------------------------------------- -// -CAspAutoSyncHandler::~CAspAutoSyncHandler() - { - if (iWait && iWait->IsStarted()) - { - iWait->AsyncStop(); - } - delete iWait; - - delete iSchedule; - - CloseSyncSession(); - } - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::OnSyncMLSessionEvent (from MSyncMLEventObserver) -// -// ----------------------------------------------------------------------------- -// -void CAspAutoSyncHandler::OnSyncMLSessionEvent(TEvent aEvent, TInt /*aIdentifier*/, - TInt aError, TInt /*aAdditionalData*/) - { - FLOG( _L("CAspAutoSyncHandler::OnSyncMLSessionEvent START") ); - - if (aEvent == EJobStart) - { - FLOG( _L("EJobStart") ); - } - - if (aEvent == EJobStop) - { - if (aError != KErrNone) - { - iSyncError = aError; - } - - FLOG( _L("EJobStop") ); - - iWait->AsyncStop(); - } - - if (aEvent == EJobStartFailed || aEvent == EJobRejected || aEvent == EServerTerminated) - { - FLOG( _L("EJobStartFailed or EJobRejected or EServerTerminated") ); - iWait->AsyncStop(); - } - - FLOG( _L("CAspAutoSyncHandler::OnSyncMLSessionEvent END") ); - } - - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::OnSyncMLSyncError (from MSyncMLProgressObserver) -// -// ----------------------------------------------------------------------------- -// -void CAspAutoSyncHandler::OnSyncMLSyncError(TErrorLevel aErrorLevel, - TInt aError, TInt /*aTaskId*/, - TInt /*aInfo1*/, TInt /*aInfo2*/) - { - FLOG( _L("CAspAutoSyncHandler::OnSyncMLSyncError START") ); - - if (aErrorLevel == ESmlFatalError) - { - iSyncError = aError; - iWait->AsyncStop(); - } - - FLOG( _L("CAspAutoSyncHandler::OnSyncMLSyncError END") ); - } - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::OnSyncMLSyncProgress (from MSyncMLProgressObserver) -// -// ----------------------------------------------------------------------------- -// -void CAspAutoSyncHandler::OnSyncMLSyncProgress(TStatus /*aStatus*/, - TInt /*aInfo1*/, TInt /*aInfo2*/) - { - // not needed in scheduled sync - } - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::OnSyncMLDataSyncModifications (from MSyncMLProgressObserver) -// -// ----------------------------------------------------------------------------- -// -void CAspAutoSyncHandler::OnSyncMLDataSyncModifications(TInt /*aTaskId*/, - const TSyncMLDataSyncModifications& /*aClientModifications*/, - const TSyncMLDataSyncModifications& /*aServerModifications*/) - { - // not needed in scheduled sync - } - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::OpenSyncSessionL -// -// ----------------------------------------------------------------------------- -// -void CAspAutoSyncHandler::OpenSyncSessionL() - { - if (!iSyncSessionOpen) - { - TRAPD(err, iSyncSession.OpenL()); - - if (err != KErrNone) - { - FLOG( _L("### CAspAutoSyncHandler: RSyncMLSession::OpenL failed (%d) ###"), err ); - User::Leave(err); - } - - iSyncSessionOpen = ETrue; - } - } - - -// ----------------------------------------------------------------------------- -// CloseSyncSession -// -// ----------------------------------------------------------------------------- -// -void CAspAutoSyncHandler::CloseSyncSession() - { - if (iSyncSessionOpen) - { - iSyncJob.Close(); // this can be done when job has not been opened - iSyncSession.Close(); - iSyncSessionOpen = EFalse; - } - } - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::CheckMandatoryData -// -// ----------------------------------------------------------------------------- -// -TInt CAspAutoSyncHandler::CheckMandatoryDataL(TInt aProfileId) - { - TAspParam param(EApplicationIdSync, &iSyncSession); - - CAspProfile* profile = CAspProfile::NewLC(param); - profile->OpenL(aProfileId, CAspProfile::EOpenRead, CAspProfile::EAllProperties); - - param.iProfile = profile; - param.iMode = CAspContentList::EInitAll; - CAspContentList* list = CAspContentList::NewLC(param); - - //TInt contentCount = 0; - TInt mandatoryConnectionData = CAspProfile::CheckMandatoryConnData(profile); - //TInt mandatoryContentData = list->CheckMandatoryDataL(contentCount); - - TInt mandatoryBearerType = EMandatoryOk; - if (profile->BearerType() != EAspBearerInternet) - { - mandatoryBearerType = EMandatoryIncorrectBearerType; - } - - TInt mandatoryAccessPoint = EMandatoryOk; - /*if (profile->AccessPointL() == CAspAccessPointHandler::KAskAlways) - { - mandatoryAccessPoint = EMandatoryIncorrectAccessPoint; - }*/ - - CleanupStack::PopAndDestroy(list); - CleanupStack::PopAndDestroy(profile); - - if (mandatoryBearerType != EMandatoryOk) - { - return mandatoryBearerType; - } - - if (mandatoryAccessPoint != EMandatoryOk) - { - return mandatoryAccessPoint; - } - - if (mandatoryConnectionData != EMandatoryOk) - { - return mandatoryConnectionData; - } - - return EMandatoryOk;//mandatoryContentData; - } - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::SynchronizeL -// -// ----------------------------------------------------------------------------- -// -void CAspAutoSyncHandler::SynchronizeL(RFile& aTaskFile) - { - - FLOG( _L("CAspAutoSyncHandler::SynchronizeL START") ); - - CFileStore* store; - RStoreReadStream instream; - // Get tasks from scheduler's store - store = CDirectFileStore::FromLC(aTaskFile); - instream.OpenLC(*store,store->Root()); - TInt count = instream.ReadInt32L(); - - CScheduledTask* task = CScheduledTask::NewLC(instream); - HBufC* taskData = const_cast(&(task->Data())); - TPtr ptr = taskData->Des(); - TBool doCleanUp = ETrue; - - if (ptr.Compare(KPeakTaskData) == 0) - { - FLOG( _L("Peak Sync Scheduled") ); - TInt interval = iSchedule->SyncPeakSchedule(); - if (iSchedule->IntervalType(interval) == EHourly - && interval != CAspSchedule::EIntervalManual) - { - if (iSchedule->IsValidPeakScheduleL() != 0) - { - //postpone peak schedule until next peak start - iSchedule->UpdatePeakScheduleL(); - CleanupStack::PopAndDestroy(task); - CleanupStack::PopAndDestroy( &instream ); - CleanupStack::PopAndDestroy( store ); - doCleanUp = EFalse; - return; - } - else - { - //schedule next sync - if(!iSchedule->IsValidNextPeakScheduleL()) - { - iSchedule->UpdatePeakScheduleL(); - } - else - { - CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC(); - syncSchedule->EditPeakScheduleL(iSchedule); - CleanupStack::PopAndDestroy(syncSchedule); - } - } - } - else - { - //schedule next sync - CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC(); - syncSchedule->EditPeakScheduleL(iSchedule); - CleanupStack::PopAndDestroy(syncSchedule); - } - } - - if (ptr.Compare(KOffPeakTaskData) == 0) - { - FLOG( _L("Off-Peak Sync Scheduled") ); - TInt interval = iSchedule->SyncOffPeakSchedule(); - if (iSchedule->IntervalType(interval) == EHourly) - { - if (iSchedule->IsValidOffPeakScheduleL() != 0) - { - //postpone off-schedule until next off-peak start - iSchedule->UpdateOffPeakScheduleL(); - CleanupStack::PopAndDestroy(task); - CleanupStack::PopAndDestroy( &instream ); - CleanupStack::PopAndDestroy( store ); - doCleanUp = EFalse; - return; - } - else - { - //schedule next sync - if(!iSchedule->IsValidNextOffPeakScheduleL()) - { - iSchedule->UpdateOffPeakScheduleL(); - } - else - { - CAspSyncSchedule* syncSchedule = CAspSyncSchedule::NewLC(); - syncSchedule->EditOffPeakScheduleL(iSchedule); - CleanupStack::PopAndDestroy(syncSchedule); - } - } - - } - } - - if(doCleanUp) - { - CleanupStack::PopAndDestroy(task); - CleanupStack::PopAndDestroy( &instream ); - CleanupStack::PopAndDestroy( store ); - doCleanUp = EFalse; - } - - iSchedule->SetError(KErrNone); - iSchedule->SaveL(); - - TRAPD (err, DoSynchronizeL()); - User::LeaveIfError(err); - -} - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::DoSynchronizeL -// -// ----------------------------------------------------------------------------- -// -void CAspAutoSyncHandler::DoSynchronizeL() -{ - - OpenSyncSessionL(); - - if (CAspProfile::OtherSyncRunning(&iSyncSession)) - { - FLOG( _L("### other sync running ###") ); - TInt currentJobId = CAspProfile::CurrentJob(&iSyncSession); - if (currentJobId != KErrNotFound) - { - iSyncJob.OpenL(iSyncSession, currentJobId); - if (iSchedule->ProfileId() != iSyncJob.Profile()) - { - FLOG( _L("CAspAutoSyncHandler::SynchronizeL Set Error") ); - iSchedule->SetError(EOtherSyncRunning); - iSchedule->SaveL(); - } - iSyncJob.Close(); - } - FLOG( _L("CAspAutoSyncHandler::SynchronizeL END") ); - return; - } - - TInt profileId = iSchedule->AutoSyncProfileId(); - iSchedule->UpdateProfileSettingsL(); - iSchedule->SaveL(); - - -#ifdef _DEBUG - iSchedule->LogScheduleL(); -#endif - - if (!iSchedule->CanSynchronizeL()) - { - FLOG( _L("### incorrect auto sync settings ###") ); - FLOG( _L("CAspAutoSyncHandler::SynchronizeL END") ); - //iSchedule->SetError(EIncorrectSchedule); - //iSchedule->SaveL(); - return; - } - -#if 0 //roaming check not supported - if (!iSchedule->RoamingAllowed()) - { - if (IsRoaming()) - { - FLOG( _L("### cannot sync when roaming ###") ); - FLOG( _L("CAspAutoSyncHandler::SynchronizeL END") ); - return; - } - } -#endif - - - - if (CheckMandatoryDataL(profileId) != EMandatoryOk) - { - FLOG( _L("### incorrect sync profile settings ###") ); - FLOG( _L("CAspAutoSyncHandler::SynchronizeL END") ); - //iSchedule->SetError(EIncorrectProfile); - //iSchedule->SaveL(); - return; - } - - - iSyncSession.RequestEventL(*this); // for MSyncMLEventObserver events - iSyncSession.RequestProgressL(*this); // for MSyncMLProgressObserver events - - - iSyncJob.CreateL(iSyncSession, profileId); // start sync - - iSyncRunning = ETrue; - - iWait->Start(); // stop here until sync has completed - - iSyncRunning = EFalse; - - iSchedule->UpdateServerIdL(); - - if (iSyncError != KErrNone) - { - iSchedule->SetError(iSyncError); - iSchedule->SaveL(); - FLOG(_L("### auto sync failed (%d) ###"), iSyncError); - } - - FLOG( _L("CAspAutoSyncHandler::SynchronizeL END") ); - -} - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::IsRoamingL -// -// ----------------------------------------------------------------------------- -// -TBool CAspAutoSyncHandler::IsRoamingL() - { - RConnectionMonitor conMon; - - conMon.ConnectL(); - - TRequestStatus status; - TInt registrationStatus(0); - - //check network status - conMon.GetIntAttribute(EBearerIdGSM, 0, KNetworkRegistration, - registrationStatus, status); - - User::WaitForRequest(status); - conMon.Close(); - - if (registrationStatus == ENetworkRegistrationRoaming) - { - return ETrue; - } - - return EFalse; - } - - -// ----------------------------------------------------------------------------- -// CAspAutoSyncHandler::IsRoaming -// -// ----------------------------------------------------------------------------- -// -TBool CAspAutoSyncHandler::IsRoaming() - { - TBool ret = EFalse; - TRAPD(err, ret = IsRoamingL()); - - if (err != KErrNone) - { - ret = EFalse; // default is not roaming - } - - return ret; - } - - - -/******************************************************************************* - * class CAspSyncSchedule - *******************************************************************************/ - - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::NewL -// -// ----------------------------------------------------------------------------- -// -CAspSyncSchedule* CAspSyncSchedule::NewL() - { - CAspSyncSchedule* self = new (ELeave) CAspSyncSchedule(); - CleanupStack::PushL(self); - self->ConstructL(); - CleanupStack::Pop(self); - - return(self); - } - - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::NewLC -// -// ----------------------------------------------------------------------------- -// -CAspSyncSchedule* CAspSyncSchedule::NewLC() - { - CAspSyncSchedule* self = new (ELeave) CAspSyncSchedule(); - CleanupStack::PushL(self); - self->ConstructL(); - - return(self); - } - - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::CAspSyncSchedule -// -// ----------------------------------------------------------------------------- -// -CAspSyncSchedule::CAspSyncSchedule() - { - } - - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::ConstructL -// -// ----------------------------------------------------------------------------- -// -void CAspSyncSchedule::ConstructL() - { - - _LIT(KScheduleHandler, "z:\\sys\\bin\\aspschedulehandler.exe"); - const TInt KDefaultSchedulePriority = 1; - - TInt err = iScheduler.Connect(); - User::LeaveIfError(err); - - TFileName name(KScheduleHandler); - err = iScheduler.Register(name, KDefaultSchedulePriority); - User::LeaveIfError(err); - - ipeakEntryList = new (ELeave) CArrayFixFlat(1); - ioffPeakEntryList = new (ELeave) CArrayFixFlat(1); - ipeakTaskList = new (ELeave) CArrayFixFlat(1); - ioffPeakTaskList = new (ELeave) CArrayFixFlat(1); - } - - -// ---------------------------------------------------------------------------- -// Destructor -// -// ---------------------------------------------------------------------------- -// -CAspSyncSchedule::~CAspSyncSchedule() - { - delete ipeakEntryList; - delete ioffPeakEntryList; - delete ipeakTaskList; - delete ioffPeakTaskList; - - iScheduler.Close(); - } - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::DoDeleteScheduleL -// - Delete schedules if exist -// ---------------------------------------------------------------------------- -// -void CAspSyncSchedule::DoDeleteScheduleL(CAspSchedule* aAspSchedule) - { - ipeakEntryList->Reset(); - ioffPeakEntryList->Reset(); - ipeakTaskList->Reset(); - ioffPeakTaskList->Reset(); - - TScheduleState2 state; - TTsTime time; - - TInt peakHandle = aAspSchedule->PeakScheduleHandle(); - TInt offPeakHandle = aAspSchedule->OffPeakScheduleHandle(); - - if (peakHandle == KErrNotFound && offPeakHandle == KErrNotFound) - { - return; // nothing to delete - } - if (peakHandle != KErrNotFound) - { - - TInt err = iScheduler.GetScheduleL(peakHandle, state, - *ipeakEntryList, *ipeakTaskList, time); - - TInt count = ipeakTaskList->Count(); - - for (TInt i=0; iSetPeakScheduleHandle(KErrNotFound); - aAspSchedule->SetDailySyncEnabled(EFalse); - aAspSchedule->SetPeakSyncEnabled(EFalse); - - User::LeaveIfError(err); - } - - if (offPeakHandle != KErrNotFound) - { - - TInt err = iScheduler.GetScheduleL(offPeakHandle, state, - *ioffPeakEntryList, *ioffPeakTaskList, time); - - TInt count = ioffPeakTaskList->Count(); - - for (TInt i=0; iSetOffPeakScheduleHandle(KErrNotFound); - aAspSchedule->SetOffPeakSyncEnabled(EFalse); - User::LeaveIfError(err); - } - } - - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::DeleteScheduleL -// -// ---------------------------------------------------------------------------- -// -void CAspSyncSchedule::DeleteScheduleL(CAspSchedule* aAspSchedule) - { - - TRAPD(err, DoDeleteScheduleL(aAspSchedule)); - - if (err == KErrNone) - { - FLOG( _L("CAspSyncSchedule::DeleteScheduleL ok")); - } - else - { - FLOG( _L("CAspSyncSchedule::DeleteSchedule failed ,err: %d"), err ); - } - - if (err != KErrNone && err != KErrNotFound) - { - User::Leave(err); - } - } - - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::CreatePeakScheduleL -// -// ---------------------------------------------------------------------------- -// -void CAspSyncSchedule::CreatePeakScheduleL(CAspSchedule* aAspSchedule) - { - - const TInt KRepeatForever = -1; - const TInt KTaskPriority = 2; - - CAspSchedule* schedule = aAspSchedule; - schedule->SetPeakScheduleHandle(KErrNotFound); - - TTsTime startTime; - TIntervalType intervalType; - TInt interval; - TTime now; - now.HomeTime(); - TInt peakschedule; - TInt peakStatus = schedule->IsValidPeakScheduleL(); - - TDateTime startday; - TInt syncFrequency = schedule->SyncFrequency(); - - //Daily schedule can be done using peak schedule - if (IntervalType(syncFrequency) == EDaily) - { - startday = now.DateTime(); - TTime start = schedule->AutoSyncScheduleTime(); - TDateTime date = start.DateTime(); - TDateTime time(startday.Year(), startday.Month(), startday.Day(), date.Hour(), date.Minute(), 0, 0); - TTime syncTime(time); - startTime.SetLocalTime(syncTime); - } - else - { - TInt dayCount = 0; - TInt dayIndex = 0; - schedule->SelectedDayInfo(dayCount, dayIndex); - if (dayCount == 0) - { - //no need to schedule if peak days are not selected - schedule->SetPeakSyncEnabled(EFalse); - return; - } - - if(schedule->WeekdayEnabled(now.DayNoInWeek())) - { - startday = now.DateTime(); - //If the current time is peak, start now - if (peakStatus == 0) - { - startTime.SetLocalTime(now); - } - //current time is before peak - else if (peakStatus > 0) - { - TTime start = schedule->StartPeakTime(); - TDateTime date = start.DateTime(); - TDateTime time(startday.Year(), startday.Month(), startday.Day(), date.Hour(), date.Minute(), 0, 0); - TTime syncTime(time); - startTime.SetLocalTime(syncTime); - } - //current time is after peak. - else if (peakStatus < 0) - { - TTime start = schedule->StartPeakTime(); - TDateTime date = start.DateTime(); - now = now + (TTimeIntervalDays)1; - while(!schedule->WeekdayEnabled(now.DayNoInWeek())) - { - now = now + (TTimeIntervalDays)1; - } - startday = now.DateTime(); - TDateTime time(startday.Year(), startday.Month(), startday.Day(), date.Hour(), date.Minute(), 0, 0); - TTime syncTime(time); - startTime.SetLocalTime(syncTime); - } - } - - else - { - //find the next day selected for sync - while(!schedule->WeekdayEnabled(now.DayNoInWeek())) - { - now = now + (TTimeIntervalDays)1; - } - - startday = now.DateTime(); - TTime start = schedule->StartPeakTime(); - TDateTime date = start.DateTime(); - TDateTime time(startday.Year(), startday.Month(), startday.Day(), date.Hour(), date.Minute(), 0, 0); - TTime syncTime(time); - startTime.SetLocalTime(syncTime); - } - - } - - TInt validityPeriod = KMaxTInt; - if (schedule->DailySyncEnabled()) - { - peakschedule = schedule->SyncFrequency(); - } - else - { - peakschedule = schedule->SyncPeakSchedule(); - } - intervalType = IntervalType(peakschedule); - interval = Interval(peakschedule); - - TScheduleEntryInfo2 peakEntry(startTime, intervalType, interval, (TTimeIntervalMinutes)validityPeriod); - - - #ifdef _DEBUG - TBuf<64> buf; - LogTsTime(startTime, buf); - FLOG(_L("Auto sync start time: %S"), &buf); - #endif - - - ipeakEntryList->Reset(); - ipeakEntryList->AppendL(peakEntry); - - TSchedulerItemRef ref; - TInt err = iScheduler.CreatePersistentSchedule(ref, *ipeakEntryList); - User::LeaveIfError(err); - - //keep the scheduler disabled until settings are saved - iScheduler.DisableSchedule(ref.iHandle); - - schedule->SetPeakScheduleHandle(ref.iHandle); - - HBufC* hBuf = HBufC::NewMaxLC(KBufSize); - hBuf->Des() = KPeakTaskData; - - TTaskInfo taskInfo; - taskInfo.iName = KPeakTaskData; - taskInfo.iRepeat = KRepeatForever; - taskInfo.iPriority = KTaskPriority; - - err = iScheduler.ScheduleTask(taskInfo, *hBuf, ref.iHandle); - User::LeaveIfError(err); - - CleanupStack::PopAndDestroy(hBuf); - } - - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::CreateOffPeakScheduleL -// -// ---------------------------------------------------------------------------- -// -void CAspSyncSchedule::CreateOffPeakScheduleL(CAspSchedule* aAspSchedule) - { - - const TInt KRepeatForever = -1; - const TInt KTaskPriority = 1; - - CAspSchedule* schedule = aAspSchedule; - schedule->SetOffPeakScheduleHandle(KErrNotFound); - - TTime opStart= schedule->EndPeakTime()+ (TTimeIntervalMinutes)1; - TDateTime opStartDate = opStart.DateTime(); - TTime pStart = schedule->StartPeakTime(); - TDateTime pStartDate = pStart.DateTime(); - - //Dont create off-peak schedule if the duration is zero - if (opStartDate.Hour() == pStartDate.Hour() - && opStartDate.Minute() == pStartDate.Minute()) - { - schedule->SetOffPeakSyncEnabled(EFalse); - return; - } - - TTsTime startTime; - TIntervalType intervalType; - TInt interval; - - TTime now; - now.HomeTime(); - - TInt offpeakschedule = schedule->SyncOffPeakSchedule(); - intervalType = IntervalType(offpeakschedule); - - TInt offPeakStatus = schedule->IsValidOffPeakScheduleL(); - TDateTime startday; - - startday = now.DateTime(); - //If the current time is off peak, start now - if (offPeakStatus == 0) - { - startTime.SetLocalTime(now); - } - //current time is peak - else if (offPeakStatus > 0) - { - TTime start= schedule->EndPeakTime()+ (TTimeIntervalMinutes)1; - TDateTime date = start.DateTime(); - TDateTime time(startday.Year(), startday.Month(), startday.Day(), date.Hour(), date.Minute(), 0, 0); - TTime syncTime(time); - startTime.SetLocalTime(syncTime); - } - - TInt validityPeriod = KMaxTInt; - - interval = Interval(offpeakschedule); - - TScheduleEntryInfo2 offPeakEntry(startTime, intervalType, interval, (TTimeIntervalMinutes)validityPeriod); - - #ifdef _DEBUG - TBuf<64> buf; - LogTsTime(startTime, buf); - FLOG(_L("Auto sync start time: %S"), &buf); - #endif - - ioffPeakEntryList->Reset(); - ioffPeakEntryList->AppendL(offPeakEntry); - - TSchedulerItemRef ref; - TInt err = iScheduler.CreatePersistentSchedule(ref, *ioffPeakEntryList); - User::LeaveIfError(err); - - //keep the scheduler disabled until settings are saved - iScheduler.DisableSchedule(ref.iHandle); - - schedule->SetOffPeakScheduleHandle(ref.iHandle); - - HBufC* hBuf = HBufC::NewMaxLC(KBufSize); - hBuf->Des() = KOffPeakTaskData; - - TTaskInfo taskInfo; - taskInfo.iName = KOffPeakTaskData; - taskInfo.iRepeat = KRepeatForever; - taskInfo.iPriority = KTaskPriority; - - err = iScheduler.ScheduleTask(taskInfo, *hBuf, ref.iHandle); - User::LeaveIfError(err); - - CleanupStack::PopAndDestroy(hBuf); - } - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::EnableSchedule() -// -Enable schedules after settings are saved. -// ----------------------------------------------------------------------------- -// -void CAspSyncSchedule::EnableSchedule(CAspSchedule* aAspSchedule) - { - TInt peakHandle = aAspSchedule->PeakScheduleHandle(); - TInt offPeakHandle = aAspSchedule->OffPeakScheduleHandle(); - - if (peakHandle != KErrNotFound) - { - iScheduler.EnableSchedule(peakHandle); - } - if (offPeakHandle != KErrNotFound) - { - iScheduler.EnableSchedule(offPeakHandle); - } - - } - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::EditPeakScheduleL -// -Edit peak schedule entry -// ----------------------------------------------------------------------------- -// - -void CAspSyncSchedule::EditPeakScheduleL(CAspSchedule* aAspSchedule) - { - - ipeakEntryList->Reset(); - ipeakTaskList->Reset(); - - TTsTime tsTime; - TScheduleState2 state; - TInt peakHandle = aAspSchedule->PeakScheduleHandle(); - - if (peakHandle == KErrNotFound) - { - User::Leave(KErrNotFound); - } - - TInt err = iScheduler.GetScheduleL(peakHandle, state, *ipeakEntryList, *ipeakTaskList, tsTime); - - User::LeaveIfError(err); - - TInt count = ipeakEntryList->Count(); - __ASSERT_DEBUG(count == 1, TUtil::Panic(KErrArgument)); - - TInt peakInterval; - if (aAspSchedule->DailySyncEnabled()) - { - peakInterval = aAspSchedule->SyncFrequency(); - } - else - { - peakInterval = aAspSchedule->SyncPeakSchedule(); - } - TInt interval = Interval(peakInterval); - TIntervalType intervalType = IntervalType(peakInterval); - TTime now; - now.HomeTime(); - TTsTime startTime ; - if (intervalType == EHourly) - { - if (peakInterval == CAspSchedule::EInterval15Mins - || peakInterval == CAspSchedule::EInterval30Mins) - { - now = now + (TTimeIntervalMinutes)interval ; - } - else - { - now = now + (TTimeIntervalHours)interval ; - } - startTime.SetLocalTime(now); - } - else - { - now = now + (TTimeIntervalDays)interval; - TDateTime startday = now.DateTime(); - TTime start = aAspSchedule->AutoSyncScheduleTime(); - TDateTime date = start.DateTime(); - TDateTime time(startday.Year(), startday.Month(), startday.Day(), date.Hour(), date.Minute(), 0, 0); - TTime syncTime(time); - startTime.SetLocalTime(syncTime); - } - - TScheduleEntryInfo2& info = (*ipeakEntryList)[0]; - - info.SetStartTime(startTime); - info.SetInterval(interval); - info.SetIntervalType(intervalType); - - err = iScheduler.EditSchedule(peakHandle, *ipeakEntryList); - User::LeaveIfError(err); - - } - - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::EditOffPeakScheduleL -// -Edit off-peak schedule entry -// ----------------------------------------------------------------------------- -// -void CAspSyncSchedule::EditOffPeakScheduleL(CAspSchedule* aAspSchedule) - { - - ioffPeakEntryList->Reset(); - ioffPeakTaskList->Reset(); - - TTsTime tsTime; - TScheduleState2 state; - TInt offPeakHandle = aAspSchedule->OffPeakScheduleHandle(); - - if (offPeakHandle == KErrNotFound) - { - User::Leave(KErrNotFound); - } - - TInt err = iScheduler.GetScheduleL(offPeakHandle, state, *ioffPeakEntryList, *ioffPeakTaskList, tsTime); - - User::LeaveIfError(err); - - TInt count = ioffPeakEntryList->Count(); - __ASSERT_DEBUG(count == 1, TUtil::Panic(KErrArgument)); - - TInt offPeakInterval = aAspSchedule->SyncOffPeakSchedule(); - TInt interval = Interval(offPeakInterval); - TIntervalType intervalType = IntervalType(offPeakInterval); - TTime now; - now.HomeTime(); - TTsTime startTime ; - - if (offPeakInterval == CAspSchedule::EInterval15Mins - || offPeakInterval == CAspSchedule::EInterval30Mins) - { - now = now + (TTimeIntervalMinutes)interval ; - } - else - { - now = now + (TTimeIntervalHours)interval ; - } - startTime.SetLocalTime(now); - - - TScheduleEntryInfo2& info = (*ioffPeakEntryList)[0]; - - info.SetStartTime(startTime); - info.SetInterval(interval); - info.SetIntervalType(intervalType); - - err = iScheduler.EditSchedule(offPeakHandle, *ioffPeakEntryList); - User::LeaveIfError(err); - - } - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::UpdatePeakScheduleL -// -Postpone peak schedule till next peak start -// ----------------------------------------------------------------------------- -// -void CAspSyncSchedule::UpdatePeakScheduleL(CAspSchedule* aAspSchedule) - { - - ipeakEntryList->Reset(); - ipeakTaskList->Reset(); - - TTime startPeak = aAspSchedule->StartPeakTime(); - - TTime now; - now.HomeTime(); - - - TDateTime startDate = startPeak.DateTime(); - - TDateTime day = now.DateTime(); - if (day.Hour() > KStartPeakHour) - { - now = now + (TTimeIntervalDays)1; - } - TDateTime tomorrow = now.DateTime(); - - TDateTime time(tomorrow.Year(), tomorrow.Month(), tomorrow.Day(), startDate.Hour(), startDate.Minute(), 0, 0); - TTime nextPeakStart(time); - - while(!aAspSchedule->WeekdayEnabled(nextPeakStart.DayNoInWeek())) - { - nextPeakStart = nextPeakStart + (TTimeIntervalDays)1; - } - TTsTime tsTime; - TScheduleState2 state; - TInt peakHandle = aAspSchedule->PeakScheduleHandle(); - - if (peakHandle == KErrNotFound) - { - User::Leave(KErrNotFound); - } - - TInt err = iScheduler.GetScheduleL(peakHandle, state, *ipeakEntryList, *ipeakTaskList, tsTime); - - User::LeaveIfError(err); - - TInt count = ipeakEntryList->Count(); - __ASSERT_DEBUG(count == 1, TUtil::Panic(KErrArgument)); - - - TTsTime startTime ; - startTime.SetLocalTime(nextPeakStart); - TIntervalType intervalType = IntervalType(aAspSchedule->SyncPeakSchedule()); - TInt interval = Interval(aAspSchedule->SyncPeakSchedule()); - - TScheduleEntryInfo2& info = (*ipeakEntryList)[0]; - - info.SetStartTime(startTime); - info.SetInterval(interval); - info.SetIntervalType(intervalType); - - err = iScheduler.EditSchedule(peakHandle, *ipeakEntryList); - User::LeaveIfError(err); - - - } - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::UpdateOffPeakScheduleL -// -Postpone off-peak schedule till next off-peak start -// ----------------------------------------------------------------------------- -// - -void CAspSyncSchedule::UpdateOffPeakScheduleL(CAspSchedule* aAspSchedule) - { - - ioffPeakEntryList->Reset(); - ioffPeakTaskList->Reset(); - - TTime startoffPeak = aAspSchedule->EndPeakTime() + (TTimeIntervalMinutes)1; - - TTime now; - now.HomeTime(); - - TInt interval = aAspSchedule->SyncOffPeakSchedule(); - TIntervalType intervalType = IntervalType(interval); - TInt intervalVal = Interval(interval); - - if (interval == CAspSchedule::EInterval15Mins - || interval == CAspSchedule::EInterval30Mins) - - { - now = now + (TTimeIntervalMinutes)intervalVal; - } - else if (intervalType == EHourly) - { - now = now + (TTimeIntervalHours)intervalVal; - } - - TDateTime startday = startoffPeak.DateTime(); - TDateTime today = now.DateTime(); - - TDateTime time(today.Year(), today.Month(), today.Day(), startday.Hour(), startday.Minute(), 0, 0); - - TTime nextOffPeakStart(time); - TTsTime tsTime; - TScheduleState2 state; - TInt offpeakHandle = aAspSchedule->OffPeakScheduleHandle(); - - if (offpeakHandle == KErrNotFound) - { - User::Leave(KErrNotFound); - } - - TInt err = iScheduler.GetScheduleL(offpeakHandle, state, *ioffPeakEntryList, *ioffPeakTaskList, tsTime); - - User::LeaveIfError(err); - - TInt count = ioffPeakEntryList->Count(); - __ASSERT_DEBUG(count == 1, TUtil::Panic(KErrArgument)); - - - TTsTime startTime ; - startTime.SetLocalTime(nextOffPeakStart); - TScheduleEntryInfo2& info = (*ioffPeakEntryList)[0]; - - info.SetStartTime(startTime); - info.SetInterval(interval); - info.SetIntervalType(intervalType); - - err = iScheduler.EditSchedule(offpeakHandle, *ioffPeakEntryList); - User::LeaveIfError(err); - - - } -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::IntervalType -// Return interval type -// ---------------------------------------------------------------------------- -// -TIntervalType CAspSyncSchedule::IntervalType(TInt aInterval) - { - if (aInterval == CAspSchedule::EInterval24hours - || aInterval == CAspSchedule::EInterval2days - || aInterval == CAspSchedule::EInterval4days - || aInterval == CAspSchedule::EInterval7days - || aInterval == CAspSchedule::EInterval14days - || aInterval == CAspSchedule::EInterval30days) - { - return EDaily; - } - - return EHourly; - } - - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::Interval -// Return interval value -// ---------------------------------------------------------------------------- -// -TInt CAspSyncSchedule::Interval(TInt aInterval) - { - const TInt KIntervalManual = 0; - const TInt KInterval15Mins = 15; - const TInt KInterval30Mins = 30; - const TInt KInterval1hour = 1; - const TInt KInterval2hours = 2; - const TInt KInterval4hours = 4; - const TInt KInterval8hours = 8; - const TInt KInterval12hours = 12; - const TInt KInterval24hours = 1; - const TInt KInterval2days = 2; - const TInt KInterval4days = 4; - const TInt KInterval7ays = 7; - const TInt KInterval14days = 14; - const TInt KInterval30days = 30; - - TInt ret = KIntervalManual; - - switch (aInterval) - { - case CAspSchedule::EIntervalManual: - ret = KIntervalManual; - break; - case CAspSchedule::EInterval15Mins: - ret = KInterval15Mins; - break; - case CAspSchedule::EInterval30Mins: - ret = KInterval30Mins; - break; - case CAspSchedule::EInterval1hour: - ret = KInterval1hour; - break; - case CAspSchedule::EInterval2hours: - ret = KInterval2hours; - break; - case CAspSchedule::EInterval4hours: - ret = KInterval4hours; - break; - case CAspSchedule::EInterval8hours: - ret = KInterval8hours; - break; - case CAspSchedule::EInterval12hours: - ret = KInterval12hours; - break; - case CAspSchedule::EInterval24hours: - ret = KInterval24hours; - break; - case CAspSchedule::EInterval2days: - ret = KInterval2days; - break; - case CAspSchedule::EInterval4days: - ret = KInterval4days; - break; - case CAspSchedule::EInterval7days: - ret = KInterval7ays; - break; - case CAspSchedule::EInterval14days: - ret = KInterval14days; - break; - case CAspSchedule::EInterval30days: - ret = KInterval30days; - break; - - - default: - break; - } - - return ret; - } - - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::StartTime -// -// ---------------------------------------------------------------------------- -// -TTsTime CAspSyncSchedule::StartTime(TInt aStartHour, TInt aInterval) - { - - if (IntervalType(aInterval) == EDaily) - { - TTime time = CAspSchedule::LocalStartTime(aStartHour); - TTsTime tsTime(time, EFalse); - return tsTime; - } - - TTime time = CAspSchedule::UniversalStartTime(aStartHour); - TTsTime tsTime(time, ETrue); - return tsTime; - } - - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::GetPeakStartTimeL -// -// ----------------------------------------------------------------------------- -// -void CAspSyncSchedule::GetPeakStartTimeL(CAspSchedule* aAspSchedule, TTime& aTime, TBool aHomeTime) - { - - ipeakEntryList->Reset(); - ipeakTaskList->Reset(); - - TTsTime tsTime; - TScheduleState2 state; - TInt peakHandle = aAspSchedule->PeakScheduleHandle(); - - TInt err = iScheduler.GetScheduleL(peakHandle, state, *ipeakEntryList, *ipeakTaskList, tsTime); - User::LeaveIfError(err); - if (aHomeTime) - { - aTime = tsTime.GetLocalTime(); - } - else - { - aTime = tsTime.GetUtcTime(); - } - - } - - -// ----------------------------------------------------------------------------- -// CAspSyncSchedule::GetOffPeakStartTimeL -// -// ----------------------------------------------------------------------------- -// -void CAspSyncSchedule::GetOffPeakStartTimeL(CAspSchedule* aAspSchedule, TTime& aTime, TBool aHomeTime) - { - - ioffPeakEntryList->Reset(); - ioffPeakTaskList->Reset(); - - TTsTime tsTime; - TScheduleState2 state; - TInt offPeakHandle = aAspSchedule->OffPeakScheduleHandle(); - - TInt err = iScheduler.GetScheduleL(offPeakHandle, state, *ioffPeakEntryList, *ioffPeakTaskList, tsTime); - User::LeaveIfError(err); - if (aHomeTime) - { - aTime = tsTime.GetLocalTime(); - } - else - { - aTime = tsTime.GetUtcTime(); - } - - } - - -#ifdef _DEBUG - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::LogScheduleL -// -// ---------------------------------------------------------------------------- -// -void CAspSyncSchedule::LogScheduleL(CAspSchedule* aAspSchedule) - { - - FLOG( _L("---- scheduler settings ----") ); - - TTsTime tsTime; - TTime time; - TScheduleState2 state; - TInt peakhandle = aAspSchedule->PeakScheduleHandle(); - if (peakhandle != KErrNotFound ) - { - FLOG( _L("---- Peak Time Sync Enabled -> Settings") ); - ipeakEntryList->Reset(); - ipeakTaskList->Reset(); - TInt err = iScheduler.GetScheduleL(peakhandle, state, *ipeakEntryList, *ipeakTaskList, tsTime); - User::LeaveIfError(err); - - TScheduleEntryInfo2 info = (*ipeakEntryList)[0]; - - TBuf buf; - - FLOG(_L("peak schedule handle: %d"), peakhandle); - - LogInterval(info, buf); - FLOG(_L("peak interval: %S"), &buf); - - LogIntervalType(info, buf); - FLOG(_L("peak interval type: %S"), &buf); - - LogTsTime(tsTime, buf); - FLOG(_L("peak sync start time: %S"), &buf); - - TTaskInfo taskInfo = (*ipeakTaskList)[0]; - LogTaskInfo(taskInfo, buf); - FLOG(_L("peak task info: %S"), &buf); - - } - TInt offPeakhandle = aAspSchedule->OffPeakScheduleHandle(); - if (offPeakhandle != KErrNotFound ) - { - FLOG( _L("---- Off-Peak Time Sync Enabled -> Settings") ); - ioffPeakEntryList->Reset(); - ioffPeakTaskList->Reset(); - TInt err = iScheduler.GetScheduleL(offPeakhandle, state, *ioffPeakEntryList, *ioffPeakTaskList, tsTime); - User::LeaveIfError(err); - - TScheduleEntryInfo2 info = (*ioffPeakEntryList)[0]; - - TBuf buf; - - FLOG(_L("off-peak schedule handle: %d"), peakhandle); - - LogInterval(info, buf); - FLOG(_L("off-peak interval: %S"), &buf); - - LogIntervalType(info, buf); - FLOG(_L("off-peak interval type: %S"), &buf); - - LogTsTime(tsTime, buf); - FLOG(_L("off-peak sync start time: %S"), &buf); - - TTaskInfo taskInfo = (*ioffPeakTaskList)[0]; - LogTaskInfo(taskInfo, buf); - FLOG(_L("off-peak task info: %S"), &buf); - - } - - - - - FLOG( _L("---- scheduler settings ----") ); - - } - - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::LogSchedule -// -// ---------------------------------------------------------------------------- -// -TInt CAspSyncSchedule::LogSchedule(CAspSchedule* aAspSchedule) - { - TInt err = KErrNone; - TRAP(err, LogScheduleL(aAspSchedule)); - - return err; - } - - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::LogTaskInfo -// -// ---------------------------------------------------------------------------- -// -void CAspSyncSchedule::LogTaskInfo(TTaskInfo& aInfo, TDes& aText) - { - aText.Format(_L("name: %S, repeat: %d, id: %d, priority: %d"), - &aInfo.iName, aInfo.iRepeat, aInfo.iTaskId, aInfo.iPriority); - } - - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::LogIntervalType -// -// ---------------------------------------------------------------------------- -// -void CAspSyncSchedule::LogIntervalType(TScheduleEntryInfo2& aInfo, TDes& aText) - { - aText = _L("unknown"); - - TIntervalType type = aInfo.IntervalType(); - - if (type == EDaily) - { - aText = _L("EDaily"); - } - if (type == EHourly) - { - aText = _L("EHourly"); - } - } - - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::LogInterval -// -// ---------------------------------------------------------------------------- -// -void CAspSyncSchedule::LogInterval(TScheduleEntryInfo2& aInfo, TDes& aText) - { - TInt num = aInfo.Interval(); - aText.Format(_L("interval: %d"), num); - } - - -// ---------------------------------------------------------------------------- -// CAspSyncSchedule::LogTime -// -// ---------------------------------------------------------------------------- -// - -void CAspSyncSchedule::LogTsTime(TTsTime aTsTime, TDes& aText) - { - TBuf<64> buf1; TBuf<64> buf2; - - TTime time = aTsTime.GetLocalTime(); - TRAP_IGNORE(TUtil::GetDateTimeTextL(buf1, time)); - time = aTsTime.GetUtcTime(); - TRAP_IGNORE(TUtil::GetDateTimeTextL(buf2, time)); - - aText.Format(_L("local: %S utc: %S"), &buf1, &buf2); - } - -#endif // _DEBUG - -