// 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:

 //

 // User includes

 #include "SchLogger.h"

 #include "SCHEDULE.H"

 #include <schtask.h>

 #include "SCHCLI.H"

 #include "SCHENTRY.H"

 #include "SchTimer.h"

 #include "SCHEXEC.H"

 // Constants

 const TInt KMaxTasksPerSchedule = 9999;

 //TScheduledTask

 TScheduledTask::TScheduledTask(CScheduledTask& aTask, CClientProxy& aClient)

 	:	iTask(aTask), 

 		iClient(aClient)

 	{

 	}

 void TScheduledTask::OnDue(const TTsTime& aValidUntil)

 	{

 	LOGSTRING("TScheduledTask::OnDue - start");

 	iTask.OnDue(aValidUntil);

 	iClient.ReadyToExecute();

 	LOGSTRING("TScheduledTask::OnDue - end");

 	}

 const HBufC& TScheduledTask::Data() const

 	{

 	return iTask.Data();

 	}

 const TTaskInfo& TScheduledTask::Info() const

 	{

 	return iTask.Info();

 	}

 const CClientProxy& TScheduledTask::Client() const

 	{

 	return iClient;

 	}

 void TScheduledTask::RemoveInfo()

 	{

 	LOGSTRING("TScheduledTask::RemoveInfo - start");

 	iClient.RemoveTask(&iTask);

 	LOGSTRING("TScheduledTask::RemoveInfo - end");

 	}

 void TScheduledTask::DecRepeat()

 	{

 	iTask.DecRepeat();

 	}

 TInt TScheduledTask::Offset()

 	{

 	return (_FOFF(TScheduledTask, iLink));

 	}

 /*************************************************************************/

 //CSchedule functions

 /*************************************************************************/

 CSchedule* CSchedule::NewLC(TInt aHandle, 

 						const TDesC& aName, 

 						TBool aPersists, 

 						const CArrayFixFlat<TScheduleEntryInfo2>& aEntries,

 						const TSecurityInfo& aSecurityInfo)

 	{

 	CSchedule* self = new(ELeave) CSchedule(aSecurityInfo, aHandle, aPersists);

 	CleanupStack::PushL(self);

 	self->ConstructL(aName, aEntries);

 	return self;

 	}

 CSchedule* CSchedule::NewLC(TInt aHandle, 

 						const TDesC& aName, 

 						TBool aPersists, 

 						const CArrayFixFlat<TTaskSchedulerCondition>& aEntries,

 						const TTsTime& aDefaultRunTime,

 						const TSecurityInfo& aSecurityInfo)

 	{

 	CSchedule* self = new(ELeave) CSchedule(aSecurityInfo, aHandle, aPersists);

 	CleanupStack::PushL(self);

 	self->ConstructL(aName, aEntries,aDefaultRunTime);

 	return self;

 	}

 CSchedule* CSchedule::NewL(CFileStore& aStore, TStreamId& aStreamId)

 	{

 	CSchedule* self = new(ELeave) CSchedule;

 	CleanupStack::PushL(self);

 	self->RestoreL(aStore, aStreamId);//get self from root

 	CleanupStack::Pop();//self

 	return self;

 	}

 CSchedule::CSchedule(const TSecurityInfo& aSecurityInfo, TInt aHandle, TBool aPersists)

 :	iId(aHandle), 

 	iPersists(aPersists), 

 	iEnabled(ETrue),

 	iTaskList(TScheduledTask::Offset()),

 	iEntryList(TScheduleEntry::Offset()),

 	iSecurityInfo(aSecurityInfo)

 	{

 	}

 CSchedule::CSchedule()

 :	iTaskList(TScheduledTask::Offset()),

 	iEntryList(TScheduleEntry::Offset())

 	{

 	}

 CSchedule::~CSchedule()

 	{

 	LOGSTRING("CSchedule::~CSchedule - start");

 	delete iName;

 	RemoveTasks(EFalse);

 	RemoveEntries();

 	RemoveConditions();

 	LOGSTRING("CSchedule::~CSchedule - end");

 	}

 void CSchedule::ConstructL(const TDesC& aName,

 						const CArrayFixFlat<TScheduleEntryInfo2>& aEntries)

 	{

 	iName = aName.AllocL();

 	AddEntriesL(aEntries);

 	}

 void CSchedule::ConstructL(const TDesC& aName,

 					const CArrayFixFlat<TTaskSchedulerCondition>& aEntries,

 					const TTsTime& aDefaultRunTime)

 	{

 	iName = aName.AllocL();

 	AddConditionsL(aEntries);

 	// we plug the default time in as the start time of a schedule entry

 	TScheduleEntryInfo2 info(aDefaultRunTime, EDaily, 1, 60*24);

 	TScheduleEntry* entry = ScheduleEntryFactory::CreateL(info);

 	iEntryList.AddLast(*entry);		

 	}	

 void CSchedule::RestoreL(CFileStore& aStore, TStreamId& aId)

 	{

 	RStoreReadStream scheduleStream;

 	scheduleStream.OpenLC(aStore, aId);

 	InternalizeL(scheduleStream);

 	CleanupStack::PopAndDestroy(&scheduleStream);

 	}

 TInt CSchedule::Offset()

 	{

 	return (_FOFF(CSchedule, iLink));

 	}

 TBool CSchedule::ClientInSchedule(const TDesC& aClientName)

 //

 // returns true if the client is part of a task associated with this schedule

 //

 	{

 	TSglQueIter<TScheduledTask> tasks(iTaskList);

 	tasks.SetToFirst();

 	//

 	TScheduledTask* task;

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

 		{

 		if (task->Client().ExecutorFileName().MatchF(aClientName) == 0)

 			return ETrue;

 		}

 	return EFalse;

 	}

 //

 //Task methods

 //

 void CSchedule::AddTask(TScheduledTask& aTask)

 	{

 	iTaskList.AddFirst(aTask);

 	}

 void CSchedule::RemoveTasks(TBool aFromClient)

 	{

 	LOGSTRING("CSchedule::RemoveTasks - start");

 	TScheduledTask*  task;

 	TSglQueIter<TScheduledTask> taskIter(iTaskList);

     taskIter.SetToFirst();

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

 		{

 		if (aFromClient)

 			{

 			task->RemoveInfo();

 			}

 		RemoveTask(task);

 		}

 	LOGSTRING("CSchedule::RemoveTasks - end");

 	}

 void CSchedule::RemoveTask(TScheduledTask* aTask)

 	{

 	LOGSTRING("CSchedule::RemoveTask - start");

 	LOGSTRING2("CSchedule::RemoveTask - Schedule id: %d", iId);

 	iTaskList.Remove(*aTask);

 	delete aTask;

 	LOGSTRING("CSchedule::RemoveTask - end");

 	}

 void CSchedule::NotifyTasks()

 	{

 	LOGSTRING("CSchedule::NotifyTasks - start");

 	TScheduledTask*  task;

 	TSglQueIter<TScheduledTask> taskIter(iTaskList);

     taskIter.SetToFirst();

     TTsTime time;

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

 		{

 		if (iDueTime.IsUtc())

 			time.SetUtcTime(iDueTime.GetUtcTime() + iValidityPeriod);

 		else

 			time.SetLocalTime(iDueTime.GetLocalTime()+iValidityPeriod);

 		task->OnDue(time);

 		if	(task->Info().iRepeat > 0)

 			task->DecRepeat();

 		if	(task->Info().iRepeat == 0)

 			RemoveTask(task);

 		}

 	LOGSTRING("CSchedule::NotifyTasks - end");

 	}

 TInt CSchedule::GenerateTaskId()

 	{

 	LOGSTRING("CSchedule::GenerateTaskId - start");

 	TInt id = iId;

 	TScheduledTask* task = Task(id);

 	while (task!=NULL) 

 		{

 		if	((id-iId) > KMaxTasksPerSchedule)

 			return KErrOverflow;

 		id++;

 		task = Task(id);

 		}

 	LOGSTRING("CSchedule::GenerateTaskId - end");

 	return id;

 	}

 TScheduledTask* CSchedule::Task(const TInt aTaskId)

 	{

 	TSglQueIter<TScheduledTask> tasks(iTaskList);

 	tasks.SetToFirst();

 	//

 	TScheduledTask* task;

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

 		{

 		if	(task->Info().iTaskId == aTaskId)

 			return task;

 		}

 	return NULL;

 	}

 void CSchedule::TasksL(CArrayFixFlat<TTaskInfo>& aTasks)

 	{

 	LOGSTRING("CSchedule::TasksL - start");

 	TSglQueIter<TScheduledTask> taskIter(iTaskList);

 	taskIter.SetToFirst();

 	TScheduledTask* task;

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

 		{

 		aTasks.AppendL(task->Info());

 		}

 	LOGSTRING("CSchedule::TasksL - end");

 	}

 //

 //Externalize/Internalize methods

 //

 void CSchedule::ExternalizeL(RWriteStream& aWriteStream) const

 	{

 	LOGSTRING("CSchedule::ExternalizeL - start");

 	aWriteStream.WriteInt32L(iId);

 	aWriteStream << *iName;

 	aWriteStream.WriteInt32L(iPersists);

 	aWriteStream.WriteInt32L(iEnabled);

 	TInt count=0;

 	// Count the number of schedule entries so that

 	// we can write the count (in the stream) in advance

 	// of the entries themselves.

 	TSglQueIter<TScheduleEntry> iter(iEntryList);

 	iter.SetToFirst();

 	TScheduleEntry* entry;

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

 		count++;

 	aWriteStream.WriteInt32L(count);

 	// Write the entries

 	iter.SetToFirst();

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

 		{

 		entry->Info().ExternalizeL(aWriteStream);

 		}

 	//write conditions

 	count = iConditions.Count();

 	aWriteStream.WriteInt32L(count);

 	for(TInt ii = 0; ii<count; ++ii)

 		{

 		aWriteStream.WriteInt32L(iConditions[ii].iCategory.iUid);

 		aWriteStream.WriteUint32L(iConditions[ii].iKey);

 		aWriteStream.WriteInt32L(iConditions[ii].iState);

 		aWriteStream.WriteInt32L(iConditions[ii].iType);		

 		}		

 	//write security Info

 	aWriteStream << iSecurityInfo;

 	LOGSTRING("CSchedule::ExternalizeL - end");

 	}

 void CSchedule::InternalizeL(RReadStream& aReadStream)

 	{

 	LOGSTRING("CSchedule::InternalizeL - start");

 	iId = aReadStream.ReadInt32L();

 	HBufC* name = HBufC::NewL(aReadStream, KMaxName);

 	delete iName;

 	iName = name;

 	iPersists = aReadStream.ReadInt32L();

 	iEnabled = aReadStream.ReadInt32L();

 	//Make sure we remove the entries first!

 	RemoveEntries();

 	TInt entries = aReadStream.ReadInt32L();

 	for (TInt i=0; i<entries;i++)

 		{

 		TScheduleEntryInfo2 info;

 		info.InternalizeL(aReadStream);		

 		TScheduleEntry* entry = ScheduleEntryFactory::CreateL(info);

 		iEntryList.AddLast(*entry);

 		}

 	// now read in conditions

 	RemoveConditions();

 	TInt conditions = aReadStream.ReadInt32L();

 	for (TInt ii=0; ii<conditions;++ii)

 		{

 		TUid category;

 		category.iUid = aReadStream.ReadInt32L();

 		TUint key = aReadStream.ReadUint32L();

 		TInt state = aReadStream.ReadInt32L();

 		TTaskSchedulerCondition::TConditionType type 

 			= static_cast<TTaskSchedulerCondition::TConditionType>(aReadStream.ReadInt32L());

 		TTaskSchedulerCondition condition(category, key, state, type);

 		User::LeaveIfError(iConditions.Append(condition));

 		}

 	// read in security Info

 	aReadStream >> iSecurityInfo;

 	LOGSTRING("CSchedule::InternalizeL - end");

 	}

 //

 //Entries methods

 //

 void CSchedule::EntriesL(CArrayFixFlat<TScheduleEntryInfo2>& aEntries)

 	{

 	LOGSTRING("CSchedule::EntriesL - start");

 	TSglQueIter<TScheduleEntry> entryIter(iEntryList);

 	entryIter.SetToFirst();

 	TScheduleEntry* entry;

 	while ((entry = entryIter++) != NULL)

 		{

 		aEntries.AppendL(entry->Info());

 		}

 	LOGSTRING("CSchedule::EntriesL - end");

 	}

 void CSchedule::AddEntriesL(const CArrayFixFlat<TScheduleEntryInfo2>& aEntries)

 	{

 	LOGSTRING("CSchedule::AddEntriesL - start");

 	TInt count = aEntries.Count();

 	TScheduleEntryInfo2 entryInfo2;

 	TTsTime ttsTime;	//temporary needed due to gccxml compiler

 	TDateTime dateTime;

 	for (TInt i = 0;i<count;i++)

 		{

 		entryInfo2 = aEntries.At(i);

 		// Zero out time to the nearest ms.

 		if(entryInfo2.StartTime().IsUtc())

 			{

 			dateTime = entryInfo2.StartTime().GetUtcTime().DateTime();

 			dateTime.SetMicroSecond(0);

 			ttsTime.SetUtcTime(dateTime);

 			entryInfo2.SetStartTime(ttsTime);

 			}

 		else

 			{

 			dateTime = entryInfo2.StartTime().GetLocalTime().DateTime();

 			dateTime.SetMicroSecond(0);

 			ttsTime.SetLocalTime(dateTime);

 			entryInfo2.SetStartTime(ttsTime);

 			}

 		TScheduleEntry* entry = ScheduleEntryFactory::CreateL(entryInfo2);

 		iEntryList.AddLast(*entry);

 		}

 	LOGSTRING("CSchedule::AddEntriesL - end");

 	}

 void CSchedule::ReplaceEntriesL(const CArrayFixFlat<TScheduleEntryInfo2>& aEntries)

 	{

 	// remove the original entries

 	RemoveEntries();

 	AddEntriesL(aEntries);

 	}

 void CSchedule::RemoveEntries()

 	{

 	LOGSTRING("CSchedule::RemoveEntries - start");

 	TScheduleEntry* entry;

     TSglQueIter<TScheduleEntry> iter(iEntryList);

 	iter.SetToFirst();

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

 		{

 		iEntryList.Remove(*entry);

 		delete entry;

 		}

 	LOGSTRING("CSchedule::RemoveEntries - end");

 	}

 //Condition methods

 void CSchedule::AddConditionsL(const CArrayFixFlat<TTaskSchedulerCondition>& aConditions)

 	{

 	TInt count = aConditions.Count();

 	for (TInt i = 0;i<count;++i)

 		User::LeaveIfError(iConditions.Append(aConditions[i]));

 	}

 void CSchedule::ReplaceConditionsL(const CArrayFixFlat<TTaskSchedulerCondition>& aConditions)

 	{

 	// remove the original conditions

 	RemoveConditions();

 	AddConditionsL(aConditions);

 	}

 void CSchedule::ConditionsL(CArrayFixFlat<TTaskSchedulerCondition>& aConditions)

 	{

 	TInt count = iConditions.Count();

 	for (TInt i = 0;i<count;++i)

 		{

 		aConditions.AppendL(iConditions[i]);

 		}

 	}

 void CSchedule::RemoveConditions()

 	{

 	iConditions.Reset();

 	}

 const TTsTime& CSchedule::DefaultRunTimeL() const

 	{

 	TSglQueIter<TScheduleEntry> entryIter(iEntryList);

 	entryIter.SetToFirst();

 	TScheduleEntry* entry = entryIter;

 	if (entry == NULL)

 		User::Leave(KErrArgument);

 	return entry->DueTime();

 	}	

 // This method is called when ever a new task is scheduled or a change to an 

 // existing schedule is made. When one of the schedule entries in this schedule 

 // has become due, this is called with aNotFirstTime = ETrue.  All this does is

 // move the next due time into the next time frame.

 void CSchedule::CalculateDueTime(TBool aNotFirstTime)

 	{

 	// Sort the list of entries

 	TSglQueIter<TScheduleEntry> iter(iEntryList);

 	iter.SetToFirst();

 	TScheduleEntry* entry;

 	TTime currentTTime;

 	TTsTime currentTTsTime;

 	//make sure we reset iDueTime to max so that only the minimum is calculated.

 	TTsTime maxTime(Time::MaxTTime(), ETrue);

 	TTsTime dueTime;

 	iDueTime = maxTime; 

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

 		{

 		currentTTime.UniversalTime();

 		currentTTsTime.SetUtcTime(currentTTime);

 		// This works out when the schedule is next due based on the input time

 		// and also updates the due time if it is home time based

 		dueTime = entry->NextScheduledTime(currentTTsTime);

 		if(aNotFirstTime && dueTime.GetUtcTime() <= currentTTime) 

 			{

 			// We don't want this schedule to run straight away so seed the 

 			// next due initial time-frame by incrementing the validity

 			currentTTime += entry->Info().ValidityPeriod();

 			currentTTime += TTimeIntervalMicroSeconds32(1); // push into the next boundary

 			if (dueTime.IsUtc())

 				currentTTsTime.SetUtcTime(currentTTime);

 			else

 				currentTTsTime.SetLocalTime(currentTTime + dueTime.GetOffset());

 			dueTime = entry->NextScheduledTime(currentTTsTime);

 			}

 		if(dueTime.GetUtcTime() < iDueTime.GetUtcTime()) //find earliest due time from all entries

 			{	

 			iDueTime = dueTime;

 			iValidityPeriod = entry->Info().ValidityPeriod();

 			}	 

 		}

 	}

 // if aCalculateForConditions is true then entrycount corresponds

 // to number of conditions;

 void CSchedule::GetInfo(TScheduleInfo& aInfo, TBool aCalculateForConditions) 

 	{

 	aInfo.iState.SetName(Name());

 	aInfo.iState.SetDueTime(iDueTime);

 	aInfo.iState.SetPersists(Persists());

 	aInfo.iState.SetEnabled(Enabled());

 	TInt taskCount = 0;

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

 	taskIter.SetToFirst();

 	while (taskIter++ != NULL)

 		{

 		taskCount++;

 		}

 	aInfo.iTaskCount = taskCount;

 	TInt entryCount = 0;

 	if(!aCalculateForConditions)

 		{

 		TSglQueIter<TScheduleEntry> entryIter(iEntryList);

 		entryIter.SetToFirst();

 		while (entryIter++ != NULL)

 			{

 			entryCount++;

 			}

 		}

 	else

 		entryCount = iConditions.Count();	

 	aInfo.iEntryCount = entryCount;

 	}

 const RArray<TTaskSchedulerCondition>& CSchedule::Conditions() const

 	{

 	return iConditions;

 	}

 TBool CSchedule::IsAccessAllowed(const RMessagePtr2& aMessage) const

 	{

 	// Access allowed if message SID is the same as the schedule creator

 	// or if client has WriteDeviceData

 	return aMessage.SecureId()==iSecurityInfo.iSecureId 

 		|| aMessage.HasCapability(ECapabilityWriteDeviceData)

 		|| PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement)==0; // Enforcement off

 	}

 const TSecurityInfo& CSchedule::SecurityInfo() const

 	{

 	return iSecurityInfo;

 	}

 TBool CSchedule::IsUpdatable()

 	{

 	if(HasTasks() && Enabled() )

 		return 	ETrue;	

 	else

 		return EFalse;	

 	}