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