sl@0: // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: // System includes
sl@0: #include <bacntf.h>
sl@0: 
sl@0: // User includes
sl@0: #include "SCHMAN.H"
sl@0: #include "SchTimer.h"
sl@0: #include "SchLogger.h"
sl@0: #include "SCHEDULE.H"
sl@0: #include "SCHCLI.H"
sl@0: #include "SCHSTORE.H"
sl@0: #include <schtask.h>
sl@0: #include "SCHLOG.h"
sl@0: 
sl@0: // Constants
sl@0: const TInt KMinScheduleId = 0;
sl@0: const TInt KMaxSchedules = 25000;
sl@0: 
sl@0: //Command line argument  
sl@0: _LIT(KCommandLine, "SYSSTARTSCHEXE");
sl@0: 
sl@0: //SID of SysStart
sl@0: const TInt KSysStartSID = 0x10205C44; 
sl@0: 
sl@0: 
sl@0: #define UNUSED_VAR(a) a = a
sl@0: 
sl@0: //
sl@0: // Construction/Destruction functions
sl@0: //
sl@0: 
sl@0: CTaskScheduler::CTaskScheduler()
sl@0: :	iSchedules(CSchedule::Offset()), 
sl@0: 	iClients(CClientProxy::Offset()),
sl@0: 	iStartupStatePassNonCritical(EFalse)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CTaskScheduler::~CTaskScheduler()
sl@0: 	{
sl@0: 	if (iBackupNotification)
sl@0: 		{
sl@0: 		iBackupNotification->DeRegisterBackupOperationObserver(*this);
sl@0: 		}
sl@0: 	delete iBackupNotification;
sl@0: 	delete iBackupManager;
sl@0: 	delete iNotifier;
sl@0: 	delete iScheduleCriteriaManager;
sl@0: 	delete iSchLogManager;
sl@0: 	
sl@0: 	//remove clients and schedules as well!!
sl@0: 	TDblQueIter<CClientProxy> clientIter(iClients);
sl@0: 	
sl@0: 	clientIter.SetToFirst();
sl@0: 	CClientProxy* client=NULL;
sl@0: 	while ((client=clientIter++)!=NULL)
sl@0: 		{
sl@0: 			client->Remove();
sl@0: 			delete client;
sl@0: 		}
sl@0: 	
sl@0: 	TSglQueIter<CSchedule> schedIter(iSchedules);
sl@0: 	
sl@0: 	schedIter.SetToFirst();
sl@0: 	CSchedule* schedule=NULL;
sl@0: 	while ((schedule=schedIter++)!=NULL)
sl@0: 		{
sl@0: 			iSchedules.Remove(*schedule);
sl@0: 			delete schedule;
sl@0: 		}	
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::ConstructL()
sl@0: 	{
sl@0: 	LOGSTRING("CTaskScheduler::ConstructL - Creating new schedule server log entry");
sl@0: 
sl@0: 	User::LeaveIfError(iFsSession.Connect());
sl@0: 	iBackupManager = new(ELeave) CSchBackupManager(iFsSession);
sl@0: 	iBackupManager->ConstructL();
sl@0: 
sl@0: 	iNotifier = CEnvironmentChangeNotifier::NewL(CActive::EPriorityHigh, TCallBack(EnvironmentChanged, this));
sl@0: 	iNotifier->Start();
sl@0: 
sl@0: 	iScheduleCriteriaManager = CScheduleCriteriaManager::NewL(*this);
sl@0: 
sl@0: 	iSchLogManager = CSchLogManager::NewL(iFsSession);
sl@0: 
sl@0: 	LOGSTRING("CTaskScheduler::ConstructL - Restoring clients and schedules");
sl@0: 	TRAPD(err, iBackupManager->RestoreL(iClients, iSchedules,*iSchLogManager));
sl@0: 	if	(err != KErrNone) // the file's corrupt or something...
sl@0: 		{
sl@0: 		LOGSTRING2("CTaskScheduler::ConstructL - had to create new store because of error: %d", err);
sl@0: 		iBackupManager->CreateEmptyBackupL();
sl@0: 		}
sl@0: 		
sl@0: 	//checking the SID of the process which started the Task scheduler	
sl@0:  	if (User::CreatorSecureId() == KSysStartSID)
sl@0: 	 	{
sl@0: 	    TInt argLen = User::CommandLineLength();
sl@0:      	if (argLen)
sl@0: 	         {
sl@0: 	         HBufC* arg = HBufC::NewLC(argLen);
sl@0: 	         TPtr argPtr = arg->Des();
sl@0: 	         User::CommandLine(argPtr);
sl@0: 	         argPtr.UpperCase();
sl@0: 	         
sl@0: 	 		 //Checking Comman dLine arg passed to it is same as in SSCForStartupMode0.rss
sl@0: 	 		 //and checking for persisted schedules
sl@0: 	         if((argPtr.Compare(KCommandLine) == 0) && iSchedules.IsEmpty())
sl@0: 	             {
sl@0: 	             //if no schedule leave
sl@0: 				 User::Leave(KErrNone);
sl@0: 	             }
sl@0: 	 	      CleanupStack::PopAndDestroy(arg);
sl@0: 	 	      }
sl@0:          }
sl@0: 
sl@0: 	// Each client now contains a list of associated tasks. We need
sl@0: 	// to now associate those tasks with specific schedules
sl@0: 	CClientProxy* client;
sl@0: 	TDblQueIter<CClientProxy> clientIter(iClients);
sl@0: 	clientIter.SetToFirst();
sl@0: 	while ((client = clientIter++) != NULL)
sl@0: 		{
sl@0: 		// Fetch an iterator for each task owned by this client
sl@0: 		CScheduledTask* task;
sl@0: 		TDblQueIter<CScheduledTask> taskIterator = client->TaskIterator();
sl@0: 		taskIterator.SetToFirst();
sl@0: 
sl@0: 		// Iterate through all the tasks owned by this client, trying to find
sl@0: 		// the corresponding schedules.
sl@0: 		while ((task = taskIterator++) != NULL)
sl@0: 			{
sl@0: 			CSchedule* schedule = NULL;
sl@0: 			schedule = Find(task->ScheduleId());
sl@0: 			if (schedule)
sl@0: 				{
sl@0: 				TScheduledTask* taskRef = new(ELeave) TScheduledTask(*task,*client);
sl@0: 				schedule->AddTask(*taskRef);
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	iBackupNotification = CBaBackupSessionWrapper::NewL();
sl@0: 	iBackupNotification->RegisterBackupOperationObserverL(*this);
sl@0: 	}
sl@0: 
sl@0: CTaskScheduler* CTaskScheduler::NewL()
sl@0: 	{
sl@0: 	CTaskScheduler* self = CTaskScheduler::NewLC();
sl@0: 	CleanupStack::Pop();
sl@0: 	return self;	
sl@0: 	}
sl@0: 
sl@0: CTaskScheduler* CTaskScheduler::NewLC()
sl@0: 	{
sl@0: 	CTaskScheduler* self = new(ELeave) CTaskScheduler();
sl@0: 	CleanupStack::PushL(self);
sl@0: 	self->ConstructL();
sl@0: 	return self;
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Client, Schedule and Task functions
sl@0: //
sl@0: 
sl@0: CClientProxy* CTaskScheduler::AddClientL(const TDesC& aFilename, TInt aPriority)
sl@0: 	{
sl@0: 	//check we don't already have a client that will do...
sl@0: 	TDblQueIter<CClientProxy> clientIter(iClients);
sl@0: 	clientIter.SetToFirst();
sl@0: 	CClientProxy* client=NULL;
sl@0: 	while ((client=clientIter++)!=NULL)
sl@0: 		{
sl@0: 		if	(client->IsEqual(aFilename, aPriority))
sl@0: 			return client;
sl@0: 		}
sl@0: 	client = CClientProxy::NewL(iFsSession, aFilename, aPriority,*iSchLogManager); 
sl@0: 	iClients.Add(*client);
sl@0: 	return client;
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::AddScheduleL(CSchedule& aSchedule)
sl@0: 	{
sl@0: 	LOGSTRING3("CTaskScheduler::AddScheduleL - schedule: %S, %d", &aSchedule.Name(), aSchedule.Id());
sl@0: 	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationAdd, aSchedule);
sl@0: 	iSchedules.AddLast(aSchedule);
sl@0: 	LOGSTRING("CTaskScheduler::AddScheduleL - schedule added");
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::EditScheduleL(TInt aScheduleHandle, CArrayFixFlat<TScheduleEntryInfo2>& aEntryList)
sl@0: 	{
sl@0: 	CSchedule* schedule = FindL(aScheduleHandle);
sl@0: 
sl@0: 	// remove schedule from condition manager before replacing entries to ensure 
sl@0: 	// its deleted properly.
sl@0: 	iScheduleCriteriaManager->RemoveSchedule(schedule->Id());
sl@0: 	schedule->ReplaceEntriesL(aEntryList);
sl@0: 
sl@0: 	TRAPD(err, iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *schedule));
sl@0: 	if(err)
sl@0: 		{
sl@0: 		schedule->RemoveEntries();
sl@0: 		User::Leave(err);
sl@0: 		}
sl@0: 	// recalculate due time only if schedule is enabled and has tasks to run	
sl@0: 	if (IsScheduleReadyForUpdate(*schedule))
sl@0: 		{
sl@0: 		iScheduleCriteriaManager->ReplaceScheduleL(*schedule);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::DoEditScheduleL(CSchedule& aSchedule, 
sl@0: 							CArrayFixFlat<TTaskSchedulerCondition>& aConditionList,
sl@0: 							const TTsTime& aDefaultTime)
sl@0: 	{
sl@0: 	aSchedule.ReplaceConditionsL(aConditionList);
sl@0: 	
sl@0: 	//Default Time is represented by a single entry class
sl@0: 	CArrayFixFlat<TScheduleEntryInfo2>* entries 
sl@0: 		= new(ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1);
sl@0: 	CleanupStack::PushL(entries);
sl@0: 	TScheduleEntryInfo2 info;
sl@0: 	info.SetStartTime(aDefaultTime);
sl@0: 	info.SetInterval(1);
sl@0: 	info.SetIntervalType(EDaily);
sl@0: 	//validityperiod of 24 hours will ensure task is always run
sl@0: 	info.SetValidityPeriod(60*24); 
sl@0: 	entries->AppendL(info);
sl@0: 	aSchedule.ReplaceEntriesL(*entries);
sl@0: 	CleanupStack::Pop(entries);
sl@0: 	
sl@0: 	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, aSchedule);
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::EditScheduleL(TInt aScheduleHandle, 
sl@0: 							CArrayFixFlat<TTaskSchedulerCondition>& aConditionList,
sl@0: 							const TTsTime& aDefaultTime)
sl@0: 	{
sl@0: 	CSchedule* schedule = FindL(aScheduleHandle);
sl@0: 
sl@0: 	// remove schedule from condition manager before replacing entries to ensure 
sl@0: 	// its deleted properly.
sl@0: 	iScheduleCriteriaManager->RemoveSchedule(schedule->Id());
sl@0: 
sl@0: 	TRAPD(err, DoEditScheduleL(*schedule, aConditionList, aDefaultTime));
sl@0: 	if(err)
sl@0: 		{
sl@0: 		schedule->RemoveEntries();
sl@0: 		schedule->RemoveConditions();
sl@0: 		User::Leave(err);
sl@0: 		}
sl@0: 
sl@0: 	// recalculate due time only if schedule is enabled and has tasks to run	
sl@0: 	if (IsScheduleReadyForUpdate(*schedule))
sl@0: 		{
sl@0: 		iScheduleCriteriaManager->ReplaceScheduleL(*schedule);
sl@0: 		}
sl@0: 	}	
sl@0: 
sl@0: void CTaskScheduler::RemoveScheduleL(TInt aHandle)
sl@0: 	{
sl@0: 	CSchedule* schedule = FindL(aHandle);
sl@0: 	LOGSTRING3("CTaskScheduler::RemoveScheduleL - schedule: %S, %d", &schedule->Name(), schedule->Id());
sl@0: 	if (!schedule->HasTasks())
sl@0: 		{
sl@0: 		LOGSTRING("CTaskScheduler::RemoveScheduleL - schedule doesn't have any tasks, removing");
sl@0: 		//remove schedule from timer
sl@0: 		iScheduleCriteriaManager->RemoveSchedule(schedule->Id());
sl@0: 		DoRemoveL(schedule);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		// Can't delete a schedule which has tasks
sl@0: 		LOGSTRING("CTaskScheduler::RemoveScheduleL - schedule has tasks, can't delete");
sl@0: 		User::Leave(KErrArgument);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::DisableScheduleL(TInt aHandle)
sl@0: 	{
sl@0: 	CSchedule* schedule = FindL(aHandle);
sl@0: 	schedule->SetEnabled(EFalse);
sl@0: 	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *schedule);
sl@0: 	//remove schedule from timer as its disabled
sl@0: 	iScheduleCriteriaManager->RemoveSchedule(schedule->Id());
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::EnableScheduleL(TInt aHandle)
sl@0: 	{
sl@0: 	CSchedule* schedule = FindL(aHandle);
sl@0: 	schedule->SetEnabled(ETrue);
sl@0: 	iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *schedule);
sl@0: 
sl@0: 	// recalculate due time only if schedule has tasks to run	
sl@0: 	if ( IsScheduleReadyForUpdate(*schedule))
sl@0: 		{
sl@0: 		iScheduleCriteriaManager->ReplaceScheduleL(*schedule);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::ScheduleTaskL(CSchedule& aSchedule, CClientProxy& aClient)
sl@0: 	{
sl@0: 	// Backup the task
sl@0: 	if	(aSchedule.Persists())
sl@0: 		{
sl@0: 		iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, aClient);
sl@0: 		}
sl@0: 	// if schedule is enabled then add schedule to timer.
sl@0: 	if (aSchedule.Enabled() && IsStartupStateNonCritical())
sl@0: 		{
sl@0: 		iScheduleCriteriaManager->ReplaceScheduleL(aSchedule);
sl@0: 		}		
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::DeleteTaskL(TInt aScheduleHandle, TInt aTaskHandle)
sl@0: 	{
sl@0: 	CSchedule* schedule = FindL(aScheduleHandle);
sl@0: 
sl@0: 	TScheduledTask* task = schedule->Task(aTaskHandle);
sl@0: 	if (!task)
sl@0: 		{
sl@0: 		LOGSTRING("CTaskScheduler::DeleteTaskL - task wasn't found");
sl@0: 		User::Leave(KErrNotFound);
sl@0: 		}
sl@0: 
sl@0: 	const CClientProxy& clientForTask = task->Client();
sl@0: 	
sl@0: 	// This deletes the task and removes the CScheduledTask
sl@0: 	// from the CClientProxy's queue of tasks
sl@0: 	task->RemoveInfo();
sl@0: 
sl@0: 	// This deletes the TScheduledTask defined above and removes it
sl@0: 	// from CSchedule's queue of TScheduledTask's.
sl@0: 	schedule->RemoveTask(task);
sl@0: 	if (!schedule->HasTasks())	//i.e. it was the last task 
sl@0: 		{
sl@0: 		LOGSTRING("CTaskScheduler::DeleteTaskL - schedule doesn't have any more tasks left");
sl@0: 		//remove scheule from timer as there are no more tasks
sl@0: 		iScheduleCriteriaManager->RemoveSchedule(schedule->Id());
sl@0: 		// If the schedule isn't persistent then we delete it (transient schedules only
sl@0: 		// have one task).
sl@0: 		if (!schedule->Persists())
sl@0: 			DoRemoveL(schedule);
sl@0: 		else
sl@0: 			iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, clientForTask);		
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		// Backup the changes to the tasks. Although we are deleting a task, we are not actually
sl@0: 		// deleting the client, so this is actually an edit operation.
sl@0: 		if (schedule->Persists())
sl@0: 			iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, clientForTask);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //
sl@0: // Utility Functions
sl@0: //
sl@0: 
sl@0: TInt CTaskScheduler::GenerateId()
sl@0: 	{
sl@0: 	TInt id = KMinScheduleId;
sl@0: 	CSchedule* schedule = Find(id);
sl@0: 	while (schedule!=NULL) 
sl@0: 		{
sl@0: 		id+=KScheduleIdDifferential;//=10 000
sl@0: 		if ((id/KScheduleIdDifferential) > KMaxSchedules)
sl@0: 			return KErrOverflow;
sl@0: 		schedule = Find(id);
sl@0: 		}
sl@0: 	return id;
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::DoRemoveL(CSchedule* aSchedule)
sl@0: 	{
sl@0: 	TRAPD(err, iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationDelete, *aSchedule));
sl@0: 	if	(err < KErrNone && err != KErrNotFound)
sl@0: 		User::Leave(err);
sl@0: 	iSchedules.Remove(*aSchedule);
sl@0: 	delete aSchedule;
sl@0: 	aSchedule = NULL;
sl@0: 	}
sl@0: 
sl@0: CSchedule* CTaskScheduler::FindL(TInt aHandle)
sl@0: 	{
sl@0: 	CSchedule* schedule = Find(aHandle);
sl@0: 	if (!schedule)
sl@0: 		User::Leave(KErrNotFound);
sl@0: 	return schedule;
sl@0: 	}
sl@0: 
sl@0: CSchedule* CTaskScheduler::Find(TInt aHandle)
sl@0: 	{
sl@0: 	TSglQueIter<CSchedule> scheduleIter(iSchedules);
sl@0: 	scheduleIter.SetToFirst();
sl@0: 	CSchedule* schedule;
sl@0: 	while ((schedule = scheduleIter++)!=NULL)
sl@0: 		{
sl@0: 		if (schedule->Id() == aHandle)
sl@0: 			return schedule;
sl@0: 		}
sl@0: 	return NULL;
sl@0: 	}
sl@0: 
sl@0: // If aRefArray is NULL then only count it returned.
sl@0: TInt CTaskScheduler::GetScheduleRefsL(CArrayFixFlat<TSchedulerItemRef>* aRefArray, 
sl@0: 									TScheduleFilter aFilter,
sl@0: 									const RMessagePtr2& aMessage)
sl@0: 	{
sl@0: 	TInt count = 0;
sl@0: 	TSglQueIter<CSchedule> iter(iSchedules);
sl@0: 	iter.SetToFirst();
sl@0: 	CSchedule* schedule = NULL;
sl@0: 	while ((schedule = iter++) != NULL)
sl@0: 		{
sl@0: 		if(aFilter == EAllSchedules || (schedule->Enabled() && schedule->HasTasks()))
sl@0: 			{
sl@0: 			//only add information for schedules that the client has permission to alter
sl@0: 			if(schedule->IsAccessAllowed(aMessage))
sl@0: 				{
sl@0: 				if(aRefArray)
sl@0: 					{
sl@0: 					TSchedulerItemRef ref;
sl@0: 					ref.iHandle = schedule->Id();
sl@0: 					ref.iName = schedule->Name();
sl@0: 					aRefArray->AppendL(ref);	
sl@0: 					}
sl@0: 				count++;		
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	return count;				
sl@0: 	}
sl@0: 
sl@0: // If aRefArray is NULL then only count it returned.
sl@0: TInt CTaskScheduler::GetTaskRefsL(CArrayFixFlat<TSchedulerItemRef>* aRefArray, 
sl@0: 									TScheduleFilter aScheduleFilter,
sl@0: 									TTaskFilter aTaskFilter,
sl@0: 									CClientProxy* aClient,
sl@0: 									const RMessagePtr2& aMessage)
sl@0: 	{
sl@0: 	TInt count = 0;
sl@0: 	TSglQueIter<CSchedule> iter(iSchedules);
sl@0: 	iter.SetToFirst();
sl@0: 	CSchedule* schedule = NULL;
sl@0: 	while ((schedule = iter++) != NULL)
sl@0: 		{
sl@0: 		if(aScheduleFilter == EAllSchedules || (schedule->Enabled() && schedule->HasTasks()))
sl@0: 			{
sl@0: 			//only add information for schedules that the client has permission to alter
sl@0: 			if(schedule->IsAccessAllowed(aMessage))
sl@0: 				{
sl@0: 				TSglQueIter<TScheduledTask> taskIter(*(schedule->Tasks()));
sl@0: 				taskIter.SetToFirst();
sl@0: 				TScheduledTask* task;
sl@0: 				while ((task=taskIter++)!=NULL)
sl@0: 					{
sl@0: 					if (aTaskFilter==EAllTasks||&task->Client() == aClient) // This pointer comparison is a bit rubbish.  Change?
sl@0: 						{
sl@0: 						if(aRefArray)
sl@0: 							{
sl@0: 							TTaskInfo info = task->Info();
sl@0: 							TSchedulerItemRef ref;
sl@0: 							ref.iHandle = info.iTaskId;
sl@0: 							ref.iName = info.iName;
sl@0: 							aRefArray->AppendL(ref);
sl@0: 							}
sl@0: 						count++;
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	return count;				
sl@0: 	}
sl@0: 	
sl@0: 
sl@0: //
sl@0: // Schedule Execution functions
sl@0: //
sl@0: 
sl@0: // A schedule is ready to be run
sl@0: void CTaskScheduler::DueTaskNotifyL(TInt aScheduleHandle)
sl@0: 	{
sl@0: 	CSchedule* schedule = FindL(aScheduleHandle);
sl@0: 	//NotifyTasks() also removes tasks from the schedule if there are no 
sl@0: 	//repeats left.
sl@0: 	schedule->NotifyTasks(); 
sl@0: 
sl@0: 	if (!schedule->HasTasks())
sl@0: 		{
sl@0: 		// remove schedule.
sl@0: 		TRAPD(ignore, DoRemoveL(schedule));
sl@0: 		//??error only occurs in relation to persistence!! Do something.  
sl@0:         UNUSED_VAR(ignore);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__ASSERT_ALWAYS(IsStartupStateNonCritical(), User::Invariant());
sl@0: 		iScheduleCriteriaManager->ReplaceScheduleL(*schedule,EConditionAndTime,ETrue);
sl@0: 		}
sl@0: 
sl@0: 	// Execute all clients.  This method doesn't leave as all errors are either
sl@0: 	// logged in the log engine or handled elsewhere.
sl@0: 	ExecuteClients();
sl@0: 	}
sl@0: 
sl@0: //	Go through all clients, executing their tasks
sl@0: void CTaskScheduler::ExecuteClients(TBool aUpdateClient)
sl@0: 	{
sl@0: 	if ((BUROperationInProgress() == EBUROperationNoActivity) || !aUpdateClient)
sl@0: 		{
sl@0: 		TDblQueIter<CClientProxy> clientIter(iClients);
sl@0: 		clientIter.SetToFirst();
sl@0: 		CClientProxy* client;
sl@0: 		while( (client = clientIter++) != NULL)
sl@0: 			{
sl@0: 			// Does this client have anything ready to run?
sl@0: 			if	(client->IsReadyToExecute())
sl@0: 				{
sl@0: 				client->ExecuteTasks();
sl@0: 				// Clears the 'IsReadyToExecute' flag...
sl@0: 				client->RemoveDueTasks();
sl@0: 				}
sl@0: 			}
sl@0: 		if (aUpdateClient)	
sl@0: 			{
sl@0: 			// Update the store file now
sl@0: 			UpdateClients();	
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		// Sets the flag to trigger delayed store operation when BUR ends
sl@0: 		iTaskExecutedDuringBUR = ETrue;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: //	Go through all clients, update the store file with modified client info
sl@0: void CTaskScheduler::UpdateClients()
sl@0: 	{
sl@0: 	// iterate the client list to perform delayed update of the store file
sl@0: 	TDblQueIter<CClientProxy> clientIter(iClients);
sl@0: 	clientIter.SetToFirst();
sl@0: 	CClientProxy* client;
sl@0: 	while( (client = clientIter++) != NULL)
sl@0: 		{
sl@0: 		if	(!client->Users())
sl@0: 			{
sl@0: 			// Remove from store
sl@0: 			TRAPD(ignore, iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationDelete, *client));
sl@0: 			//?? if ignore is not KErrNone then there is a problem with the store
sl@0:             UNUSED_VAR(ignore);
sl@0: 			// Remove client & delete it
sl@0: 			client->Remove();
sl@0: 			delete client;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			// Update this clients data in the store...
sl@0: 			TRAPD(ignore, iBackupManager->PerformStoreOperationL(CSchBackupManager::ESchBackupOperationEdit, *client));
sl@0: 
sl@0: 			//?? if ignore is not KErrNone then there is a problem with the store
sl@0:             UNUSED_VAR(ignore);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: //
sl@0: // Environment change functions
sl@0: //
sl@0: 
sl@0: TInt CTaskScheduler::EnvironmentChanged(TAny* aScheduler)
sl@0: 	{
sl@0: 	CTaskScheduler* self = reinterpret_cast<CTaskScheduler*>(aScheduler);
sl@0: 	self->HandleEnvironmentChange();
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::HandleEnvironmentChange()
sl@0: 	{
sl@0: 	// If staged startup still in critical region, can safely
sl@0: 	// ignore system time change.
sl@0: 	if (!IsStartupStateNonCritical())
sl@0: 		{
sl@0: 		return;
sl@0: 		}
sl@0: 
sl@0: 	TInt changes=iNotifier->Change();
sl@0: 	if	(changes & EChangesSystemTime)
sl@0: 		{
sl@0: #ifdef __SCHLOGGING__
sl@0: 		{
sl@0: 		TTime time;
sl@0: 		time.HomeTime();
sl@0: 		TDateTime due(time.DateTime());
sl@0: 		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());
sl@0: 		}
sl@0: #endif
sl@0: 
sl@0: 
sl@0: 		// Cannot use AddSchedulesToTimerL() because this method
sl@0: 		// uses the non-condition version of ReplaceScheduleL.
sl@0: 		TSglQueIter<CSchedule> scheduleIter(iSchedules);
sl@0: 		scheduleIter.SetToFirst();
sl@0: 		CSchedule* schedule = NULL;
sl@0: 		while ((schedule=scheduleIter++)!=NULL)
sl@0: 			{
sl@0: 			if(IsScheduleReadyForUpdate(*schedule))
sl@0: 				{
sl@0: 				TRAPD(err, iScheduleCriteriaManager->ReplaceScheduleL(*schedule, EOnlyTime));
sl@0:                 UNUSED_VAR(err);
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CTaskScheduler::AddSchedulesToTimerL()
sl@0: 	{
sl@0: 	if (!IsStartupStateNonCritical())
sl@0: 		{
sl@0: 		return; // not ready
sl@0: 		}
sl@0: 
sl@0: 	TInt ret = KErrNone;
sl@0: 
sl@0: 	TSglQueIter<CSchedule> scheduleIter(iSchedules);
sl@0: 	scheduleIter.SetToFirst();
sl@0: 	CSchedule* schedule = NULL;
sl@0: 	while ((schedule=scheduleIter++)!=NULL)
sl@0: 		{
sl@0: 		if(IsScheduleReadyForUpdate(*schedule))
sl@0: 			{
sl@0: 			TRAPD(err, iScheduleCriteriaManager->ReplaceScheduleL(*schedule));
sl@0: 			if (err != KErrNone)
sl@0: 				{
sl@0: 				ret = err;
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	User::LeaveIfError(ret);
sl@0: 	}
sl@0: 	
sl@0: void CTaskScheduler::CleanupScheduledTasksL()
sl@0: 	{
sl@0: 	RFs fs;
sl@0: 	_LIT(KTempFilePath, "_:\\private\\10005399\\*.tmp");
sl@0: 	TBuf<32> filePath(KTempFilePath);
sl@0: 
sl@0: 	filePath[0] = RFs::GetSystemDriveChar();	
sl@0: 	
sl@0: 	fs.Connect();
sl@0: 	CleanupClosePushL(fs);
sl@0: 	
sl@0: 	CFileMan* fileMan = CFileMan::NewL(fs);
sl@0: 	CleanupStack::PushL(fileMan);
sl@0: 
sl@0: 	//Delete all temporary files in the private folder	
sl@0: 	fileMan->Delete(filePath,0);
sl@0: 	
sl@0: 	//Pop and destroy fs and fileMan  
sl@0: 	//This will call fs.Close() so no need to call it explicitly
sl@0: 	CleanupStack::PopAndDestroy(2); 
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: CSchStartupStateMgr calls this to notify startup state changes of
sl@0: interest.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: void CTaskScheduler::ProcessSSAEventL(TStartupStateIdentifier aKnownState)
sl@0: 	{
sl@0: 	LOGSTRING2("ProcessSSAEventL receive SS 0x%x", aKnownState);
sl@0: 
sl@0: 	if (! IsStartupStateNonCritical() &&
sl@0: 		(aKnownState >= KSchFinalStartupState))
sl@0: 		{
sl@0: 		iStartupStatePassNonCritical = ETrue;
sl@0: 		CleanupScheduledTasksL();
sl@0: 		AddSchedulesToTimerL();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Returns ETrue if Start-up State is NonCritical
sl@0: */
sl@0: TBool CTaskScheduler::IsStartupStateNonCritical()
sl@0: 	{
sl@0: 	return iStartupStatePassNonCritical;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Check schedule is valid
sl@0: */
sl@0: TBool CTaskScheduler::IsScheduleReadyForUpdate(CSchedule& aSchedule)
sl@0: 	{
sl@0: 	if(aSchedule.IsUpdatable() && IsStartupStateNonCritical())
sl@0: 		return 	ETrue;		
sl@0: 	else
sl@0: 		return EFalse;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: babackup server calls this to notify backup operations. The attributes are read and translated to determine
sl@0: which operation is actually in progress.  
sl@0: @internalComponent
sl@0: */
sl@0: void CTaskScheduler::HandleBackupOperationEventL(const TBackupOperationAttributes& aBackupOperationAttributes)
sl@0: 	{
sl@0: 	TBUROperation type;
sl@0: 
sl@0: 	// determine the operation type (backup or restore)
sl@0: 	switch(aBackupOperationAttributes.iFileFlag)	
sl@0: 		{
sl@0: 		case MBackupObserver::EReleaseLockReadOnly:
sl@0: 			type = EBUROperationBackup;
sl@0: 			break;
sl@0: 		case MBackupObserver::EReleaseLockNoAccess:
sl@0: 			type = EBUROperationRestore;
sl@0: 			break;
sl@0: 		case MBackupObserver::ETakeLock:
sl@0: 			// No information is passed from babackup server, so we need to depend on our own memory
sl@0: 			type = iBUROperationInProgress;
sl@0: 			break;
sl@0: 		default:
sl@0: 			type = EBUROperationNoActivity;
sl@0: 			break;
sl@0: 		}
sl@0: 		
sl@0: 	// determine the operation status (e.g. starting, ending)
sl@0: 	switch(aBackupOperationAttributes.iOperation)
sl@0: 		{
sl@0: 		case EStart:
sl@0: 			BURBeginningL(type);
sl@0: 			break;
sl@0: 		case EEnd:
sl@0: 			BURCompleteL(type, EBUROperationSuccess);
sl@0: 			break;
sl@0: 		case EAbort:
sl@0: 			BURCompleteL(type, EBUROperationAbort);
sl@0: 			break;
sl@0: 		default:
sl@0: 			break;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: This function is called to notify when a Backup or Restore operation is commencing.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: void CTaskScheduler::BURBeginningL(TBUROperation aOperationType)
sl@0: {
sl@0: 	// This will stop the API calls that directly modify the store file
sl@0: 	iBUROperationInProgress	= aOperationType;
sl@0: 	
sl@0: 	//cancel background compaction of store during backup/restore	
sl@0: 	iBackupManager->Cancel();
sl@0: }
sl@0: 
sl@0: 
sl@0: /**
sl@0: This function is called to notify when a Backup or Restore operation is finished.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: void CTaskScheduler::BURCompleteL(TBUROperation aOperationType, TBUROperationResult aBURResult)
sl@0: {
sl@0: 	// If there is a successful restore, this means that we have a different store file then we were using 
sl@0: 	// so we have to internalize and use that file. In any other case, we can proceed with the delayed 
sl@0: 	// updates to the old file
sl@0: 	if ((aOperationType == EBUROperationRestore)&&(aBURResult == EBUROperationSuccess))
sl@0: 		{
sl@0: 		LOGSTRING("CTaskScheduler::BURCompleteL - Restoring clients and schedules after successful restore");
sl@0: 
sl@0: 		//First check whether any task expires during the restore process now that this is completed
sl@0: 		if (iTaskExecutedDuringBUR)	
sl@0: 			{
sl@0: 			// performed the delayed task execution but with no externalizing as we dont want to modify
sl@0: 			// the just restored file as after the delayed execution, all persistent schedule will be removed
sl@0: 			ExecuteClients(EFalse);
sl@0: 			iTaskExecutedDuringBUR=EFalse;			
sl@0: 			}
sl@0: 		
sl@0: 		// Now remove existing persistent schedules, tasks and clients
sl@0: 		TSglQueIter<CSchedule> scheduleIter(iSchedules);
sl@0: 		scheduleIter.SetToFirst();
sl@0: 		CSchedule* schedule;
sl@0: 		while ((schedule = scheduleIter++)!=NULL)
sl@0: 			{
sl@0: 			if (schedule->Persists())
sl@0: 				{
sl@0: 				iSchedules.Remove(*schedule);
sl@0: 				schedule->RemoveTasks(ETrue);
sl@0: 				delete schedule; 
sl@0: 				}
sl@0: 			}
sl@0: 
sl@0: 		CClientProxy* client;
sl@0: 		TDblQueIter<CClientProxy> clientIter(iClients);
sl@0: 		
sl@0: 		// remove clients which don't have any associated tasks left (tasks in persistent schedules are
sl@0: 		// already removed, but the client might have transient schedules as well)
sl@0: 		clientIter.SetToFirst();
sl@0: 		while ((client = clientIter++) != NULL)
sl@0: 			{
sl@0: 			TDblQueIter<CScheduledTask> taskIter = client->TaskIterator();
sl@0: 			taskIter.SetToFirst();
sl@0: 			
sl@0: 			// remove client if no more tasks
sl@0: 			if (taskIter++ == NULL)
sl@0: 				{
sl@0: 				client->Remove();
sl@0: 				delete client; // removes associated tasks
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				//remove any persisted task and if the client only has persisted task, remove client as well
sl@0: 				taskIter.SetToFirst();
sl@0: 				CScheduledTask* task;
sl@0: 				TInt taskCount=0;
sl@0: 				TInt persistCount=0;
sl@0: 				while ((task = taskIter++) != NULL)
sl@0: 					{
sl@0: 					taskCount++;
sl@0: 					if (task->Persists())
sl@0: 						{
sl@0: 						persistCount++;
sl@0: 						client->RemoveTask(task);
sl@0: 						}
sl@0: 					}
sl@0: 				//if after removing the persist tasks, there are no more other tasks, we can remove the client too						
sl@0: 				if (taskCount==persistCount)
sl@0: 					{
sl@0: 					client->Remove();
sl@0: 					delete client;
sl@0: 					}					
sl@0: 				}
sl@0: 			}
sl@0: 		
sl@0: 		// now re-read the clients and schedules from the restored store file
sl@0: 		TRAPD(err, iBackupManager->RestoreL(iClients, iSchedules,*iSchLogManager,ETrue));
sl@0: 
sl@0: 		if	(err != KErrNone) // the file's corrupt or something...
sl@0: 			{
sl@0: 			LOGSTRING2("CTaskScheduler::BURCompleteL - had to create new store because of error: %d", err);
sl@0: 			iBackupManager->CreateEmptyBackupL();
sl@0: 			}
sl@0: 
sl@0: 			
sl@0: 		// Each client now contains a list of associated tasks. We need
sl@0: 		// to now associate those tasks with specific schedules
sl@0: 		clientIter.SetToFirst();
sl@0: 		while ((client = clientIter++) != NULL)
sl@0: 			{
sl@0: 			// Fetch an iterator for each task owned by this client
sl@0: 			CScheduledTask* task;
sl@0: 			TDblQueIter<CScheduledTask> taskIterator = client->TaskIterator();
sl@0: 			taskIterator.SetToFirst();
sl@0: 
sl@0: 			// Iterate through all the tasks owned by this client, trying to find
sl@0: 			// the corresponding schedules.
sl@0: 			while ((task = taskIterator++) != NULL)
sl@0: 				{
sl@0: 				TSglQueIter<CSchedule> persScheduleIter(iSchedules);
sl@0: 				persScheduleIter.SetToFirst();
sl@0: 				CSchedule* persSchedule;
sl@0: 				while ((persSchedule = persScheduleIter++)!=NULL)
sl@0: 					{
sl@0: 					if ((persSchedule->Persists())&&(persSchedule->Id() == task->ScheduleId()))
sl@0: 						{
sl@0: 						TScheduledTask* taskRef = new(ELeave) TScheduledTask(*task,*client);
sl@0: 						persSchedule->AddTask(*taskRef);
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		
sl@0: 		// Activate the scheduler with the new schedules
sl@0: 		AddSchedulesToTimerL();	
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		if (iTaskExecutedDuringBUR)	
sl@0: 			{
sl@0: 			iBUROperationInProgress	= EBUROperationNoActivity;		
sl@0: 			iTaskExecutedDuringBUR = EFalse;
sl@0: 			// performed the delayed task execution
sl@0: 			ExecuteClients();
sl@0: 			}	
sl@0: 		}	
sl@0: 	
sl@0: 	// BUR operation is completed
sl@0: 	iBUROperationInProgress	= EBUROperationNoActivity;		
sl@0: 	iTaskExecutedDuringBUR = EFalse;
sl@0: }