--- /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;
+ }
+
+
+