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

 // class TScheduledTask

 // -a task which has been scheduled with a schedule

 // -maintains non-owning pointer to proxy for client which scheduled it

 // class CSchedule

 // -has >=1 entries, >=0 tasks

 // -when one of its entries is due, all its tasks are due

 // 

 //

 #ifndef __SCHEDULE_H__

 #define __SCHEDULE_H__

 // System includes

 #include <e32base.h>

 // Forward Declarations

 class CFileStore;

 class TStreamId;

 class TScheduleEntry;

 class TScheduleEntryInfo2;

 class TScheduleInfo;

 class TScheduledTask;

 class CScheduledTask;

 class CClientProxy;

 class TTaskInfo;

 class RWriteStream;

 class CConditionManager;

 class TTaskSchedulerCondition;

 //#include <schinfo.h>

 #include <schinfointernal.h>

 #include "CSCHCODE.H"	//opcodes

 /**

 Constants

 @internalComponent

 */

 const TInt KScheduleIdDifferential=10000;

 /**

 @internalComponent

 */

 class TScheduledTask

 	{

 public:

 	TScheduledTask(CScheduledTask& aTask, CClientProxy& iClient);

 	// ?? 

 	void OnDue(const TTsTime& iValidUntil);

 	// Access data

 	const HBufC& Data() const;

 	const TTaskInfo& Info() const;

 	const CClientProxy& Client() const;

 	// Ask client to remove & delete the TTaskInfo member

 	void RemoveInfo();

 	void DecRepeat();

 	// For queue support

 	static TInt Offset();

 private:

 	CScheduledTask& iTask;//doesn't own this: the client does

 	CClientProxy& iClient;//doesn't own this: CTaskScheduler owns all clients

 	TSglQueLink iLink;

 	};

 /**

 @internalComponent

 */

 NONSHARABLE_CLASS(CSchedule) : public CBase

 	{

 public:

 	static CSchedule* NewLC(TInt aHandle, 

 						const TDesC& aName, 

 						TBool aPersists,  

 						const CArrayFixFlat<TScheduleEntryInfo2>& aEntries,

 						const TSecurityInfo& aSecurityInfo);

 	static CSchedule* NewLC(TInt aHandle, 

 						const TDesC& aName, 

 						TBool aPersists,  

 						const CArrayFixFlat<TTaskSchedulerCondition>& aEntries,

 						const TTsTime& aDefaultRunTime,

 						const TSecurityInfo& aSecurityInfo);

 	static CSchedule* NewL(CFileStore& aStore, TStreamId& aId);

 	~CSchedule();

 private: 

 	void ConstructL(const TDesC& aName,

 					const CArrayFixFlat<TScheduleEntryInfo2>& aEntries);

 	void ConstructL(const TDesC& aName,

 					const CArrayFixFlat<TTaskSchedulerCondition>& aEntries,

 					const TTsTime& aDefaultRunTime);

 	void RestoreL(CFileStore& aStore, TStreamId& aId);

 	CSchedule();

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

 private:

 	void AddEntriesL(const CArrayFixFlat<TScheduleEntryInfo2>& aEntries);

 	TTsTime ValidUntil() const; //from base class

 	void AddConditionsL(const CArrayFixFlat<TTaskSchedulerCondition>& aConditions);

 public:

 	// externalize/internalize

 	void InternalizeL(RReadStream& aReadStream);

 	void ExternalizeL(RWriteStream& aWriteStream) const;

 	//call this whenever schedule becomes due: tells tasks they need to be executed 

 	void NotifyTasks();

 	// called whenever a schedule changes.  If aNotFirstTime = ETrue then this means

 	// the schedule has just run so we need a minor modification to the next due time calculation

 	void CalculateDueTime(TBool aNotFirstTime = EFalse);

 	//Time entries

 	void ReplaceEntriesL(const CArrayFixFlat<TScheduleEntryInfo2>& aEntries);

 	void EntriesL(CArrayFixFlat<TScheduleEntryInfo2>& aEntries);

 	void GetInfo(TScheduleInfo& aInfo, TBool aCalculateForConditions);

 	inline const TTsTime& DueTime() const;

 	//Condition entries

 	void ReplaceConditionsL(const CArrayFixFlat<TTaskSchedulerCondition>& aConditions);

 	void ConditionsL(CArrayFixFlat<TTaskSchedulerCondition>& aConditions);

 	const TTsTime& DefaultRunTimeL() const;

 	//editing

 	void AddTask(TScheduledTask& aTask);

 	void RemoveTask(TScheduledTask* aTask);

 	void RemoveTasks(TBool aFromClient);

 	TInt GenerateTaskId();

 	TScheduledTask* Task(const TInt aTaskId);

 	//accessors

 	void RemoveEntries();

 	void RemoveConditions();

 	TBool ClientInSchedule(const TDesC& aClientName);

 	inline TSglQue<TScheduledTask>* Tasks();

 	void TasksL(CArrayFixFlat<TTaskInfo>& aTasks);

 	inline TInt Id() const;

 	inline const TDesC& Name() const;

 	inline TBool Persists() const;

 	inline TBool Enabled() const;

 	inline void SetEnabled(TBool aEnabled);

 	inline TBool HasTasks() const;

 	inline TScheduleType Type() const;

 	const RArray<TTaskSchedulerCondition>& Conditions() const;

 	//security Info related stuff

 	TBool IsAccessAllowed(const RMessagePtr2& aMessage) const;

 	inline void CheckAccessAllowedL(const RMessagePtr2& aMessage) const;

 	const TSecurityInfo& SecurityInfo() const;

 	//list capability

 	static TInt Offset();

 	TBool IsUpdatable();

 private://data

 	TSglQueLink iLink;			//scheduler keeps all schedules in owning queue

 	TInt iId;

 	HBufC* iName;

 	TBool iPersists;

 	TBool iEnabled;

 	TTsTime iDueTime;

 	TTimeIntervalMinutes iValidityPeriod;

 	// list handling

 	RArray<TTaskSchedulerCondition> iConditions;

 	TSglQue<TScheduledTask> iTaskList;		//things which happen at those times	

 	mutable TSglQue<TScheduleEntry> iEntryList;	//list of times at which things happen

 	//Creating process SecurityInfo

 	TSecurityInfo iSecurityInfo;

 	};

 #include "SCHEDULE.INL"

 #endif