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

//

// User includes

#include "SSCH_STD.H"

#include "CSCHCODE.H"

#include "SCHCLI.H"

#include "SchLogger.h"

#include "SCHMAN.H"

#include "SCHEDULE.H"

#include <schtask.h>

// Constants

const TInt KSchedulerArrayGranularity = 1; 

_LIT(KSchedulerPanic, "Task Scheduler");

void PanicClient(TInt aPanic, const RMessage2& aMessage)

//

// Toast the client

//

	{

	//Note that panic also completes the message so don't complete anywhere else

	aMessage.Panic(KSchedulerPanic,aPanic);

	}

CSchSession::CSchSession(CTaskScheduler& aScheduler)

//

// C'Tor - must pass client to CSession

//

	:	CSession2(), 

		iTaskScheduler(&aScheduler), 

		iClient(NULL)

	{

	}

CSchSession::~CSchSession()

	{

	if (iClient)

		{

		iClient->DecUsers();

		if (!iClient->Users())

			{

			iClient->Remove();

			delete iClient;

			iClient = NULL;

			}

		}

	if(!iPendingNotification.IsNull())

		iPendingNotification.Complete(KErrCancel);	

	}

void CSchSession::ServiceError(const RMessage2& aMessage,TInt aError)

//

// Handle an error or leave from CMySession::ServiceL()

// A bad descriptor error implies a badly programmed client, so panic it;

// otherwise use the default handling (report the error to the client)

//

	{

	if (aError==KErrBadDescriptor)

		PanicClient(EPanicBadDescriptor,aMessage);

	CSession2::ServiceError(aMessage,aError);

	}

void CSchSession::ServiceL(const RMessage2& aMessage)

//

//	Handle messages for this session.

//	all API functions are synchronous so complete here too

//

	{

	iClientMessage = BSUL::CClientMessage::NewL(aMessage);

	//Validate the message

	TRAPD(error, iClientMessage->ValidateL());

	if(error == KErrNone)

		{

		TRAP(error, DoServiceL());

		}

   	// don't complete message if we have paniced client (ie message is NULL)

   	iClientMessage->CompleteRequestL(error);

   	delete iClientMessage;

   	iClientMessage = NULL;   	

	}

void CSchSession::DoServiceL()

//

//	Handle messages for this session.

//	all API functions are synchronous so complete here too

//

	{

	switch (iClientMessage->Function())

		{

#if defined (_DEBUG)

	case ESchDbgMarkHeap:

		__UHEAP_MARK;

		break;

	case ESchDbgCheckHeap:

		__UHEAP_CHECK(iClientMessage->GetIntL(0));

		break;

	case ESchDbgMarkEnd:

		{

		TInt count = iClientMessage->GetIntL(0);

		//Three allocations are made for this message so add 3 to count

		//CClientMessage::NewL

		//CIntParameter::NewL

		//RPointerArray::AppendL	

		__UHEAP_MARKENDC(count + 3);

		}

		break;

	case ESchDbgFailNext:

		__UHEAP_FAILNEXT(iClientMessage->GetIntL(0));

		break;

	case ESchDbgResetHeap:

		__UHEAP_RESET;

		break;

	case ESchFaultServer:

		{

		// make sure we complete the message first before Killing this server

		iClientMessage->CompleteRequestL(KErrNone);

		RProcess().Kill(0);

		return;

		}

#endif

    case ERegisterClient:

		RegisterClientL();

    	break;

	case ECreateTimeSchedule:

		CreateTimeScheduleL();

    	break;

	case ECreateConditionSchedule:

		CreateConditionScheduleL();

    	break;

	case EScheduleTask:

		ScheduleTaskL();

    	break;

	case EDeleteTask:

		DeleteTaskL();

		break;

	case EDeleteSchedule:

		{

		CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(0));

		CheckPersistsInBackupL(*schedule);

		//check that user has permission to delete this schedule.

		schedule->CheckAccessAllowedL(iClientMessage->Message());

		iTaskScheduler->RemoveScheduleL(iClientMessage->GetIntL(0));

    	break;

		}

	case EDisableSchedule:

		{

		CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(0));

		CheckPersistsInBackupL(*schedule);

		//check that user has permission to disable this schedule.

		schedule->CheckAccessAllowedL(iClientMessage->Message());

		iTaskScheduler->DisableScheduleL(iClientMessage->GetIntL(0));

    	break;

		}

	case EEnableSchedule:

		{

		CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(0));

		CheckPersistsInBackupL(*schedule);

		//check that user has permission to enable this schedule.

		schedule->CheckAccessAllowedL(iClientMessage->Message());

		iTaskScheduler->EnableScheduleL(iClientMessage->GetIntL(0));

    	break;

		}

	case EEditTimeSchedule:

		EditTimeScheduleL();

    	break;

	case EEditConditionSchedule:

		EditConditionScheduleL();

    	break;

	case EGetScheduleRefs:

		GetScheduleRefsL();

		break;

	case ECountSchedules:

		CountSchedulesL();

		break;

	case EGetScheduleInfo:

		GetScheduleInfoL();

		break;

	case EGetTimeScheduleData:

		GetTimeScheduleDataL();

		break;

	case EGetConditionScheduleData:

		GetConditionScheduleDataL();

		break;

	case EGetTaskData:

		GetTaskDataL();

		break;

	case EGetTaskRefs:

		GetTaskRefsL();

    	break;	

	case ECountTasks:

		CountTasksL();

		break;

	case EGetTask:

		GetTaskInfoL();

		break;

	case EGetSchedulerItemRefAndNextDueTime:

		GetScheduleItemRefAndDueTimeL();

		break;

	case EGetTaskDataSize:

		GetTaskDataSizeL();

		break;

	case EGetScheduleType:

		GetScheduleTypeL();

		break;

	default:

		User::Leave(EPanicIllegalFunction);

		break;

        }//switch 

	}

//private functions

void CSchSession::RegisterClientL()

	{

	TFileName writeBuf;

	iClientMessage->ReadL(0,writeBuf);

	// should return existing client if there is one

	CClientProxy* client = iTaskScheduler->AddClientL(writeBuf, iClientMessage->GetIntL(1));

	client->IncUsers();

	if	(iClient)

		{

		iClient->DecUsers();

		if	(!iClient->Users())

			{

			LOGSTRING2("CSchSession::RegisterClientL - removing existing client %S", &iClient->ExecutorFileName());

			iClient->Remove();

			delete iClient;

			}

		}

	iClient = client;

	}

void CSchSession::CreateTimeScheduleL()

	{

	// get settings

	TScheduleSettings2 settings;

	TPScheduleSettings pS(settings);

	iClientMessage->ReadL(0, pS);

	//WriteDeviceData needed to create persistent schedules

	if(settings.iPersists)

		{

		// backup or restore in progress, so don't allow functions that might write to store

		if (iTaskScheduler->BUROperationInProgress() != EBUROperationNoActivity)

			{

			User::Leave(KErrServerBusy);

			}

		CheckCapabilityL();

		}	

	//Verify that the length of the condition list passed in is as expected

	if(iClientMessage->GetDesLengthL(1) != 

				(settings.iEntryCount * sizeof(TScheduleEntryInfo2)))

		{

		User::Leave(KErrBadDescriptor);

		}

	// get entries

	CArrayFixFlat<TScheduleEntryInfo2>* entries 

		= new(ELeave) CArrayFixFlat<TScheduleEntryInfo2>(settings.iEntryCount);

	CleanupStack::PushL(entries);

	entries->ResizeL(settings.iEntryCount);

	TPtr8 entriesPtr(REINTERPRET_CAST(TUint8*,&(entries->At(0))), settings.iEntryCount * sizeof(TScheduleEntryInfo2));

	iClientMessage->ReadL(1, entriesPtr);

	// create schedule

	const TInt handle = iTaskScheduler->GenerateId();

	if	(handle == KErrOverflow)

		User::Leave(KErrOverflow);

	// write back ID

	TPInt id(handle);

	iClientMessage->WriteL(2,id);

	// get security info

	TSecurityInfo securityInfo(iClientMessage->Message());	

	// Create schedule and add to scheduler

	CSchedule* newschedule = CSchedule::NewLC(handle, 

										settings.iName, 

										settings.iPersists, 

										*entries,

										securityInfo);

	iTaskScheduler->AddScheduleL(*newschedule);

	CleanupStack::Pop(newschedule);

	CleanupStack::PopAndDestroy(entries);

	}

void CSchSession::CreateConditionScheduleL()

	{

	// get settings

	TScheduleSettings2 settings;

	TPScheduleSettings pS(settings);

	iClientMessage->ReadL(0, pS);

	//WriteDeviceData needed to create persistent schedules

	if(settings.iPersists)

		{

		// backup or restore in progress, so don't allow functions that might write to store

		if (iTaskScheduler->BUROperationInProgress() != EBUROperationNoActivity)

			{

			User::Leave(KErrServerBusy);

			}

		CheckCapabilityL();

		}

	//Verify that the length of the condition list passed in is as expected

	if(iClientMessage->GetDesLengthL(1) != 

				(settings.iEntryCount * sizeof(TTaskSchedulerCondition)))

		{

		User::Leave(KErrBadDescriptor);

		}

	// get entries

	CArrayFixFlat<TTaskSchedulerCondition>* entries 

		= new(ELeave) CArrayFixFlat<TTaskSchedulerCondition>(settings.iEntryCount);

	CleanupStack::PushL(entries);

	entries->ResizeL(settings.iEntryCount);

	TPtr8 entriesPtr(REINTERPRET_CAST(TUint8*,&(entries->At(0))), settings.iEntryCount * sizeof(TTaskSchedulerCondition));

	iClientMessage->ReadL(1, entriesPtr);

	// get time

	TTsTime defaultRunTime;

	TPckg<TTsTime> pTime(defaultRunTime);

	iClientMessage->ReadL(2, pTime);

	// create schedule

	const TInt handle = iTaskScheduler->GenerateId();

	if	(handle == KErrOverflow)

		User::Leave(KErrOverflow);

	// write back ID

	TPInt id(handle);

	iClientMessage->WriteL(3,id);

	// get security info

	TSecurityInfo securityInfo(iClientMessage->Message());	

	// Create schedule and add to scheduler

	CSchedule* newschedule 

		= CSchedule::NewLC(handle, 

							settings.iName, 

							settings.iPersists, 

							*entries,

							defaultRunTime,

							securityInfo);

	iTaskScheduler->AddScheduleL(*newschedule);

	CleanupStack::Pop(newschedule);

	CleanupStack::PopAndDestroy(entries);

	}

void CSchSession::EditTimeScheduleL()

	{

	CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(1));

	CheckPersistsInBackupL(*schedule);

	//check that user has permission to edit this schedule.

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	//check that this is a time schedule!

	if(schedule->Type() != ETimeSchedule)

		User::Leave(KErrArgument);

	// Get entry count

	const TInt count = iClientMessage->GetIntL(0);

	//Verify that the length of the condition list passed in is as expected

	if(iClientMessage->GetDesLengthL(2) != (count * sizeof(TScheduleEntryInfo2)))

		{

		User::Leave(KErrBadDescriptor);

		}

	// Get new entry list

	CArrayFixFlat<TScheduleEntryInfo2>* entries 

		= new(ELeave) CArrayFixFlat<TScheduleEntryInfo2> (KSchedulerArrayGranularity);	

	CleanupStack::PushL(entries);

	entries->ResizeL(count);

	TPtr8 entriesPtr(REINTERPRET_CAST(TUint8*, &(entries->At(0))), count*sizeof(TScheduleEntryInfo2));

	iClientMessage->ReadL(2, entriesPtr);

	// Give it to scheduler along with schedule id

	iTaskScheduler->EditScheduleL(iClientMessage->GetIntL(1), *entries);

	CleanupStack::PopAndDestroy(entries);

	}

void CSchSession::EditConditionScheduleL()

	{

	CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(1));

	CheckPersistsInBackupL(*schedule);

	//check that user has permission to edit this schedule.

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	//check that this is a condition schedule!

	if(schedule->Type() != EConditionSchedule)

		User::Leave(KErrArgument);

	// Get entry count

	const TInt count = iClientMessage->GetIntL(0);

	//Verify that the length of the condition list passed in is as expected

	if(iClientMessage->GetDesLengthL(2) != (count * sizeof(TTaskSchedulerCondition)))

		{

		User::Leave(KErrBadDescriptor);

		}

	// Get new entry list

	CArrayFixFlat<TTaskSchedulerCondition>* entries 

		= new(ELeave) CArrayFixFlat<TTaskSchedulerCondition> (KSchedulerArrayGranularity);	

	CleanupStack::PushL(entries);

	entries->ResizeL(count);

	TPtr8 entriesPtr(REINTERPRET_CAST(TUint8*, &(entries->At(0))), count*sizeof(TTaskSchedulerCondition));

	iClientMessage->ReadL(2, entriesPtr);

	// get time

	TTsTime defaultRunTime;

	TPckg<TTsTime> pTime(defaultRunTime);

	iClientMessage->ReadL(3, pTime);

	// Give it to scheduler along with schedule id

	iTaskScheduler->EditScheduleL(iClientMessage->GetIntL(1), *entries, defaultRunTime);

	CleanupStack::PopAndDestroy(entries);

	}

void CSchSession::ScheduleTaskL()

	{

	// If client is registered, it is allowed to schedule tasks

	if(iClient != NULL)

		{

		TTaskInfo taskInfo;

		TPTaskInfo pI(taskInfo);

		iClientMessage->ReadL(0, pI);

		CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(1));

		CheckPersistsInBackupL(*schedule);

		//check that user has permission to schedule a task using this schedule.

		schedule->CheckAccessAllowedL(iClientMessage->Message());

		taskInfo.iTaskId = schedule->GenerateTaskId();

		if (taskInfo.iTaskId == KErrOverflow)

			{

			User::Leave(KErrOverflow);

			}

		// panic client if this is a condition schedule and client is asking for 

		// repeats.  This doesnt make sense.	

		if (schedule->Type() == EConditionSchedule && taskInfo.iRepeat != 0)

			User::Leave(KErrArgument); 

		// Create a new scheduled task with associated task data

		TInt len = iClientMessage->GetDesLengthL(3);

		HBufC* taskdata = HBufC::NewLC(len);

		TPtr pData(taskdata->Des());

		iClientMessage->ReadL(3, pData);	

		CScheduledTask* newTask = new(ELeave) CScheduledTask(taskInfo, 

											taskdata, 

											schedule->Type(), 

											schedule->SecurityInfo());

		CleanupStack::Pop(taskdata); //taskdata now owned by newTask

		CleanupStack::PushL(newTask);

		// Have to store the associated task, so that in the case where the

		// tasks need to be restored from a backup, we can ensure that the

		// task is associated with the correct schedule.

		newTask->SetScheduleId(schedule->Id());

		//If the schedule that the task is associated with is persistent then set the flag

		if(schedule->Persists())

			{

			newTask->SetPersists();

			}

		LOGSTRING("CSchSession::ScheduleTaskL - writing back task id to client");

		TPInt id(taskInfo.iTaskId);

		iClientMessage->WriteL(2,id);

		TScheduledTask* task = new(ELeave) TScheduledTask(*newTask,*iClient);

		// Now that task has been created sucessfully, we can add newTask to Client

		iClient->AddTask(*newTask); // task info is owned by client: schedule just keeps a reference

		CleanupStack::Pop(newTask);

		schedule->AddTask(*task);	//add new task - its now owned by schedule

		LOGSTRING("CSchSession::ScheduleTaskL - scheduling task with task scheduler");

		// If this leaves we need to still remove task from client and schedule. 

		// No easy way to do this via CleanupStack

		TRAPD(err, iTaskScheduler->ScheduleTaskL(*schedule, *iClient));

		if(err)

			{

			schedule->RemoveTask(task);

			iClient->RemoveTask(newTask);

			User::Leave(err);	

			}

		}

	else

		//Client hasnt been registered so it isn't allowed to schedule task, panic client

		{

		iClientMessage->PanicClient(KSchedulerPanic,EPanicNotRegistered);

		}

	}

void CSchSession::DeleteTaskL()

	{

	const TInt taskId = iClientMessage->GetIntL(0);

	const TInt scheduleId = (taskId/KScheduleIdDifferential)*KScheduleIdDifferential;

	//check that user has permission to delete a task using this schedule.

	CSchedule* schedule = iTaskScheduler->FindL(scheduleId);

	CheckPersistsInBackupL(*schedule);

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	iTaskScheduler->DeleteTaskL(scheduleId, taskId);

	}

//retrieval functions

void CSchSession::CountSchedulesL()

	{

	TScheduleFilter filter = STATIC_CAST(TScheduleFilter, iClientMessage->GetIntL(1));

	//GetScheduleRefs filters on clients schedule permssion as well.

	TInt count = iTaskScheduler->GetScheduleRefsL(NULL,filter, iClientMessage->Message());

	TPInt pCount(count);

	iClientMessage->WriteL(0,pCount);

	}

void CSchSession::GetScheduleRefsL()

	{

	//client calls CountSchedules() first to get expected count. still 

	//need to check it's valid though...

	const TInt expectedCount = iClientMessage->GetIntL(0);

	TScheduleFilter filter = STATIC_CAST(TScheduleFilter, iClientMessage->GetIntL(1));

	CArrayFixFlat<TSchedulerItemRef>* refArray 

		= new(ELeave) CArrayFixFlat<TSchedulerItemRef>(KSchedulerArrayGranularity);

	CleanupStack::PushL(refArray);

	//GetScheduleRefs filters on clients schedule permssion as well.

	TInt count = iTaskScheduler->GetScheduleRefsL(refArray, filter, iClientMessage->Message());

	if	((expectedCount<count) || (count == 0))

		User::Leave(KErrArgument);

	TPtrC8 pS(REINTERPRET_CAST(TUint8*, &refArray->At(0)),sizeof(TSchedulerItemRef)*expectedCount);

	iClientMessage->WriteL(2, pS);

	CleanupStack::PopAndDestroy();//info array

	}

void CSchSession::GetTimeScheduleDataL()

	{

	//client input:handle at info at aMessage.Int0()

	//info at aMessage.Ptr1()

	//info contains: exepcted entry count

	//scheduler output: entries at aM.Ptr2()

	TInt handle = iClientMessage->GetIntL(0);

	TScheduleInfo info;

	TPScheduleInfo pS(info);

	iClientMessage->ReadL(1, pS);

	CSchedule* schedule = iTaskScheduler->FindL(handle);

	//check that user has permission to get this schedules info.

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	if (schedule->Type() != ETimeSchedule)

		User::Leave(KErrArgument); //calling wrong API

	CArrayFixFlat<TScheduleEntryInfo2>* entries 

		= new(ELeave) CArrayFixFlat<TScheduleEntryInfo2> (KSchedulerArrayGranularity);

	CleanupStack::PushL(entries);

	schedule->EntriesL(*entries);

	if ((entries->Count())!=info.iEntryCount)

		User::Leave(KErrArgument);

	//write entries

	TPtrC8 pE(REINTERPRET_CAST(TUint8*, &entries->At(0)),sizeof(TScheduleEntryInfo2)*info.iEntryCount);

	iClientMessage->WriteL(2, pE);	

	CleanupStack::PopAndDestroy(entries);//entry array

	}

void CSchSession::GetConditionScheduleDataL()

	{

	//client input:handle at info at aMessage.Int0()

	//info at aMessage.Ptr1()

	//info contains: exepcted entry count

	//scheduler output: entries at aM.Ptr2()

	TInt handle = iClientMessage->GetIntL(0);

	TScheduleInfo info;

	TPScheduleInfo pS(info);

	iClientMessage->ReadL(1, pS);

	CSchedule* schedule = iTaskScheduler->FindL(handle);

	//check that user has permission to get this schedules info.

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	if (schedule->Type() != EConditionSchedule)

		User::Leave(KErrArgument); //calling wrong API

	CArrayFixFlat<TTaskSchedulerCondition>* conditions 

		= new(ELeave) CArrayFixFlat<TTaskSchedulerCondition> (KSchedulerArrayGranularity);

	CleanupStack::PushL(conditions);

	schedule->ConditionsL(*conditions);

	if ((conditions->Count())!=info.iEntryCount)

		User::Leave(KErrArgument);

	//write entries

	TPtrC8 pE(REINTERPRET_CAST(TUint8*, &conditions->At(0)),sizeof(TTaskSchedulerCondition)*info.iEntryCount);

	iClientMessage->WriteL(2, pE);	

	//write time

	TTsTime defaultTime(schedule->DefaultRunTimeL());

	TPBTime pDefaultTime(defaultTime);

	iClientMessage->WriteL(3, pDefaultTime);

	CleanupStack::PopAndDestroy(conditions);//condition array

	}

void CSchSession::GetScheduleTypeL()

	{

	TScheduleType type;

	TInt handle = iClientMessage->GetIntL(0);

	CSchedule* schedule = iTaskScheduler->FindL(handle);

	//check that user has permission to get this schedules info.

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	type = schedule->Type();	

	TPInt pType(type);

	iClientMessage->WriteL(1,pType);

	}

void CSchSession::GetTaskDataL()

	{//client input:handle at info at aMessage.Int0()

	//info at aMessage.Ptr1()

	//info contains: exepcted entry count, expected task count

	//scheduler output: tasks at aM.Ptr2()

	TInt handle = iClientMessage->GetIntL(0);

	TScheduleInfo info;

	TPScheduleInfo pS(info);

	iClientMessage->ReadL(1, pS);

	CSchedule* schedule = iTaskScheduler->FindL(handle);

	//check that user has permission to get this task info (based on owning

	// schedules info).

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	CArrayFixFlat<TTaskInfo>* tasks 

		= new(ELeave) CArrayFixFlat<TTaskInfo> (KSchedulerArrayGranularity);

	CleanupStack::PushL(tasks);

	schedule->TasksL(*tasks);

	if ((tasks->Count())!=info.iTaskCount)

		User::Leave(KErrArgument);

	//write tasks if there are any

	if (info.iTaskCount>0)

		{

		TPtrC8 pT(REINTERPRET_CAST(TUint8*, &tasks->At(0)),sizeof(TTaskInfo)*info.iTaskCount);

		iClientMessage->WriteL(2, pT);	

		}

	CleanupStack::PopAndDestroy(tasks);//task array

	}

void CSchSession::GetScheduleInfoL()

	{

	CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(0));

	//check that user has permission to get this schedules info.

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	TScheduleInfo info;

	if (schedule->Type() == ETimeSchedule)

		schedule->GetInfo(info, EFalse);

	else

		schedule->GetInfo(info, ETrue);

	TPBScheduleInfo pInfo(info);

	iClientMessage->WriteL(1, pInfo);

	TTsTime dueTime(schedule->DueTime());

	TPBTime pDueTime(dueTime);

	iClientMessage->WriteL(2, pDueTime);

	}

void CSchSession::GetTaskRefsL()

	{

	//taskrefs for all, 

	//or just the ones I scheduled, 

	//or just the pending ones, 

	//or just the pending ones I scheduled

	TInt expectedCount = iClientMessage->GetIntL(0);

	TScheduleFilter sFilter = STATIC_CAST(TScheduleFilter, iClientMessage->GetIntL(1));

	TTaskFilter tFilter = STATIC_CAST(TTaskFilter, iClientMessage->GetIntL(2));

	CArrayFixFlat<TSchedulerItemRef>* refs 

		= new (ELeave) CArrayFixFlat<TSchedulerItemRef> (KSchedulerArrayGranularity);

	CleanupStack::PushL(refs);

	//GetTaskRefs filters on clients schedule permssion as well.

	TInt actualCount = iTaskScheduler->GetTaskRefsL(refs, sFilter, tFilter,iClient, iClientMessage->Message());

	// Must find enough tasks.

	if((actualCount != expectedCount) || (refs->Count() == 0))

		User::Leave(KErrArgument);

	// Write array back to client

	TPtrC8 pR(REINTERPRET_CAST(TUint8*,&refs->At(0)),sizeof(TSchedulerItemRef)*expectedCount);

	iClientMessage->WriteL(3, pR);

	CleanupStack::PopAndDestroy();//refs

	}

void CSchSession::CountTasksL()

	{

	//count either all of 'em or just mine

	TScheduleFilter sFilter = STATIC_CAST(TScheduleFilter, iClientMessage->GetIntL(1));

	TTaskFilter tFilter = STATIC_CAST(TTaskFilter, iClientMessage->GetIntL(2));

	//GetTaskRefs filters on clients schedule permssion as well.

	TInt count = iTaskScheduler->GetTaskRefsL(NULL, sFilter, tFilter,iClient, iClientMessage->Message());

	TPInt pCount(count);

	iClientMessage->WriteL(0,pCount);

	}

void CSchSession::GetTaskInfoL()

	{

	// Get task

	TInt taskId				= iClientMessage->GetIntL(0);

	TInt scheduleId			= (taskId/KScheduleIdDifferential)*KScheduleIdDifferential;

	CSchedule* schedule		= iTaskScheduler->FindL(scheduleId);

	//check that user has permission to get this task info (based on owning 

	//schedules info).

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	TScheduledTask* task = schedule->Task(taskId);

	if	(!task)

		User::Leave(KErrNotFound);

	TPBTaskInfo pI(task->Info());

	iClientMessage->WriteL(1, pI);//write info	

	// If there isn't enough room to hold the task data in the client buffer then

	// indicate by returning KErrArgument

	TInt clientBufferSize = iClientMessage->GetIntL(2);

	if	(clientBufferSize < task->Data().Length())

		User::Leave(KErrArgument);

	iClientMessage->WriteL(3, task->Data());

	}

void CSchSession::GetScheduleItemRefAndDueTimeL()

	{

	// Get CSchedule object

	TInt taskId = iClientMessage->GetIntL(0);

	TInt scheduleId = (taskId/KScheduleIdDifferential)*KScheduleIdDifferential;

	CSchedule* schedule = iTaskScheduler->FindL(scheduleId);

	//check that user has permission to get this schedules info.

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	TSchedulerItemRef ref;

	ref.iHandle	= schedule->Id();

	ref.iName	= schedule->Name();

	TPBSchedulerItemRef pRef(ref);

	iClientMessage->WriteL(1, pRef);

	TTsTime dueTime(schedule->DueTime());

	TPBTime pDueTime(dueTime);

	iClientMessage->WriteL(2, pDueTime);

	}

void CSchSession::GetTaskDataSizeL()

	{

	TInt taskId = iClientMessage->GetIntL(0);

	TInt scheduleId = (taskId/KScheduleIdDifferential)*KScheduleIdDifferential;

	CSchedule* schedule = iTaskScheduler->FindL(scheduleId);

	//check that user has permission to get this task info (based on owning 

	//schedules info).

	schedule->CheckAccessAllowedL(iClientMessage->Message());

	TScheduledTask* task = schedule->Task(taskId);

	if	(!task)

		User::Leave(KErrNotFound);

	TInt size = task->Data().Length();

	TPInt pSize(size);

	iClientMessage->WriteL(1,pSize);

	}

void  CSchSession::CheckCapabilityL()

	{

	if( !( iClientMessage->Message().HasCapability(ECapabilityWriteDeviceData)

		|| (PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement)==0 ))) // Enforcement off

		User::Leave(KErrPermissionDenied);	

	}

void CSchSession::CheckPersistsInBackupL(const CSchedule& aSchedule)

	{

	// backup or restore in progress, so don't allow functions that might write to store	

	if ((iTaskScheduler->BUROperationInProgress() != EBUROperationNoActivity) && (aSchedule.Persists()))

		{

		User::Leave(KErrServerBusy);

		}

	}