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

		}

	}