--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/taskscheduler/SCHSVR/SCHTASK.CPP	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,275 @@
+// 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:
+//
+ 
+#include "SCHTASK.H"
+#include "taskfile.h"
+#include "SCHEXEC.H"
+#include <schinfointernal.h>
+
+/**
+Returns the index of the slot in the process environment data that contains the
+shared file server session (RFs) handle passed from the Task Scheduler.
+
+@return The index of the shared file server session handle
+@see RFile::AdoptFromCreator
+*/
+EXPORT_C TInt TScheduledTaskFile::FsHandleIndex()
+	{
+	return KTaskFsHandleIndex;
+	}
+
+/**
+Returns the index of the slot in the process environment data that contains the
+shared file (RFile) handle passed from the Task Scheduler.
+
+@return The index of the shared file handle
+@see RFile::AdoptFromCreator
+*/
+EXPORT_C TInt TScheduledTaskFile::FileHandleIndex()
+	{
+	return KTaskFileHandleIndex;
+	}
+
+/** Creates the object from the specified stream.
+
+@param aStream The stream containing the external representation of this object.
+@return A new instance of a CScheduledTask object. */
+EXPORT_C CScheduledTask* CScheduledTask::NewLC(RReadStream& aStream)
+	{
+	CScheduledTask* self = new(ELeave) CScheduledTask;
+	CleanupStack::PushL(self);
+	self->InternalizeL(aStream);
+	return self;
+	}
+
+CScheduledTask::CScheduledTask()
+	{
+	}
+/**
+@internalComponent
+*/
+CScheduledTask::CScheduledTask(TTaskInfo& aInfo, 
+								HBufC* aData, 
+								TScheduleType aScheduleType,
+								const TSecurityInfo& aSecurityInfo)
+:	iInfo(aInfo), 
+	iData(aData),
+	iScheduleType(aScheduleType),
+	iSecurityInfo(aSecurityInfo)
+	{
+	iPLink.iPriority = aInfo.iPriority;
+	}
+
+CScheduledTask::~CScheduledTask()
+	{
+	delete iData;
+	}
+/**
+Remove from queue
+@internalComponent only used by server
+*/
+void CScheduledTask::Remove()
+	{
+	iPLink.Deque();
+	}
+
+/**
+queue offset
+@internalComponent only used by server
+*/
+TInt CScheduledTask::Offset()
+	{
+	return (_FOFF(CScheduledTask,iPLink));
+	}
+
+
+/** Gets the detailed information for the task.
+
+@return Detailed information about a task. */
+EXPORT_C const TTaskInfo& CScheduledTask::Info() const 
+	{
+	return iInfo;
+	}
+	
+/** Gets a reference to the data to be passed to the program on execution.
+
+@return A reference to the descriptor containing the data. */
+EXPORT_C const HBufC& CScheduledTask::Data() const
+	{
+	return *iData;
+	}
+
+/** Gets the time when the task stops being valid.
+
+If the executing program determines that this time is in the past, then it 
+should not run the task.
+
+@return The time when the task stops being valid */
+EXPORT_C const TTsTime& CScheduledTask::ValidUntil() const
+	{
+	return iValidUntil;
+	}
+
+/**
+Gets the schedules type.
+*/	
+EXPORT_C TScheduleType CScheduledTask::ScheduleType() const
+	{
+	return iScheduleType;
+	}
+
+/**
+Gets the security information for this scheduled task.  This information
+is the securityID, VenforID and capabilities of the client who created
+the schedule responsible for invoking this task.
+*/
+EXPORT_C const TSecurityInfo& CScheduledTask::SecurityInfo() const
+	{
+	return iSecurityInfo;
+	}
+		
+/**
+Is this task due?
+@internalComponent only used by server
+*/
+TBool CScheduledTask::Due() const
+	{
+	return iDue;
+	}
+
+/**
+Decrement repeat counter
+@internalComponent only used by server
+*/
+void CScheduledTask::DecRepeat()
+	{
+	iInfo.iRepeat--;
+	}
+
+/**
+Set due flag.
+@internalComponent only used by server
+*/
+void CScheduledTask::SetDue(TBool aDue)
+	{
+	iDue = aDue;
+	}
+
+/**
+Mark task as being due.
+@param aValidUntil time this task will be valid until. 
+This information will be passed to the registered executable, 
+so they may check whether the task should still be executed.
+@internalComponent only used by server
+*/
+void CScheduledTask::OnDue(const TTsTime& aValidUntil)
+	{
+	iValidUntil = aValidUntil;
+	iDue = ETrue;
+	}
+
+/**
+Return flag that determines if task is transisent or persistent.
+@internalComponent only used by server
+*/	
+TBool CScheduledTask::Persists() const
+	{return iPersists;}
+
+/**
+Mark task as belonging to a persistent schedule.
+@internalComponent only used by server
+*/	
+void CScheduledTask::SetPersists()
+	{iPersists = ETrue;}
+	
+/**
+externalize data to stream.
+@internalComponent only used by server
+*/
+void CScheduledTask::ExternalizeL(RWriteStream& aStream) const
+	{
+	aStream << *iData;
+	aStream << iValidUntil; 
+	aStream << iInfo;
+	aStream.WriteInt32L(iScheduleId);
+	aStream.WriteInt32L(iScheduleType);
+	aStream << iSecurityInfo;
+	aStream.WriteInt32L(iPersists);
+	}
+
+void CScheduledTask::InternalizeL(RReadStream& aStream)
+	{
+	iData = HBufC::NewL(aStream, KMaxTInt);
+	aStream >> iValidUntil;
+	aStream >> iInfo;
+	iScheduleId = aStream.ReadInt32L();
+	iScheduleType = static_cast<TScheduleType>(aStream.ReadInt32L());
+	aStream >> iSecurityInfo;
+	iPersists = aStream.ReadInt32L();;	
+	}
+
+/**
+Gets the schedulesID
+@internalComponent only used by server
+*/
+TInt CScheduledTask::ScheduleId() const
+	{
+	return iScheduleId;
+	}
+
+/**
+Sets the schedules ID
+@internalComponent only used by server
+*/
+void CScheduledTask::SetScheduleId(TInt aScheduleId)
+	{
+	iScheduleId = aScheduleId;
+	}
+
+	
+// Streaming operators for TSecurityInfo	
+RWriteStream& operator<<(RWriteStream& aWriteStream, 
+						const TSecurityInfo& aSecurityInfo)
+	{
+	//write security policy
+	aWriteStream.WriteUint32L(aSecurityInfo.iSecureId);
+	aWriteStream.WriteUint32L(aSecurityInfo.iVendorId);
+	// write capabilities by looping through all available
+	for (TUint jj = 0; jj < ECapability_Limit; ++jj)
+		if(aSecurityInfo.iCaps.HasCapability((TCapability)jj))
+			aWriteStream.WriteUint8L(jj);
+	aWriteStream.WriteUint8L(ECapability_HardLimit); // terminate capabilities with hard limit
+	return aWriteStream;
+	}
+
+RReadStream& operator>>(RReadStream& aReadStream,
+						TSecurityInfo& aSecurityInfo)
+	{
+	
+	aSecurityInfo.iSecureId = aReadStream.ReadUint32L();
+	aSecurityInfo.iVendorId = aReadStream.ReadUint32L();
+	aSecurityInfo.iCaps.SetEmpty();
+	TCapability cap = ECapability_None; 
+	aSecurityInfo.iCaps.AddCapability(cap);		
+	while (cap != ECapability_HardLimit )
+		{
+		aSecurityInfo.iCaps.AddCapability(cap);
+		cap = (TCapability)aReadStream.ReadUint8L();
+		}
+	return aReadStream;		
+	}	
+
+
+