--- 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 <schinfo.h> // TScheduleEntryInfo2
-#include <s32mem.h> // RDesWriteStream
-#include <s32file.h> // RFileReadStream
-//#include <centralrepository.h> // CRepository
-#include <rconnmon.h>
-
-
-
-
-_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<HBufC*>(&(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<TScheduleEntryInfo2>(1);
- ioffPeakEntryList = new (ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1);
- ipeakTaskList = new (ELeave) CArrayFixFlat<TTaskInfo>(1);
- ioffPeakTaskList = new (ELeave) CArrayFixFlat<TTaskInfo>(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; i<count; i++)
- {
- TTaskInfo& task = (*ipeakTaskList)[i];
- err = iScheduler.DeleteTask(task.iTaskId);
- User::LeaveIfError(err);
- }
-
- err = iScheduler.DeleteSchedule(peakHandle);
- aAspSchedule->SetPeakScheduleHandle(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; i<count; i++)
- {
- TTaskInfo& task = (*ioffPeakTaskList)[i];
- err = iScheduler.DeleteTask(task.iTaskId);
- User::LeaveIfError(err);
- }
-
- err = iScheduler.DeleteSchedule(offPeakHandle);
- aAspSchedule->SetOffPeakScheduleHandle(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<KBufSize> 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<KBufSize> 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
-
-