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

// Implements RScheduler functions: client-side session with the task scheduler

// 

//

#include "CSCH_CLI.H"	//definition of RScheduler

#include "CSCHCODE.H"	//opcodes

#include "SCHEXE.H"

#include <schinfointernal.h>

/** Default constructor. */

EXPORT_C RScheduler::RScheduler()

    {

    }

/** 

Connects a client to the Task Scheduler server, creating a session with that 

server.

@return KErrNone, if successful; otherwise one of the other system wide error 

codes. 

*/

EXPORT_C TInt RScheduler::Connect()

	{

	TInt r=CreateSession(KSchSvrName, Version(),0);

	if (r==KErrNotFound)

		{

		r=StartSch32();

		if (r!=KErrNone)

			return r;

		r=CreateSession(KSchSvrName, Version(),0);

	    }

	return(r); 

	}

/** 

Gets the client side version number.

@return The version number. 

*/

EXPORT_C TVersion RScheduler::Version() const

	{

	return(TVersion(KESchMajorVersionNumber,KESchMinorVersionNumber,KESchBuildVersionNumber));

	}

/** 

Registers a client with the Task Scheduler.

A client must register with the Task Scheduler before scheduling any tasks, 

but does not need to register just to create and edit schedules.

@param aFileName The name and full path of a program that encapsulates the 

client-specific knowledge for implementing tasks. On the emulator, the program 

should be a DLL; on an ARM processor, it should be an executable.

@param aPriority A priority value.

@return KErrNone, if successful; otherwise one of the other system wide error 

codes. 

*/

EXPORT_C TInt RScheduler::Register(const TFileName& aFileName,const TInt aPriority)

	{

	return SendReceive(ERegisterClient,TIpcArgs(&aFileName,aPriority));

	}

/** 

Creates a persistent time based schedule.

This schedule has no tasks associated with it but merely contains information

about start and finish times.

@capability WriteDeviceData

@param aRef Definition of the new schedule.  On return this contains a valid

handle to the newly created schedule.

@param aEntryList The set of schedule entries that make up the new schedule.

@return KErrNone, if successful, KErrArgument if the condition array is 

empty, or an entry has an interval less than 1, KErrServerBusy, if a backup or 

restore operation is taking place, KErrPermissionDenied if the client 

does not have WriteDeviceData capability. 

Otherwise one of the other system wide error codes.

@see TScheduleEntryInfo2

*/

EXPORT_C TInt RScheduler::CreatePersistentSchedule(TSchedulerItemRef& aRef, 

							const CArrayFixFlat<TScheduleEntryInfo2>& aEntryList)

	{

	TScheduleSettings2 settings;

	settings.iPersists = ETrue;

	settings.iEntryCount = aEntryList.Count();

	settings.iName = aRef.iName;

	return CreateSchedule(aRef, aEntryList, settings);

	}

/** 

Creates a persistent condition based schedule.

This schedule has no tasks associated with it but merely contains information

about conditions that must be satified to complete this schedule.

@capability WriteDeviceData

@param aRef Definition of the new schedule.  On return this contains a valid

handle to the newly created schedule.

@param aConditions An array of system agent conditons 

that make up the schedule.

@param aDefaultRunTime The time at which the schedule with run if no

conditions are met. If this is a local time based value, the schedule will remain

at that local time regardless of timezone and DST changes (ie. it will float)

If the value is UTC based, the schedule will remain at that UTC time (will not float).

@return KErrNone, if successful, KErrArgument if the condition array is 

empty or if the publish and subscribe variables have an invalid category, 

KErrServerBusy, if a backup or restore operation is taking place,

KErrPermissionDenied if the client does not have WriteDeviceData capability. 

Otherwise one of the other system wide error codes.

@see TTaskSchedulerCondition 

@internalAll

*/

EXPORT_C TInt RScheduler::CreatePersistentSchedule(TSchedulerItemRef& aRef, 

							const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,

							const TTsTime& aDefaultRunTime)

	{

	TScheduleSettings2 settings;

	settings.iPersists = ETrue;

	settings.iEntryCount = aConditions.Count();

	settings.iName = aRef.iName;

	return CreateSchedule(aRef, aConditions, aDefaultRunTime, settings);	

	}

static TBool ScheduleEntriesAreBad(const CArrayFixFlat<TScheduleEntryInfo2>& aEntries)

	{//must have at least 1 entry, each entry's interval must be at least 1

	TInt count = aEntries.Count();

	if (count==0)

		return ETrue;

	for (TInt i=0; i < count; i++)

		{

		const TScheduleEntryInfo2* entry = &(aEntries.At(i));

		if (entry->Interval() < 1)

			return ETrue;

		}

	return EFalse;

	}

TInt RScheduler::CreateSchedule(TSchedulerItemRef& aRef, 

			const CArrayFixFlat<TScheduleEntryInfo2>& aEntryList, 

			const TScheduleSettings2& aSettings)

	{//check critical aspects of input here (client-side)

	if (ScheduleEntriesAreBad(aEntryList))

		return KErrArgument;

	//write settings (entry count + persists flag + name)

	TPckgC<TScheduleSettings2> pSettings(aSettings);

	//write entries

	TPtrC8 pA((TUint8*)&aEntryList.At(0), sizeof(TScheduleEntryInfo2)*aSettings.iEntryCount); 

	//read back generated ID

	TPckg<TInt> id(aRef.iHandle);

	return SendReceive(ECreateTimeSchedule, TIpcArgs(&pSettings, &pA, &id));

	}

static TBool ScheduleEntriesAreBad(const CArrayFixFlat<TTaskSchedulerCondition>& aConditions)

	{//must have at least 1 condition in array. The category for a condition cannot be KNullUid.

	TInt count = aConditions.Count();

	if (count==0)

		return ETrue;

	for (TInt i=0; i < count; i++)

		{

		const TTaskSchedulerCondition* entry = &(aConditions.At(i));

		if (entry->iCategory == KNullUid)

			return ETrue;

		}

	return EFalse;

	}

TInt RScheduler::CreateSchedule(TSchedulerItemRef& aRef, 

			const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,

			const TTsTime& aDefaultRunTime, 

			const TScheduleSettings2& aSettings)

	{//check critical aspects of input here (client-side)

	if (ScheduleEntriesAreBad(aConditions))

		return KErrArgument;

	//write settings (entry count + persists flag + name)

	TPckgC<TScheduleSettings2> pSettings(aSettings);

	//write entries

	TPtrC8 pA((TUint8*)&aConditions.At(0), sizeof(TTaskSchedulerCondition)*aSettings.iEntryCount); 

	//write Time

	TPckgC<TTsTime> pTime(aDefaultRunTime);

	//read back generated ID

	TPckg<TInt> id(aRef.iHandle);

	return SendReceive(ECreateConditionSchedule, TIpcArgs(&pSettings, &pA, &pTime, &id));

	}

/** 

Changes a time based schedule.

Note that changing a schedule is implemented by supplying a replacement set 

of schedule entries.

@capability Note Only clients with the same SID as the schedule creator, or 

WriteDeviceData capability can sucessfully call this API.

@param aScheduleHandle The Id that identifies the schedule.

@param aEntryList The set of schedule entries that will make up the new schedule.

@return KErrNone if successful, KErrNotFound if there is no schedule with 

the specified Id, KErrArgument if the schedule is not a time based one, 

KErrPermissionDenied if the client does not have the same SID as the schedules

creator or has WriteDeviceData capability, KErrServerBusy, if a backup or 

restore operation is taking place or any of the other system wide error 

codes.

@see TScheduleEntryInfo2

*/

EXPORT_C TInt RScheduler::EditSchedule(const TInt aScheduleHandle, const CArrayFixFlat<TScheduleEntryInfo2>& aEntryList)

	{

	if (ScheduleEntriesAreBad(aEntryList))

		return KErrArgument;

	TInt count = aEntryList.Count();

	TPtrC8 pA((TUint8*) &aEntryList.At(0), sizeof(TScheduleEntryInfo2)*count);

	return SendReceive(EEditTimeSchedule, TIpcArgs(count, aScheduleHandle, &pA));

	}

/** 

Changes a condition based schedule.

Note that changing a schedule is implemented by supplying a replacement set 

of schedule conditons and time.

@capability Note Only clients with the same SID as the schedule creator, or 

WriteDeviceData capability can sucessfully call this API.

@param aScheduleHandle The Id that identifies the schedule.

@param aConditions An array of system agent conditons 

that make up the schedule.

@param aDefaultRunTime The time at which the schedule with run if no

conditions are met. If this is a local time based value, the schedule will remain

at that local time regardless of timezone and DST changes (ie. it will float)

If the value is UTC based, the schedule will remain at that UTC time (will not float).

@return KErrNone if successful, KErrNotFound if there is no schedule with 

the specified Id, KErrArgument if the schedule is not a condition based one

or if the publish and subscribe variables, defined by aConditions category 

and key values, do not exist or are not of integral type, 

KErrPermissionDenied if the client does not have the same SID as the schedules

creator or has WriteDeviceData capability, KErrServerBusy, if a backup or 

restore operation is taking place, or any of the other system wide error 

codes.

@internalAll

*/	

EXPORT_C TInt RScheduler::EditSchedule(TInt aScheduleHandle, 

						const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,

						const TTsTime& aDefaultRunTime)

	{

	TInt count = aConditions.Count();

	TPtrC8 pA((TUint8*) &aConditions.At(0), sizeof(TTaskSchedulerCondition)*count);

	//write Time

	TPckgC<TTsTime> pTime(aDefaultRunTime);

	return SendReceive(EEditConditionSchedule, TIpcArgs(count, aScheduleHandle, &pA, &pTime));	

	}

/** 

Deletes the specified schedule.

@capability Note Only clients with the same SID as the schedule creator, or 

WriteDeviceData capability can sucessfully call this API.

Note that a schedule cannot be deleted if there are tasks associated with 

it; the tasks must be explicitly deleted first.

@param aScheduleHandle The Id that identifies the schedule.

@return KErrNone if successful, KErrNotFound if there is no schedule with 

the specified Id, KErrArgument if there are outstanding tasks associated with 

the schedule, KErrPermissionDenied if the client does not have the same SID as 

the schedules creator or has WriteDeviceData capability, KErrServerBusy, if a 

backup or restore operation is taking place or any of the other 

system wide error codes.

*/

EXPORT_C TInt RScheduler::DeleteSchedule(const TInt aScheduleHandle) const

	{

	return SendReceive(EDeleteSchedule, TIpcArgs(aScheduleHandle));

	}

/** 

Disables the specified schedule.

@capability Note Only clients with the same SID as the schedule creator, or 

WriteDeviceData capability can sucessfully call this API.

@param aScheduleHandle The Id that identifies the schedule.

@return KErrNone if successful, KErrNotFound if there is no schedule with 

the specified Id, KErrPermissionDenied if the client does not have the same SID 

as the schedules creator or has WriteDeviceData capability, KErrServerBusy, if a 

backup or restore operation is taking place or any of the other 

system wide error codes.

*/

EXPORT_C TInt RScheduler::DisableSchedule(const TInt aScheduleHandle) const

	{

	return SendReceive(EDisableSchedule, TIpcArgs(aScheduleHandle));

	}

/** 

Enables the specified schedule.

@capability Note Only clients with the same SID as the schedule creator, or 

WriteDeviceData capability can sucessfully call this API.

@param aScheduleHandle The Id that identifies the schedule.

@return KErrNone if successful. KErrNotFound if there is no schedule with 

the specified Id, KErrPermissionDenied if the client does not have the same SID 

as the schedules creator or has WriteDeviceData capability, KErrServerBusy, if a 

backup or restore operation is taking place or any of the other 

system wide error codes.

*/

EXPORT_C TInt RScheduler::EnableSchedule(const TInt aScheduleHandle) const

	{

	return SendReceive(EEnableSchedule, TIpcArgs(aScheduleHandle));

	}

/** 

Adds a task to an existing persistent schedule.

Behaviour of execution after a Backup and Restore operation should be 

considered when adding tasks to a persistent schedule. Persistent schedules might be 

backed up when a one-off task might be pending, and become due and executed some time 

after the backup operation. When the backup is restored, the tasks might be executed 

again if they are still valid (restore done during the validation period for time-based 

schedules, or conditions satisfied after restore for condition-based schedules). Clients 

should refrain from creating tasks that might have undesired effects under these 

conditions (e.g. by incurring a cost to the user by sending an SMS twice). 

@capability Note Only clients with the same SID as the schedule creator, or 

WriteDeviceData capability can sucessfully call this API.

@param aTaskInfo Information about the task to be added to the schedule. On return

the task Id is written into this class.

@param aTaskData Data that is passed to the task on execution.

@param aScheduleHandle The Id that identifies the schedule to be used.

@return KErrNone if successful, KErrNotFound if there is no schedule with 

the specified Id, KErrArgument if a task with a repeat vale other than 0 is 

being tried to be assigned to a condition based schedule, 

KErrPermissionDenied if the client does not have the same SID as the schedules

creator or has WriteDeviceData capability, KErrServerBusy, if a backup or 

restore operation is taking place or any of the other system wide error 

codes.

@panic CTaskScheduler 0 The client has not registered. The client must register 

before adding tasks to the schedule. 

*/

EXPORT_C TInt RScheduler::ScheduleTask(TTaskInfo& aTaskInfo, 

									HBufC& aTaskData, 

									const TInt aScheduleHandle)

	{

	TPckgC<TTaskInfo> pI(aTaskInfo);

	//scheduler writes back task id

	TPckg<TInt> id(aTaskInfo.iTaskId);

	TPtr pD(aTaskData.Des());

	return SendReceive(EScheduleTask, TIpcArgs(&pI,aScheduleHandle,&id, &pD));

	}

/** 

Creates a new, transient, time based schedule and adds a task to it.

Note that a transient schedule is destroyed when the task is destroyed or 

power is lost.

@param aTaskInfo Information about the task to be added to the transient schedule. 

On return the task Id is written into this class.

@param aTaskData Data that is passed to the task on execution.

@param aRef Definition of the new transient schedule.

@param aEntryList The set of schedule entries that make up the new transient 

schedule.

@return KErrNone, if successful, or any of the other system wide error codes.

@panic CTaskScheduler 0 The client has not registered. The client must register 

before adding tasks to the schedule.

@see TScheduleEntryInfo2 

*/

EXPORT_C TInt RScheduler::ScheduleTask(TTaskInfo& aTaskInfo, 

									HBufC& aTaskData, 

									TSchedulerItemRef& aRef,

									const CArrayFixFlat<TScheduleEntryInfo2>& aEntryList)

	{

	TScheduleSettings2 settings;

	settings.iPersists = EFalse;

	settings.iEntryCount = aEntryList.Count();

	settings.iName = aRef.iName;

	TInt res = CreateSchedule(aRef, aEntryList, settings);

	if (res==KErrNone)

		{

		res = ScheduleTask(aTaskInfo, aTaskData, aRef.iHandle);

		//the schedule here needs a task: so if we can't schedule a task,

		//need to delete schedule

		if (res!=KErrNone)

			DeleteSchedule(aRef.iHandle);

		}

	return res;

	}

/** 

Creates a new, transient, condition based schedule and adds a task to it.

Note that a transient schedule is destroyed when the task is destroyed or

power is lost.

@param aTaskInfo Information about the task to be added to the transient schedule. 

On return the task Id is written into this class.

@param aTaskData Data that is passed to the task on execution.

@param aRef Definition of the new transient schedule.

@param aConditions An array of schedule conditons that make up the schedule.

@param aDefaultRunTime The time at which the schedule will run if no

conditions are met. If this is a local time based value, the schedule will remain

at that local time regardless of timezone and DST changes (ie. it will float)

If the value is UTC based, the schedule will remain at that UTC time (will not float).

@return KErrNone, if successful, KErrArgument if the publish and subscribe 

variables, defined by aConditions category and key values, do not exist or 

are not of integral type, or any of the other system wide error codes.

@panic CTaskScheduler 0 The client has not registered. The client must register 

before adding tasks to the schedule.

@internalAll

*/

EXPORT_C TInt RScheduler::ScheduleTask(TTaskInfo& aTaskInfo, 

								HBufC& aTaskData, 

								TSchedulerItemRef& aRef, 

								const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,

								const TTsTime& aDefaultRunTime)

	{

	TScheduleSettings2 settings;

	settings.iPersists = EFalse;

	settings.iEntryCount = aConditions.Count();

	settings.iName = aRef.iName;

	TInt res = CreateSchedule(aRef, aConditions, aDefaultRunTime, settings);

	if (res==KErrNone)

		{

		res = ScheduleTask(aTaskInfo, aTaskData, aRef.iHandle);

		//the schedule here needs a task: so if we can't schedule a task,

		//need to delete schedule

		if (res!=KErrNone)

			DeleteSchedule(aRef.iHandle);

		}

	return res;

	}

/** 

Deletes the specified task.

@capability Note Only clients with the same SID as the relevant schedule

creator, or WriteDeviceData capability can sucessfully call this API.

@param aTaskId The Id that identifies the task.

@return KErrNone if successful, KErrNotFound if there is no task with the 

specified Id, KErrPermissionDenied if the client does not have the same SID as 

the schedules creator or has WriteDeviceData capability, KErrServerBusy, if a 

backup or restore operation is taking place or any of the 

other system wide error codes.

*/

EXPORT_C TInt RScheduler::DeleteTask(const TInt aTaskId) const

	{

	return SendReceive(EDeleteTask, TIpcArgs(aTaskId));

	}

/** 

Gets a list of all schedules, or a subset of schedules.

@capability Note A call to this API will only retrieve schedules created with

the caller's SID.  If the caller has WriteDeviceData capability all schedules

will be retrieved.

@param aScheduleRefArray On return, a populated array of schedule definitions. 

Note that populating the array could cause this function to leave because 

of an out of memory condition.

@param aFilter The schedule filter.

@return KErrNone if successful otherwise one of the other system wide error 

codes.

@see TSchedulerItemRef 

*/

EXPORT_C TInt RScheduler::GetScheduleRefsL(CArrayFixFlat<TSchedulerItemRef>& aScheduleRefArray,

									const TScheduleFilter aFilter)

	{

	//1) get number of refs

	TInt count;//scheduler writes back count

	TPckg<TInt> pCount(count);

	TInt res = SendReceive(ECountSchedules, TIpcArgs(&pCount, aFilter));

	if (res!=KErrNone)

		return res;

	aScheduleRefArray.ResizeL(count);

	//2) get refs, if there are any

	if (count>0)

		{

		TPtr8 sPtr((TUint8*)&(aScheduleRefArray.At(0)), count*sizeof(TSchedulerItemRef));

		res = SendReceive(EGetScheduleRefs, TIpcArgs(count, aFilter, &sPtr));

		}

	return res;

	}

/** 

Gets information relating to a specified time based schedule.

@capability Note Only clients with the same SID as the schedule creator, or 

WriteDeviceData capability can sucessfully call this API.

@param aScheduleHandle The Id that identifies the schedule.

@param aState On return, the state of the specified schedule.

@param aEntries On return, a populated array of schedule entries that make 

up the schedule. Note that populating the array could cause this function 

to leave because of an out of memory condition.

@param aTasks On return, a populated array of tasks associated with the schedule. 

Note that populating the array could cause this function to leave because 

of an out of memory condition.

@param aDueTime On return, the time that the schedule is next due. This value may

be local time or UTC based,dependent on the type of time used for schedule entries.

Comparisons used within the scheduler to find the next due time are UTC based.

@return KErrNone if successful, KErrNotFound if there is no schedule with 

the specified Id, KErrArgument if the schedule is not a time based one, 

KErrPermissionDenied if the client does not have the same SID as the schedules

creator or has WriteDeviceData capability, or any of the other system wide error 

codes.

@see TScheduleEntryInfo2

@see TTaskInfo 

*/

EXPORT_C TInt RScheduler::GetScheduleL(const TInt aScheduleHandle, 

									TScheduleState2& aState,