// Copyright (c) 2004-2009 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:

 //

 // System includes

 #include <bacntf.h>

 // User includes

 #include "SCHMAN.H"

 #include "SchTimer.h"

 #include "SchLogger.h"

 #include "SCHEDULE.H"

 #include "SCHCLI.H"

 #include "SCHSTORE.H"

 #include <schtask.h>

 #include "SCHLOG.h"

 // Constants

 const TInt KMinScheduleId = 0;

 const TInt KMaxSchedules = 25000;

 //Command line argument  

 _LIT(KCommandLine, "SYSSTARTSCHEXE");

 //SID of SysStart

 const TInt KSysStartSID = 0x10205C44; 

 #define UNUSED_VAR(a) a = a

 //

 // Construction/Destruction functions

 //

 CTaskScheduler::CTaskScheduler()

 :	iSchedules(CSchedule::Offset()), 

 	iClients(CClientProxy::Offset()),

 	iStartupStatePassNonCritical(EFalse)

 	{

 	}

 CTaskScheduler::~CTaskScheduler()

 	{

 	if (iBackupNotification)

 		{

 		iBackupNotification->DeRegisterBackupOperationObserver(*this);

 		}

 	delete iBackupNotification;

 	delete iBackupManager;

 	delete iNotifier;

 	delete iScheduleCriteriaManager;

 	delete iSchLogManager;

 	//remove clients and schedules as well!!

 	TDblQueIter<CClientProxy> clientIter(iClients);

 	clientIter.SetToFirst();

 	CClientProxy* client=NULL;

 	while ((client=clientIter++)!=NULL)

 		{

 			client->Remove();

 			delete client;

 		}

 	TSglQueIter<CSchedule> schedIter(iSchedules);

 	schedIter.SetToFirst();

 	CSchedule* schedule=NULL;

 	while ((schedule=schedIter++)!=NULL)

 		{

 			iSchedules.Remove(*schedule);

 			delete schedule;

 		}	

 	}

 void CTaskScheduler::ConstructL()

 	{

 	LOGSTRING("CTaskScheduler::ConstructL - Creating new schedule server log entry");

 	User::LeaveIfError(iFsSession.Connect());

 	iBackupManager = new(ELeave) CSchBackupManager(iFsSession);

 	iBackupManager->ConstructL();

 	iNotifier = CEnvironmentChangeNotifier::NewL(CActive::EPriorityHigh, TCallBack(EnvironmentChanged, this));

 	iNotifier->Start();

 	iScheduleCriteriaManager = CScheduleCriteriaManager::NewL(*this);

 	iSchLogManager = CSchLogManager::NewL(iFsSession);

 	LOGSTRING("CTaskScheduler::ConstructL - Restoring clients and schedules");

 	TRAPD(err, iBackupManager->RestoreL(iClients, iSchedules,*iSchLogManager));

 	if	(err != KErrNone) // the file's corrupt or something...

 		{

 		LOGSTRING2("CTaskScheduler::ConstructL - had to create new store because of error: %d", err);

 		iBackupManager->CreateEmptyBackupL();

 		}

 	//checking the SID of the process which started the Task scheduler	

  	if (User::CreatorSecureId() == KSysStartSID)

 	 	{

 	    TInt argLen = User::CommandLineLength();

      	if (argLen)

 	         {

 	         HBufC* arg = HBufC::NewLC(argLen);

 	         TPtr argPtr = arg->Des();

 	         User::CommandLine(argPtr);

 	         argPtr.UpperCase();

 	 		 //Checking Comman dLine arg passed to it is same as in SSCForStartupMode0.rss

 	 		 //and checking for persisted schedules

 	         if((argPtr.Compare(KCommandLine) == 0) && iSchedules.IsEmpty())

 	             {

 	             //if no schedule leave

 				 User::Leave(KErrNone);

 	             }

 	 	      CleanupStack::PopAndDestroy(arg);

 	 	      }

          }

 	// Each client now contains a list of associated tasks. We need

 	// to now associate those tasks with specific schedules

 	CClientProxy* client;

 	TDblQueIter<CClientProxy> clientIter(iClients);

 	clientIter.SetToFirst();

 	while ((client = clientIter++) != NULL)

 		{

 		// Fetch an iterator for each task owned by this client

 		CScheduledTask* task;

 		TDblQueIter<CScheduledTask> taskIterator = client->TaskIterator();

 		taskIterator.SetToFirst();

 		// Iterate through all the tasks owned by this client, trying to find

 		// the corresponding schedules.

 		while ((task = taskIterator++) != NULL)

 			{

 			CSchedule* schedule = NULL;

 			schedule = Find(task->ScheduleId());

 			if (schedule)

 				{

 				TScheduledTask* taskRef = new(ELeave) TScheduledTask(*task,*client);

 				schedule->AddTask(*taskRef);

 				}

 			}

 		}

 	iBackupNotification = CBaBackupSessionWrapper::NewL();

 	iBackupNotification->RegisterBackupOperationObserverL(*this);

 	}

 CTaskScheduler* CTaskScheduler::NewL()

 	{

 	CTaskScheduler* self = CTaskScheduler::NewLC();

 	CleanupStack::Pop();

 	return self;	

 	}

 CTaskScheduler* CTaskScheduler::NewLC()

 	{

 	CTaskScheduler* self = new(ELeave) CTaskScheduler();

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	return self;

 	}

 //

 // Client, Schedule and Task functions

 //

 CClientProxy* CTaskScheduler::AddClientL(const TDesC& aFilename, TInt aPriority)

 	{

 	//check we don't already have a client that will do...

 	TDblQueIter<CClientProxy> clientIter(iClients);

 	clientIter.SetToFirst();

 	CClientProxy* client=NULL;

 	while ((client=clientIter++)!=NULL)

 		{

 		if	(client->IsEqual(aFilename, aPriority))

 			return client;

 		}

 	client = CClientProxy::NewL(iFsSession, aFilename, aPriority,*iSchLogManager); 

 	iClients.Add(*client);

 	return client;

 	}

 void CTaskScheduler::AddScheduleL(CSchedule& aSchedule)

 	{

 	LOGSTRING3("CTaskScheduler::AddScheduleL - schedule: %S, %d", &aSchedule.Name(), aSchedule.Id());

 	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationAdd, aSchedule);

 	iSchedules.AddLast(aSchedule);

 	LOGSTRING("CTaskScheduler::AddScheduleL - schedule added");

 	}

 void CTaskScheduler::EditScheduleL(TInt aScheduleHandle, CArrayFixFlat<TScheduleEntryInfo2>& aEntryList)

 	{

 	CSchedule* schedule = FindL(aScheduleHandle);

 	// remove schedule from condition manager before replacing entries to ensure 

 	// its deleted properly.

 	iScheduleCriteriaManager->RemoveSchedule(schedule->Id());

 	schedule->ReplaceEntriesL(aEntryList);

 	TRAPD(err, iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *schedule));

 	if(err)

 		{

 		schedule->RemoveEntries();

 		User::Leave(err);

 		}

 	// recalculate due time only if schedule is enabled and has tasks to run	

 	if (IsScheduleReadyForUpdate(*schedule))

 		{

 		iScheduleCriteriaManager->ReplaceScheduleL(*schedule);

 		}

 	}

 void CTaskScheduler::DoEditScheduleL(CSchedule& aSchedule, 

 							CArrayFixFlat<TTaskSchedulerCondition>& aConditionList,

 							const TTsTime& aDefaultTime)

 	{

 	aSchedule.ReplaceConditionsL(aConditionList);

 	//Default Time is represented by a single entry class

 	CArrayFixFlat<TScheduleEntryInfo2>* entries 

 		= new(ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1);

 	CleanupStack::PushL(entries);

 	TScheduleEntryInfo2 info;

 	info.SetStartTime(aDefaultTime);

 	info.SetInterval(1);

 	info.SetIntervalType(EDaily);

 	//validityperiod of 24 hours will ensure task is always run

 	info.SetValidityPeriod(60*24); 

 	entries->AppendL(info);

 	aSchedule.ReplaceEntriesL(*entries);

 	CleanupStack::Pop(entries);

 	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, aSchedule);

 	}

 void CTaskScheduler::EditScheduleL(TInt aScheduleHandle, 

 							CArrayFixFlat<TTaskSchedulerCondition>& aConditionList,

 							const TTsTime& aDefaultTime)

 	{

 	CSchedule* schedule = FindL(aScheduleHandle);

 	// remove schedule from condition manager before replacing entries to ensure 

 	// its deleted properly.

 	iScheduleCriteriaManager->RemoveSchedule(schedule->Id());

 	TRAPD(err, DoEditScheduleL(*schedule, aConditionList, aDefaultTime));

 	if(err)

 		{

 		schedule->RemoveEntries();

 		schedule->RemoveConditions();

 		User::Leave(err);

 		}

 	// recalculate due time only if schedule is enabled and has tasks to run	

 	if (IsScheduleReadyForUpdate(*schedule))

 		{

 		iScheduleCriteriaManager->ReplaceScheduleL(*schedule);

 		}

 	}	

 void CTaskScheduler::RemoveScheduleL(TInt aHandle)

 	{

 	CSchedule* schedule = FindL(aHandle);

 	LOGSTRING3("CTaskScheduler::RemoveScheduleL - schedule: %S, %d", &schedule->Name(), schedule->Id());

 	if (!schedule->HasTasks())

 		{

 		LOGSTRING("CTaskScheduler::RemoveScheduleL - schedule doesn't have any tasks, removing");

 		//remove schedule from timer

 		iScheduleCriteriaManager->RemoveSchedule(schedule->Id());

 		DoRemoveL(schedule);

 		}

 	else

 		{

 		// Can't delete a schedule which has tasks

 		LOGSTRING("CTaskScheduler::RemoveScheduleL - schedule has tasks, can't delete");

 		User::Leave(KErrArgument);

 		}

 	}

 void CTaskScheduler::DisableScheduleL(TInt aHandle)

 	{

 	CSchedule* schedule = FindL(aHandle);

 	schedule->SetEnabled(EFalse);

 	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *schedule);

 	//remove schedule from timer as its disabled

 	iScheduleCriteriaManager->RemoveSchedule(schedule->Id());

 	}

 void CTaskScheduler::EnableScheduleL(TInt aHandle)

 	{

 	CSchedule* schedule = FindL(aHandle);

 	schedule->SetEnabled(ETrue);

 	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *schedule);

 	// recalculate due time only if schedule has tasks to run	

 	if ( IsScheduleReadyForUpdate(*schedule))

 		{

 		iScheduleCriteriaManager->ReplaceScheduleL(*schedule);

 		}

 	}

 void CTaskScheduler::ScheduleTaskL(CSchedule& aSchedule, CClientProxy& aClient)

 	{

 	// Backup the task

 	if	(aSchedule.Persists())

 		{

 		iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, aClient);

 		}

 	// if schedule is enabled then add schedule to timer.

 	if (aSchedule.Enabled() && IsStartupStateNonCritical())

 		{

 		iScheduleCriteriaManager->ReplaceScheduleL(aSchedule);

 		}		

 	}

 void CTaskScheduler::DeleteTaskL(TInt aScheduleHandle, TInt aTaskHandle)

 	{

 	CSchedule* schedule = FindL(aScheduleHandle);

 	TScheduledTask* task = schedule->Task(aTaskHandle);

 	if (!task)

 		{

 		LOGSTRING("CTaskScheduler::DeleteTaskL - task wasn't found");

 		User::Leave(KErrNotFound);

 		}

 	const CClientProxy& clientForTask = task->Client();

 	// This deletes the task and removes the CScheduledTask

 	// from the CClientProxy's queue of tasks

 	task->RemoveInfo();

 	// This deletes the TScheduledTask defined above and removes it

 	// from CSchedule's queue of TScheduledTask's.

 	schedule->RemoveTask(task);

 	if (!schedule->HasTasks())	//i.e. it was the last task 

 		{

 		LOGSTRING("CTaskScheduler::DeleteTaskL - schedule doesn't have any more tasks left");

 		//remove scheule from timer as there are no more tasks

 		iScheduleCriteriaManager->RemoveSchedule(schedule->Id());

 		// If the schedule isn't persistent then we delete it (transient schedules only

 		// have one task).

 		if (!schedule->Persists())

 			DoRemoveL(schedule);

 		else

 			iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, clientForTask);		

 		}

 	else

 		{

 		// Backup the changes to the tasks. Although we are deleting a task, we are not actually

 		// deleting the client, so this is actually an edit operation.

 		if (schedule->Persists())

 			iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, clientForTask);

 		}

 	}

 //

 // Utility Functions

 //

 TInt CTaskScheduler::GenerateId()

 	{

 	TInt id = KMinScheduleId;

 	CSchedule* schedule = Find(id);

 	while (schedule!=NULL) 

 		{

 		id+=KScheduleIdDifferential;//=10 000

 		if ((id/KScheduleIdDifferential) > KMaxSchedules)

 			return KErrOverflow;

 		schedule = Find(id);

 		}

 	return id;

 	}

 void CTaskScheduler::DoRemoveL(CSchedule* aSchedule)

 	{

 	TRAPD(err, iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationDelete, *aSchedule));

 	if	(err < KErrNone && err != KErrNotFound)

 		User::Leave(err);

 	iSchedules.Remove(*aSchedule);

 	delete aSchedule;

 	aSchedule = NULL;

 	}

 CSchedule* CTaskScheduler::FindL(TInt aHandle)

 	{

 	CSchedule* schedule = Find(aHandle);

 	if (!schedule)

 		User::Leave(KErrNotFound);

 	return schedule;

 	}

 CSchedule* CTaskScheduler::Find(TInt aHandle)

 	{

 	TSglQueIter<CSchedule> scheduleIter(iSchedules);

 	scheduleIter.SetToFirst();

 	CSchedule* schedule;

 	while ((schedule = scheduleIter++)!=NULL)

 		{

 		if (schedule->Id() == aHandle)

 			return schedule;

 		}

 	return NULL;

 	}

 // If aRefArray is NULL then only count it returned.

 TInt CTaskScheduler::GetScheduleRefsL(CArrayFixFlat<TSchedulerItemRef>* aRefArray, 

 									TScheduleFilter aFilter,

 									const RMessagePtr2& aMessage)

 	{

 	TInt count = 0;

 	TSglQueIter<CSchedule> iter(iSchedules);

 	iter.SetToFirst();

 	CSchedule* schedule = NULL;

 	while ((schedule = iter++) != NULL)

 		{

 		if(aFilter == EAllSchedules || (schedule->Enabled() && schedule->HasTasks()))

 			{

 			//only add information for schedules that the client has permission to alter

 			if(schedule->IsAccessAllowed(aMessage))

 				{

 				if(aRefArray)

 					{

 					TSchedulerItemRef ref;

 					ref.iHandle = schedule->Id();

 					ref.iName = schedule->Name();

 					aRefArray->AppendL(ref);	

 					}

 				count++;		

 				}

 			}

 		}

 	return count;				

 	}

 // If aRefArray is NULL then only count it returned.

 TInt CTaskScheduler::GetTaskRefsL(CArrayFixFlat<TSchedulerItemRef>* aRefArray, 

 									TScheduleFilter aScheduleFilter,

 									TTaskFilter aTaskFilter,

 									CClientProxy* aClient,

 									const RMessagePtr2& aMessage)

 	{

 	TInt count = 0;

 	TSglQueIter<CSchedule> iter(iSchedules);

 	iter.SetToFirst();

 	CSchedule* schedule = NULL;

 	while ((schedule = iter++) != NULL)

 		{

 		if(aScheduleFilter == EAllSchedules || (schedule->Enabled() && schedule->HasTasks()))

 			{

 			//only add information for schedules that the client has permission to alter

 			if(schedule->IsAccessAllowed(aMessage))

 				{

 				TSglQueIter<TScheduledTask> taskIter(*(schedule->Tasks()));

 				taskIter.SetToFirst();

 				TScheduledTask* task;

 				while ((task=taskIter++)!=NULL)

 					{

 					if (aTaskFilter==EAllTasks||&task->Client() == aClient) // This pointer comparison is a bit rubbish.  Change?

 						{

 						if(aRefArray)

 							{

 							TTaskInfo info = task->Info();

 							TSchedulerItemRef ref;

 							ref.iHandle = info.iTaskId;

 							ref.iName = info.iName;

 							aRefArray->AppendL(ref);

 							}

 						count++;

 						}

 					}

 				}

 			}

 		}

 	return count;				

 	}

 //

 // Schedule Execution functions

 //

 // A schedule is ready to be run

 void CTaskScheduler::DueTaskNotifyL(TInt aScheduleHandle)

 	{

 	CSchedule* schedule = FindL(aScheduleHandle);

 	//NotifyTasks() also removes tasks from the schedule if there are no 

 	//repeats left.

 	schedule->NotifyTasks(); 

 	if (!schedule->HasTasks())

 		{

 		// remove schedule.

 		TRAPD(ignore, DoRemoveL(schedule));

 		//??error only occurs in relation to persistence!! Do something.  

         UNUSED_VAR(ignore);

 		}

 	else

 		{

 		__ASSERT_ALWAYS(IsStartupStateNonCritical(), User::Invariant());

 		iScheduleCriteriaManager->ReplaceScheduleL(*schedule,EConditionAndTime,ETrue);

 		}

 	// Execute all clients.  This method doesn't leave as all errors are either

 	// logged in the log engine or handled elsewhere.

 	ExecuteClients();

 	}

 //	Go through all clients, executing their tasks

 void CTaskScheduler::ExecuteClients(TBool aUpdateClient)

 	{

 	if ((BUROperationInProgress() == EBUROperationNoActivity) || !aUpdateClient)

 		{

 		TDblQueIter<CClientProxy> clientIter(iClients);

 		clientIter.SetToFirst();

 		CClientProxy* client;

 		while( (client = clientIter++) != NULL)

 			{

 			// Does this client have anything ready to run?

 			if	(client->IsReadyToExecute())

 				{

 				client->ExecuteTasks();

 				// Clears the 'IsReadyToExecute' flag...

 				client->RemoveDueTasks();

 				}

 			}

 		if (aUpdateClient)	

 			{

 			// Update the store file now

 			UpdateClients();	

 			}

 		}

 	else

 		{

 		// Sets the flag to trigger delayed store operation when BUR ends

 		iTaskExecutedDuringBUR = ETrue;

 		}

 	}

 //	Go through all clients, update the store file with modified client info

 void CTaskScheduler::UpdateClients()

 	{

 	// iterate the client list to perform delayed update of the store file

 	TDblQueIter<CClientProxy> clientIter(iClients);

 	clientIter.SetToFirst();

 	CClientProxy* client;

 	while( (client = clientIter++) != NULL)

 		{

 		if	(!client->Users())

 			{

 			// Remove from store

 			TRAPD(ignore, iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationDelete, *client));

 			//?? if ignore is not KErrNone then there is a problem with the store

             UNUSED_VAR(ignore);

 			// Remove client & delete it

 			client->Remove();

 			delete client;

 			}

 		else

 			{

 			// Update this clients data in the store...

 			TRAPD(ignore, iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *client));

 			//?? if ignore is not KErrNone then there is a problem with the store

             UNUSED_VAR(ignore);

 			}

 		}

 	}

 //

 // Environment change functions

 //

 TInt CTaskScheduler::EnvironmentChanged(TAny* aScheduler)

 	{

 	CTaskScheduler* self = reinterpret_cast<CTaskScheduler*>(aScheduler);

 	self->HandleEnvironmentChange();

 	return KErrNone;

 	}

 void CTaskScheduler::HandleEnvironmentChange()

 	{

 	// If staged startup still in critical region, can safely

 	// ignore system time change.

 	if (!IsStartupStateNonCritical())

 		{

 		return;

 		}

 	TInt changes=iNotifier->Change();

 	if	(changes & EChangesSystemTime)

 		{

 #ifdef __SCHLOGGING__

 		{

 		TTime time;

 		time.HomeTime();

 		TDateTime due(time.DateTime());

 		LOGSTRING7("CTaskScheduler::HandleEnvironmentChangeL - system time is now: [%02d/%02d/%d] @ %02d:%02d:%02d", due.Day(), (TInt) due.Month() + 1, due.Year(), due.Hour(), due.Minute(), due.Second());

 		}

 #endif

 		// Cannot use AddSchedulesToTimerL() because this method

 		// uses the non-condition version of ReplaceScheduleL.

 		TSglQueIter<CSchedule> scheduleIter(iSchedules);

 		scheduleIter.SetToFirst();

 		CSchedule* schedule = NULL;

 		while ((schedule=scheduleIter++)!=NULL)

 			{

 			if(IsScheduleReadyForUpdate(*schedule))

 				{

 				TRAPD(err, iScheduleCriteriaManager->ReplaceScheduleL(*schedule, EOnlyTime));

                 UNUSED_VAR(err);

 				}

 			}

 		}

 	}

 void CTaskScheduler::AddSchedulesToTimerL()

 	{

 	if (!IsStartupStateNonCritical())

 		{

 		return; // not ready

 		}

 	TInt ret = KErrNone;

 	TSglQueIter<CSchedule> scheduleIter(iSchedules);

 	scheduleIter.SetToFirst();

 	CSchedule* schedule = NULL;

 	while ((schedule=scheduleIter++)!=NULL)

 		{

 		if(IsScheduleReadyForUpdate(*schedule))

 			{

 			TRAPD(err, iScheduleCriteriaManager->ReplaceScheduleL(*schedule));

 			if (err != KErrNone)

 				{

 				ret = err;

 				}

 			}

 		}

 	User::LeaveIfError(ret);

 	}

 void CTaskScheduler::CleanupScheduledTasksL()

 	{

 	RFs fs;

 	_LIT(KTempFilePath, "_:\\private\\10005399\\*.tmp");

 	TBuf<32> filePath(KTempFilePath);

 	filePath[0] = RFs::GetSystemDriveChar();	

 	fs.Connect();

 	CleanupClosePushL(fs);

 	CFileMan* fileMan = CFileMan::NewL(fs);

 	CleanupStack::PushL(fileMan);

 	//Delete all temporary files in the private folder	

 	fileMan->Delete(filePath,0);

 	//Pop and destroy fs and fileMan  

 	//This will call fs.Close() so no need to call it explicitly

 	CleanupStack::PopAndDestroy(2); 

 	}

 /**

 CSchStartupStateMgr calls this to notify startup state changes of

 interest.

 @internalComponent

 */

 void CTaskScheduler::ProcessSSAEventL(TStartupStateIdentifier aKnownState)

 	{

 	LOGSTRING2("ProcessSSAEventL receive SS 0x%x", aKnownState);

 	if (! IsStartupStateNonCritical() &&

 		(aKnownState >= KSchFinalStartupState))

 		{

 		iStartupStatePassNonCritical = ETrue;

 		CleanupScheduledTasksL();

 		AddSchedulesToTimerL();

 		}

 	}

 /**

 Returns ETrue if Start-up State is NonCritical

 */

 TBool CTaskScheduler::IsStartupStateNonCritical()

 	{

 	return iStartupStatePassNonCritical;

 	}

 /**

 Check schedule is valid

 */

 TBool CTaskScheduler::IsScheduleReadyForUpdate(CSchedule& aSchedule)

 	{

 	if(aSchedule.IsUpdatable() && IsStartupStateNonCritical())

 		return 	ETrue;		

 	else

 		return EFalse;

 	}

 /**

 babackup server calls this to notify backup operations. The attributes are read and translated to determine

 which operation is actually in progress.  

 @internalComponent

 */

 void CTaskScheduler::HandleBackupOperationEventL(const TBackupOperationAttributes& aBackupOperationAttributes)

 	{

 	TBUROperation type;

 	// determine the operation type (backup or restore)

 	switch(aBackupOperationAttributes.iFileFlag)	

 		{

 		case MBackupObserver::EReleaseLockReadOnly:

 			type = EBUROperationBackup;

 			break;

 		case MBackupObserver::EReleaseLockNoAccess:

 			type = EBUROperationRestore;

 			break;

 		case MBackupObserver::ETakeLock:

 			// No information is passed from babackup server, so we need to depend on our own memory

 			type = iBUROperationInProgress;

 			break;

 		default:

 			type = EBUROperationNoActivity;

 			break;

 		}

 	// determine the operation status (e.g. starting, ending)

 	switch(aBackupOperationAttributes.iOperation)

 		{

 		case EStart:

 			BURBeginningL(type);

 			break;

 		case EEnd:

 			BURCompleteL(type, EBUROperationSuccess);

 			break;

 		case EAbort:

 			BURCompleteL(type, EBUROperationAbort);

 			break;

 		default:

 			break;

 		}

 	}

 /**

 This function is called to notify when a Backup or Restore operation is commencing.

 @internalComponent

 */

 void CTaskScheduler::BURBeginningL(TBUROperation aOperationType)

 {

 	// This will stop the API calls that directly modify the store file

 	iBUROperationInProgress	= aOperationType;

 	//cancel background compaction of store during backup/restore	

 	iBackupManager->Cancel();

 }

 /**

 This function is called to notify when a Backup or Restore operation is finished.

 @internalComponent

 */

 void CTaskScheduler::BURCompleteL(TBUROperation aOperationType, TBUROperationResult aBURResult)

 {

 	// If there is a successful restore, this means that we have a different store file then we were using 

 	// so we have to internalize and use that file. In any other case, we can proceed with the delayed 

 	// updates to the old file

 	if ((aOperationType == EBUROperationRestore)&&(aBURResult == EBUROperationSuccess))

 		{

 		LOGSTRING("CTaskScheduler::BURCompleteL - Restoring clients and schedules after successful restore");

 		//First check whether any task expires during the restore process now that this is completed

 		if (iTaskExecutedDuringBUR)	

 			{

 			// performed the delayed task execution but with no externalizing as we dont want to modify

 			// the just restored file as after the delayed execution, all persistent schedule will be removed

 			ExecuteClients(EFalse);

 			iTaskExecutedDuringBUR=EFalse;			

 			}

 		// Now remove existing persistent schedules, tasks and clients

 		TSglQueIter<CSchedule> scheduleIter(iSchedules);

 		scheduleIter.SetToFirst();

 		CSchedule* schedule;

 		while ((schedule = scheduleIter++)!=NULL)

 			{

 			if (schedule->Persists())

 				{

 				iSchedules.Remove(*schedule);

 				schedule->RemoveTasks(ETrue);

 				delete schedule; 

 				}

 			}

 		CClientProxy* client;

 		TDblQueIter<CClientProxy> clientIter(iClients);

 		// remove clients which don't have any associated tasks left (tasks in persistent schedules are

 		// already removed, but the client might have transient schedules as well)

 		clientIter.SetToFirst();

 		while ((client = clientIter++) != NULL)

 			{

 			TDblQueIter<CScheduledTask> taskIter = client->TaskIterator();

 			taskIter.SetToFirst();

 			// remove client if no more tasks

 			if (taskIter++ == NULL)

 				{

 				client->Remove();

 				delete client; // removes associated tasks

 				}

 			else

 				{

 				//remove any persisted task and if the client only has persisted task, remove client as well

 				taskIter.SetToFirst();

 				CScheduledTask* task;

 				TInt taskCount=0;

 				TInt persistCount=0;

 				while ((task = taskIter++) != NULL)

 					{

 					taskCount++;

 					if (task->Persists())

 						{

 						persistCount++;

 						client->RemoveTask(task);

 						}

 					}

 				//if after removing the persist tasks, there are no more other tasks, we can remove the client too						

 				if (taskCount==persistCount)

 					{

 					client->Remove();

 					delete client;

 					}					

 				}

 			}

 		// now re-read the clients and schedules from the restored store file

 		TRAPD(err, iBackupManager->RestoreL(iClients, iSchedules,*iSchLogManager,ETrue));

 		if	(err != KErrNone) // the file's corrupt or something...

 			{

 			LOGSTRING2("CTaskScheduler::BURCompleteL - had to create new store because of error: %d", err);

 			iBackupManager->CreateEmptyBackupL();

 			}

 		// Each client now contains a list of associated tasks. We need

 		// to now associate those tasks with specific schedules

 		clientIter.SetToFirst();

 		while ((client = clientIter++) != NULL)

 			{

 			// Fetch an iterator for each task owned by this client

 			CScheduledTask* task;

 			TDblQueIter<CScheduledTask> taskIterator = client->TaskIterator();

 			taskIterator.SetToFirst();

 			// Iterate through all the tasks owned by this client, trying to find

 			// the corresponding schedules.

 			while ((task = taskIterator++) != NULL)

 				{

 				TSglQueIter<CSchedule> persScheduleIter(iSchedules);

 				persScheduleIter.SetToFirst();

 				CSchedule* persSchedule;

 				while ((persSchedule = persScheduleIter++)!=NULL)

 					{

 					if ((persSchedule->Persists())&&(persSchedule->Id() == task->ScheduleId()))

 						{

 						TScheduledTask* taskRef = new(ELeave) TScheduledTask(*task,*client);

 						persSchedule->AddTask(*taskRef);

 						}

 					}

 				}

 			}

 		// Activate the scheduler with the new schedules

 		AddSchedulesToTimerL();	

 		}

 	else

 		{

 		if (iTaskExecutedDuringBUR)	

 			{

 			iBUROperationInProgress	= EBUROperationNoActivity;		

 			iTaskExecutedDuringBUR = EFalse;

 			// performed the delayed task execution

 			ExecuteClients();

 			}	

 		}	

 	// BUR operation is completed

 	iBUROperationInProgress	= EBUROperationNoActivity;		

 	iTaskExecutedDuringBUR = EFalse;

 }