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

 	}