sl@0: // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: // User includes
sl@0: #include "SSCH_STD.H"
sl@0: #include "CSCHCODE.H"
sl@0: #include "SCHCLI.H"
sl@0: #include "SchLogger.h"
sl@0: #include "SCHMAN.H"
sl@0: #include "SCHEDULE.H"
sl@0: #include <schtask.h>
sl@0: 
sl@0: // Constants
sl@0: const TInt KSchedulerArrayGranularity = 1; 
sl@0: _LIT(KSchedulerPanic, "Task Scheduler");
sl@0: 
sl@0: void PanicClient(TInt aPanic, const RMessage2& aMessage)
sl@0: //
sl@0: // Toast the client
sl@0: //
sl@0: 	{
sl@0: 	//Note that panic also completes the message so don't complete anywhere else
sl@0: 	aMessage.Panic(KSchedulerPanic,aPanic);
sl@0: 	}
sl@0: 	
sl@0: CSchSession::CSchSession(CTaskScheduler& aScheduler)
sl@0: //
sl@0: // C'Tor - must pass client to CSession
sl@0: //
sl@0: 	:	CSession2(), 
sl@0: 		iTaskScheduler(&aScheduler), 
sl@0: 		iClient(NULL)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CSchSession::~CSchSession()
sl@0: 	{
sl@0: 	if (iClient)
sl@0: 		{
sl@0: 		iClient->DecUsers();
sl@0: 		if (!iClient->Users())
sl@0: 			{
sl@0: 			iClient->Remove();
sl@0: 			delete iClient;
sl@0: 			iClient = NULL;
sl@0: 			}
sl@0: 		}
sl@0: 	if(!iPendingNotification.IsNull())
sl@0: 		iPendingNotification.Complete(KErrCancel);	
sl@0: 	}
sl@0: 	
sl@0: void CSchSession::ServiceError(const RMessage2& aMessage,TInt aError)
sl@0: //
sl@0: // Handle an error or leave from CMySession::ServiceL()
sl@0: // A bad descriptor error implies a badly programmed client, so panic it;
sl@0: // otherwise use the default handling (report the error to the client)
sl@0: //
sl@0: 	{
sl@0: 	if (aError==KErrBadDescriptor)
sl@0: 		PanicClient(EPanicBadDescriptor,aMessage);
sl@0: 	CSession2::ServiceError(aMessage,aError);
sl@0: 	}
sl@0: 
sl@0: void CSchSession::ServiceL(const RMessage2& aMessage)
sl@0: //
sl@0: //	Handle messages for this session.
sl@0: //	all API functions are synchronous so complete here too
sl@0: //
sl@0: 	{
sl@0: 	
sl@0: 	iClientMessage = BSUL::CClientMessage::NewL(aMessage);
sl@0: 	
sl@0: 	//Validate the message
sl@0: 	TRAPD(error, iClientMessage->ValidateL());
sl@0: 	
sl@0: 	if(error == KErrNone)
sl@0: 		{
sl@0: 		TRAP(error, DoServiceL());
sl@0: 		}
sl@0: 	
sl@0:    	// don't complete message if we have paniced client (ie message is NULL)
sl@0:    	iClientMessage->CompleteRequestL(error);
sl@0: 
sl@0:    	delete iClientMessage;
sl@0:    	iClientMessage = NULL;   	
sl@0: 	}
sl@0: 
sl@0: void CSchSession::DoServiceL()
sl@0: //
sl@0: //	Handle messages for this session.
sl@0: //	all API functions are synchronous so complete here too
sl@0: //
sl@0: 	{
sl@0: 	switch (iClientMessage->Function())
sl@0: 		{
sl@0: #if defined (_DEBUG)
sl@0: 	case ESchDbgMarkHeap:
sl@0: 		__UHEAP_MARK;
sl@0: 		break;
sl@0: 	case ESchDbgCheckHeap:
sl@0: 		__UHEAP_CHECK(iClientMessage->GetIntL(0));
sl@0: 		break;
sl@0: 	case ESchDbgMarkEnd:
sl@0: 		{
sl@0: 		TInt count = iClientMessage->GetIntL(0);
sl@0: 		
sl@0: 		//Three allocations are made for this message so add 3 to count
sl@0: 		//CClientMessage::NewL
sl@0: 		//CIntParameter::NewL
sl@0: 		//RPointerArray::AppendL	
sl@0: 		__UHEAP_MARKENDC(count + 3);
sl@0: 		}
sl@0: 		break;
sl@0: 	case ESchDbgFailNext:
sl@0: 		__UHEAP_FAILNEXT(iClientMessage->GetIntL(0));
sl@0: 		break;
sl@0: 	case ESchDbgResetHeap:
sl@0: 		__UHEAP_RESET;
sl@0: 		break;
sl@0: 	case ESchFaultServer:
sl@0: 		{
sl@0: 		// make sure we complete the message first before Killing this server
sl@0: 		iClientMessage->CompleteRequestL(KErrNone);
sl@0: 		RProcess().Kill(0);
sl@0: 		return;
sl@0: 		}
sl@0: #endif
sl@0:     case ERegisterClient:
sl@0: 		RegisterClientL();
sl@0:     	break;
sl@0: 	case ECreateTimeSchedule:
sl@0: 		CreateTimeScheduleL();
sl@0:     	break;
sl@0: 	case ECreateConditionSchedule:
sl@0: 		CreateConditionScheduleL();
sl@0:     	break;
sl@0: 	case EScheduleTask:
sl@0: 		ScheduleTaskL();
sl@0:     	break;
sl@0: 	case EDeleteTask:
sl@0: 		DeleteTaskL();
sl@0: 		break;
sl@0: 	case EDeleteSchedule:
sl@0: 		{
sl@0: 		CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(0));
sl@0: 		CheckPersistsInBackupL(*schedule);
sl@0: 		//check that user has permission to delete this schedule.
sl@0: 		schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 		iTaskScheduler->RemoveScheduleL(iClientMessage->GetIntL(0));
sl@0:     	break;
sl@0: 		}
sl@0: 	case EDisableSchedule:
sl@0: 		{
sl@0: 		CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(0));
sl@0: 		CheckPersistsInBackupL(*schedule);
sl@0: 		//check that user has permission to disable this schedule.
sl@0: 		schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 		iTaskScheduler->DisableScheduleL(iClientMessage->GetIntL(0));
sl@0:     	break;
sl@0: 		}
sl@0: 	case EEnableSchedule:
sl@0: 		{
sl@0: 		CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(0));
sl@0: 		CheckPersistsInBackupL(*schedule);
sl@0: 		//check that user has permission to enable this schedule.
sl@0: 		schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 		iTaskScheduler->EnableScheduleL(iClientMessage->GetIntL(0));
sl@0:     	break;
sl@0: 		}
sl@0: 	case EEditTimeSchedule:
sl@0: 		EditTimeScheduleL();
sl@0:     	break;
sl@0: 	case EEditConditionSchedule:
sl@0: 		EditConditionScheduleL();
sl@0:     	break;
sl@0: 	case EGetScheduleRefs:
sl@0: 		GetScheduleRefsL();
sl@0: 		break;
sl@0: 	case ECountSchedules:
sl@0: 		CountSchedulesL();
sl@0: 		break;
sl@0: 	case EGetScheduleInfo:
sl@0: 		GetScheduleInfoL();
sl@0: 		break;
sl@0: 	case EGetTimeScheduleData:
sl@0: 		GetTimeScheduleDataL();
sl@0: 		break;
sl@0: 	case EGetConditionScheduleData:
sl@0: 		GetConditionScheduleDataL();
sl@0: 		break;
sl@0: 	case EGetTaskData:
sl@0: 		GetTaskDataL();
sl@0: 		break;
sl@0: 	case EGetTaskRefs:
sl@0: 		GetTaskRefsL();
sl@0:     	break;	
sl@0: 	case ECountTasks:
sl@0: 		CountTasksL();
sl@0: 		break;
sl@0: 	case EGetTask:
sl@0: 		GetTaskInfoL();
sl@0: 		break;
sl@0: 	case EGetSchedulerItemRefAndNextDueTime:
sl@0: 		GetScheduleItemRefAndDueTimeL();
sl@0: 		break;
sl@0: 	case EGetTaskDataSize:
sl@0: 		GetTaskDataSizeL();
sl@0: 		break;
sl@0: 	case EGetScheduleType:
sl@0: 		GetScheduleTypeL();
sl@0: 		break;
sl@0: 	default:
sl@0: 		User::Leave(EPanicIllegalFunction);
sl@0: 		break;
sl@0: 		
sl@0:         }//switch 
sl@0: 
sl@0: 	}
sl@0: 
sl@0: //private functions
sl@0: void CSchSession::RegisterClientL()
sl@0: 	{
sl@0: 	TFileName writeBuf;
sl@0: 
sl@0: 	iClientMessage->ReadL(0,writeBuf);
sl@0: 
sl@0: 	// should return existing client if there is one
sl@0: 	CClientProxy* client = iTaskScheduler->AddClientL(writeBuf, iClientMessage->GetIntL(1));
sl@0: 	client->IncUsers();
sl@0: 	if	(iClient)
sl@0: 		{
sl@0: 		iClient->DecUsers();
sl@0: 		if	(!iClient->Users())
sl@0: 			{
sl@0: 			LOGSTRING2("CSchSession::RegisterClientL - removing existing client %S", &iClient->ExecutorFileName());
sl@0: 			iClient->Remove();
sl@0: 			delete iClient;
sl@0: 			}
sl@0: 		}
sl@0: 	iClient = client;
sl@0: 	}
sl@0: 
sl@0: void CSchSession::CreateTimeScheduleL()
sl@0: 	{
sl@0: 	// get settings
sl@0: 	TScheduleSettings2 settings;
sl@0: 	TPScheduleSettings pS(settings);
sl@0: 	iClientMessage->ReadL(0, pS);
sl@0: 	
sl@0: 	//WriteDeviceData needed to create persistent schedules
sl@0: 	if(settings.iPersists)
sl@0: 		{
sl@0: 		// backup or restore in progress, so don't allow functions that might write to store
sl@0: 		if (iTaskScheduler->BUROperationInProgress() != EBUROperationNoActivity)
sl@0: 			{
sl@0: 			User::Leave(KErrServerBusy);
sl@0: 			}
sl@0: 
sl@0: 		CheckCapabilityL();
sl@0: 		}	
sl@0: 
sl@0: 	//Verify that the length of the condition list passed in is as expected
sl@0: 	if(iClientMessage->GetDesLengthL(1) != 
sl@0: 				(settings.iEntryCount * sizeof(TScheduleEntryInfo2)))
sl@0: 		{
sl@0: 		User::Leave(KErrBadDescriptor);
sl@0: 		}
sl@0: 
sl@0: 	// get entries
sl@0: 	CArrayFixFlat<TScheduleEntryInfo2>* entries 
sl@0: 		= new(ELeave) CArrayFixFlat<TScheduleEntryInfo2>(settings.iEntryCount);
sl@0: 	CleanupStack::PushL(entries);
sl@0: 	entries->ResizeL(settings.iEntryCount);
sl@0: 	TPtr8 entriesPtr(REINTERPRET_CAST(TUint8*,&(entries->At(0))), settings.iEntryCount * sizeof(TScheduleEntryInfo2));
sl@0: 	iClientMessage->ReadL(1, entriesPtr);
sl@0: 
sl@0: 	// create schedule
sl@0: 	const TInt handle = iTaskScheduler->GenerateId();
sl@0: 	if	(handle == KErrOverflow)
sl@0: 		User::Leave(KErrOverflow);
sl@0: 
sl@0: 	// write back ID
sl@0: 	TPInt id(handle);
sl@0: 	iClientMessage->WriteL(2,id);
sl@0: 
sl@0: 	// get security info
sl@0: 	TSecurityInfo securityInfo(iClientMessage->Message());	
sl@0: 
sl@0: 	// Create schedule and add to scheduler
sl@0: 	CSchedule* newschedule = CSchedule::NewLC(handle, 
sl@0: 										settings.iName, 
sl@0: 										settings.iPersists, 
sl@0: 										*entries,
sl@0: 										securityInfo);
sl@0: 	iTaskScheduler->AddScheduleL(*newschedule);
sl@0: 	CleanupStack::Pop(newschedule);
sl@0: 	CleanupStack::PopAndDestroy(entries);
sl@0: 	}
sl@0: 
sl@0: void CSchSession::CreateConditionScheduleL()
sl@0: 	{
sl@0: 	// get settings
sl@0: 	TScheduleSettings2 settings;
sl@0: 	TPScheduleSettings pS(settings);
sl@0: 	iClientMessage->ReadL(0, pS);
sl@0: 
sl@0: 	//WriteDeviceData needed to create persistent schedules
sl@0: 	if(settings.iPersists)
sl@0: 		{
sl@0: 		// backup or restore in progress, so don't allow functions that might write to store
sl@0: 		if (iTaskScheduler->BUROperationInProgress() != EBUROperationNoActivity)
sl@0: 			{
sl@0: 			User::Leave(KErrServerBusy);
sl@0: 			}
sl@0: 
sl@0: 		CheckCapabilityL();
sl@0: 		}
sl@0: 
sl@0: 	//Verify that the length of the condition list passed in is as expected
sl@0: 	if(iClientMessage->GetDesLengthL(1) != 
sl@0: 				(settings.iEntryCount * sizeof(TTaskSchedulerCondition)))
sl@0: 		{
sl@0: 		User::Leave(KErrBadDescriptor);
sl@0: 		}
sl@0: 
sl@0: 	// get entries
sl@0: 	CArrayFixFlat<TTaskSchedulerCondition>* entries 
sl@0: 		= new(ELeave) CArrayFixFlat<TTaskSchedulerCondition>(settings.iEntryCount);
sl@0: 	CleanupStack::PushL(entries);
sl@0: 	entries->ResizeL(settings.iEntryCount);
sl@0: 	TPtr8 entriesPtr(REINTERPRET_CAST(TUint8*,&(entries->At(0))), settings.iEntryCount * sizeof(TTaskSchedulerCondition));
sl@0: 	iClientMessage->ReadL(1, entriesPtr);
sl@0: 	
sl@0: 	// get time
sl@0: 	TTsTime defaultRunTime;
sl@0: 	TPckg<TTsTime> pTime(defaultRunTime);
sl@0: 	iClientMessage->ReadL(2, pTime);
sl@0: 
sl@0: 	// create schedule
sl@0: 	const TInt handle = iTaskScheduler->GenerateId();
sl@0: 	if	(handle == KErrOverflow)
sl@0: 		User::Leave(KErrOverflow);
sl@0: 
sl@0: 	// write back ID
sl@0: 	TPInt id(handle);
sl@0: 	iClientMessage->WriteL(3,id);
sl@0: 	
sl@0: 	// get security info
sl@0: 	TSecurityInfo securityInfo(iClientMessage->Message());	
sl@0: 
sl@0: 	// Create schedule and add to scheduler
sl@0: 	CSchedule* newschedule 
sl@0: 		= CSchedule::NewLC(handle, 
sl@0: 							settings.iName, 
sl@0: 							settings.iPersists, 
sl@0: 							*entries,
sl@0: 							defaultRunTime,
sl@0: 							securityInfo);
sl@0: 	iTaskScheduler->AddScheduleL(*newschedule);
sl@0: 	CleanupStack::Pop(newschedule);
sl@0: 	CleanupStack::PopAndDestroy(entries);
sl@0: 	}
sl@0: 
sl@0: void CSchSession::EditTimeScheduleL()
sl@0: 	{
sl@0: 	CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(1));
sl@0: 	
sl@0: 	CheckPersistsInBackupL(*schedule);
sl@0: 	//check that user has permission to edit this schedule.
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	//check that this is a time schedule!
sl@0: 	if(schedule->Type() != ETimeSchedule)
sl@0: 		User::Leave(KErrArgument);
sl@0: 		
sl@0: 	// Get entry count
sl@0: 	const TInt count = iClientMessage->GetIntL(0);
sl@0: 	
sl@0: 	//Verify that the length of the condition list passed in is as expected
sl@0: 	if(iClientMessage->GetDesLengthL(2) != (count * sizeof(TScheduleEntryInfo2)))
sl@0: 		{
sl@0: 		User::Leave(KErrBadDescriptor);
sl@0: 		}
sl@0: 
sl@0: 	// Get new entry list
sl@0: 	CArrayFixFlat<TScheduleEntryInfo2>* entries 
sl@0: 		= new(ELeave) CArrayFixFlat<TScheduleEntryInfo2> (KSchedulerArrayGranularity);	
sl@0: 	CleanupStack::PushL(entries);
sl@0: 	entries->ResizeL(count);
sl@0: 	TPtr8 entriesPtr(REINTERPRET_CAST(TUint8*, &(entries->At(0))), count*sizeof(TScheduleEntryInfo2));
sl@0: 
sl@0: 	iClientMessage->ReadL(2, entriesPtr);
sl@0: 
sl@0: 	// Give it to scheduler along with schedule id
sl@0: 	iTaskScheduler->EditScheduleL(iClientMessage->GetIntL(1), *entries);
sl@0: 	CleanupStack::PopAndDestroy(entries);
sl@0: 	}
sl@0: 
sl@0: void CSchSession::EditConditionScheduleL()
sl@0: 	{
sl@0: 	CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(1));
sl@0: 	
sl@0: 	CheckPersistsInBackupL(*schedule);
sl@0: 	//check that user has permission to edit this schedule.
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	//check that this is a condition schedule!
sl@0: 	if(schedule->Type() != EConditionSchedule)
sl@0: 		User::Leave(KErrArgument);
sl@0: 
sl@0: 	// Get entry count
sl@0: 	const TInt count = iClientMessage->GetIntL(0);
sl@0: 	
sl@0: 	//Verify that the length of the condition list passed in is as expected
sl@0: 	if(iClientMessage->GetDesLengthL(2) != (count * sizeof(TTaskSchedulerCondition)))
sl@0: 		{
sl@0: 		User::Leave(KErrBadDescriptor);
sl@0: 		}
sl@0: 
sl@0: 	// Get new entry list
sl@0: 	CArrayFixFlat<TTaskSchedulerCondition>* entries 
sl@0: 		= new(ELeave) CArrayFixFlat<TTaskSchedulerCondition> (KSchedulerArrayGranularity);	
sl@0: 	CleanupStack::PushL(entries);
sl@0: 	entries->ResizeL(count);
sl@0: 	TPtr8 entriesPtr(REINTERPRET_CAST(TUint8*, &(entries->At(0))), count*sizeof(TTaskSchedulerCondition));
sl@0: 	iClientMessage->ReadL(2, entriesPtr);
sl@0: 
sl@0: 	// get time
sl@0: 	TTsTime defaultRunTime;
sl@0: 	TPckg<TTsTime> pTime(defaultRunTime);
sl@0: 	iClientMessage->ReadL(3, pTime);
sl@0: 
sl@0: 	// Give it to scheduler along with schedule id
sl@0: 	iTaskScheduler->EditScheduleL(iClientMessage->GetIntL(1), *entries, defaultRunTime);
sl@0: 	CleanupStack::PopAndDestroy(entries);
sl@0: 	}
sl@0: 
sl@0: void CSchSession::ScheduleTaskL()
sl@0: 	{
sl@0: 	// If client is registered, it is allowed to schedule tasks
sl@0: 	if(iClient != NULL)
sl@0: 		{
sl@0: 		TTaskInfo taskInfo;
sl@0: 		TPTaskInfo pI(taskInfo);
sl@0: 		iClientMessage->ReadL(0, pI);
sl@0: 
sl@0: 		CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(1));
sl@0: 	
sl@0: 		CheckPersistsInBackupL(*schedule);
sl@0: 
sl@0: 		//check that user has permission to schedule a task using this schedule.
sl@0: 		schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 		taskInfo.iTaskId = schedule->GenerateTaskId();
sl@0: 
sl@0: 		if (taskInfo.iTaskId == KErrOverflow)
sl@0: 			{
sl@0: 			User::Leave(KErrOverflow);
sl@0: 			}
sl@0: 		// panic client if this is a condition schedule and client is asking for 
sl@0: 		// repeats.  This doesnt make sense.	
sl@0: 		if (schedule->Type() == EConditionSchedule && taskInfo.iRepeat != 0)
sl@0: 			User::Leave(KErrArgument); 
sl@0: 
sl@0: 		// Create a new scheduled task with associated task data
sl@0: 		TInt len = iClientMessage->GetDesLengthL(3);
sl@0: 		HBufC* taskdata = HBufC::NewLC(len);
sl@0: 
sl@0: 		TPtr pData(taskdata->Des());
sl@0: 		iClientMessage->ReadL(3, pData);	
sl@0: 	
sl@0: 		CScheduledTask* newTask = new(ELeave) CScheduledTask(taskInfo, 
sl@0: 											taskdata, 
sl@0: 											schedule->Type(), 
sl@0: 											schedule->SecurityInfo());
sl@0: 		CleanupStack::Pop(taskdata); //taskdata now owned by newTask
sl@0: 		CleanupStack::PushL(newTask);
sl@0: 		// Have to store the associated task, so that in the case where the
sl@0: 		// tasks need to be restored from a backup, we can ensure that the
sl@0: 		// task is associated with the correct schedule.
sl@0: 		newTask->SetScheduleId(schedule->Id());
sl@0: 
sl@0: 		//If the schedule that the task is associated with is persistent then set the flag
sl@0: 		if(schedule->Persists())
sl@0: 			{
sl@0: 			newTask->SetPersists();
sl@0: 			}
sl@0: 		LOGSTRING("CSchSession::ScheduleTaskL - writing back task id to client");
sl@0: 		TPInt id(taskInfo.iTaskId);
sl@0: 		iClientMessage->WriteL(2,id);
sl@0: 	
sl@0: 		TScheduledTask* task = new(ELeave) TScheduledTask(*newTask,*iClient);
sl@0: 	
sl@0: 		// Now that task has been created sucessfully, we can add newTask to Client
sl@0: 		iClient->AddTask(*newTask); // task info is owned by client: schedule just keeps a reference
sl@0: 		CleanupStack::Pop(newTask);
sl@0: 
sl@0: 		schedule->AddTask(*task);	//add new task - its now owned by schedule
sl@0: 
sl@0: 		LOGSTRING("CSchSession::ScheduleTaskL - scheduling task with task scheduler");
sl@0: 		// If this leaves we need to still remove task from client and schedule. 
sl@0: 		// No easy way to do this via CleanupStack
sl@0: 		TRAPD(err, iTaskScheduler->ScheduleTaskL(*schedule, *iClient));
sl@0: 		if(err)
sl@0: 			{
sl@0: 			schedule->RemoveTask(task);
sl@0: 			iClient->RemoveTask(newTask);
sl@0: 			User::Leave(err);	
sl@0: 			}
sl@0: 		}
sl@0: 	else
sl@0: 		//Client hasnt been registered so it isn't allowed to schedule task, panic client
sl@0: 		{
sl@0: 		iClientMessage->PanicClient(KSchedulerPanic,EPanicNotRegistered);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CSchSession::DeleteTaskL()
sl@0: 	{
sl@0: 	const TInt taskId = iClientMessage->GetIntL(0);
sl@0: 	
sl@0: 	const TInt scheduleId = (taskId/KScheduleIdDifferential)*KScheduleIdDifferential;
sl@0: 
sl@0: 	//check that user has permission to delete a task using this schedule.
sl@0: 	CSchedule* schedule = iTaskScheduler->FindL(scheduleId);
sl@0: 	CheckPersistsInBackupL(*schedule);
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	iTaskScheduler->DeleteTaskL(scheduleId, taskId);
sl@0: 	}
sl@0: 
sl@0: //retrieval functions
sl@0: void CSchSession::CountSchedulesL()
sl@0: 	{
sl@0: 	TScheduleFilter filter = STATIC_CAST(TScheduleFilter, iClientMessage->GetIntL(1));
sl@0: 	//GetScheduleRefs filters on clients schedule permssion as well.
sl@0: 	TInt count = iTaskScheduler->GetScheduleRefsL(NULL,filter, iClientMessage->Message());
sl@0: 	TPInt pCount(count);
sl@0: 	iClientMessage->WriteL(0,pCount);
sl@0: 	}
sl@0: 
sl@0: void CSchSession::GetScheduleRefsL()
sl@0: 	{
sl@0: 	//client calls CountSchedules() first to get expected count. still 
sl@0: 	//need to check it's valid though...
sl@0: 	
sl@0: 	const TInt expectedCount = iClientMessage->GetIntL(0);
sl@0: 	TScheduleFilter filter = STATIC_CAST(TScheduleFilter, iClientMessage->GetIntL(1));
sl@0: 
sl@0: 	CArrayFixFlat<TSchedulerItemRef>* refArray 
sl@0: 		= new(ELeave) CArrayFixFlat<TSchedulerItemRef>(KSchedulerArrayGranularity);
sl@0: 	CleanupStack::PushL(refArray);
sl@0: 	
sl@0: 	//GetScheduleRefs filters on clients schedule permssion as well.
sl@0: 	TInt count = iTaskScheduler->GetScheduleRefsL(refArray, filter, iClientMessage->Message());
sl@0: 	if	((expectedCount<count) || (count == 0))
sl@0: 		User::Leave(KErrArgument);
sl@0: 
sl@0: 	TPtrC8 pS(REINTERPRET_CAST(TUint8*, &refArray->At(0)),sizeof(TSchedulerItemRef)*expectedCount);
sl@0: 	iClientMessage->WriteL(2, pS);
sl@0: 	CleanupStack::PopAndDestroy();//info array
sl@0: 	}
sl@0: 
sl@0: void CSchSession::GetTimeScheduleDataL()
sl@0: 	{
sl@0: 	//client input:handle at info at aMessage.Int0()
sl@0: 	//info at aMessage.Ptr1()
sl@0: 	//info contains: exepcted entry count
sl@0: 	//scheduler output: entries at aM.Ptr2()
sl@0: 	TInt handle = iClientMessage->GetIntL(0);
sl@0: 
sl@0: 	TScheduleInfo info;
sl@0: 	TPScheduleInfo pS(info);
sl@0: 	iClientMessage->ReadL(1, pS);
sl@0: 
sl@0: 	CSchedule* schedule = iTaskScheduler->FindL(handle);
sl@0: 
sl@0: 	//check that user has permission to get this schedules info.
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	if (schedule->Type() != ETimeSchedule)
sl@0: 		User::Leave(KErrArgument); //calling wrong API
sl@0: 
sl@0: 	CArrayFixFlat<TScheduleEntryInfo2>* entries 
sl@0: 		= new(ELeave) CArrayFixFlat<TScheduleEntryInfo2> (KSchedulerArrayGranularity);
sl@0: 	CleanupStack::PushL(entries);
sl@0: 	schedule->EntriesL(*entries);
sl@0: 	if ((entries->Count())!=info.iEntryCount)
sl@0: 		User::Leave(KErrArgument);
sl@0: 	//write entries
sl@0: 	TPtrC8 pE(REINTERPRET_CAST(TUint8*, &entries->At(0)),sizeof(TScheduleEntryInfo2)*info.iEntryCount);
sl@0: 	iClientMessage->WriteL(2, pE);	
sl@0: 
sl@0: 	CleanupStack::PopAndDestroy(entries);//entry array
sl@0: 	}
sl@0: 
sl@0: void CSchSession::GetConditionScheduleDataL()
sl@0: 	{
sl@0: 	//client input:handle at info at aMessage.Int0()
sl@0: 	//info at aMessage.Ptr1()
sl@0: 	//info contains: exepcted entry count
sl@0: 	//scheduler output: entries at aM.Ptr2()
sl@0: 	TInt handle = iClientMessage->GetIntL(0);
sl@0: 
sl@0: 	TScheduleInfo info;
sl@0: 	TPScheduleInfo pS(info);
sl@0: 	iClientMessage->ReadL(1, pS);
sl@0: 
sl@0: 	CSchedule* schedule = iTaskScheduler->FindL(handle);
sl@0: 	
sl@0: 	//check that user has permission to get this schedules info.
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	if (schedule->Type() != EConditionSchedule)
sl@0: 		User::Leave(KErrArgument); //calling wrong API
sl@0: 
sl@0: 	CArrayFixFlat<TTaskSchedulerCondition>* conditions 
sl@0: 		= new(ELeave) CArrayFixFlat<TTaskSchedulerCondition> (KSchedulerArrayGranularity);
sl@0: 	CleanupStack::PushL(conditions);
sl@0: 	schedule->ConditionsL(*conditions);
sl@0: 	if ((conditions->Count())!=info.iEntryCount)
sl@0: 		User::Leave(KErrArgument);
sl@0: 	//write entries
sl@0: 	TPtrC8 pE(REINTERPRET_CAST(TUint8*, &conditions->At(0)),sizeof(TTaskSchedulerCondition)*info.iEntryCount);
sl@0: 	iClientMessage->WriteL(2, pE);	
sl@0: 
sl@0: 	//write time
sl@0: 	TTsTime defaultTime(schedule->DefaultRunTimeL());
sl@0: 	TPBTime pDefaultTime(defaultTime);
sl@0: 	iClientMessage->WriteL(3, pDefaultTime);
sl@0: 
sl@0: 	CleanupStack::PopAndDestroy(conditions);//condition array
sl@0: 	}
sl@0: 
sl@0: void CSchSession::GetScheduleTypeL()
sl@0: 	{
sl@0: 	TScheduleType type;
sl@0: 	TInt handle = iClientMessage->GetIntL(0);
sl@0: 	CSchedule* schedule = iTaskScheduler->FindL(handle);
sl@0: 	
sl@0: 	//check that user has permission to get this schedules info.
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	type = schedule->Type();	
sl@0: 	TPInt pType(type);
sl@0: 	iClientMessage->WriteL(1,pType);
sl@0: 	}
sl@0: 	
sl@0: void CSchSession::GetTaskDataL()
sl@0: 	{//client input:handle at info at aMessage.Int0()
sl@0: 	//info at aMessage.Ptr1()
sl@0: 	//info contains: exepcted entry count, expected task count
sl@0: 	//scheduler output: tasks at aM.Ptr2()
sl@0: 	TInt handle = iClientMessage->GetIntL(0);
sl@0: 
sl@0: 	TScheduleInfo info;
sl@0: 	TPScheduleInfo pS(info);
sl@0: 	iClientMessage->ReadL(1, pS);
sl@0: 
sl@0: 	CSchedule* schedule = iTaskScheduler->FindL(handle);
sl@0: 
sl@0: 	//check that user has permission to get this task info (based on owning
sl@0: 	// schedules info).
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	CArrayFixFlat<TTaskInfo>* tasks 
sl@0: 		= new(ELeave) CArrayFixFlat<TTaskInfo> (KSchedulerArrayGranularity);
sl@0: 	CleanupStack::PushL(tasks);
sl@0: 	schedule->TasksL(*tasks);
sl@0: 	if ((tasks->Count())!=info.iTaskCount)
sl@0: 		User::Leave(KErrArgument);
sl@0: 	//write tasks if there are any
sl@0: 	if (info.iTaskCount>0)
sl@0: 		{
sl@0: 		TPtrC8 pT(REINTERPRET_CAST(TUint8*, &tasks->At(0)),sizeof(TTaskInfo)*info.iTaskCount);
sl@0: 		iClientMessage->WriteL(2, pT);	
sl@0: 		}
sl@0: 	CleanupStack::PopAndDestroy(tasks);//task array
sl@0: 	}
sl@0: 
sl@0: void CSchSession::GetScheduleInfoL()
sl@0: 	{
sl@0: 	CSchedule* schedule = iTaskScheduler->FindL(iClientMessage->GetIntL(0));
sl@0: 	
sl@0: 	//check that user has permission to get this schedules info.
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	TScheduleInfo info;
sl@0: 	if (schedule->Type() == ETimeSchedule)
sl@0: 		schedule->GetInfo(info, EFalse);
sl@0: 	else
sl@0: 		schedule->GetInfo(info, ETrue);
sl@0: 		
sl@0: 	TPBScheduleInfo pInfo(info);
sl@0: 	iClientMessage->WriteL(1, pInfo);
sl@0: 	TTsTime dueTime(schedule->DueTime());
sl@0: 	TPBTime pDueTime(dueTime);
sl@0: 	iClientMessage->WriteL(2, pDueTime);
sl@0: 	}
sl@0: 
sl@0: void CSchSession::GetTaskRefsL()
sl@0: 	{
sl@0: 	//taskrefs for all, 
sl@0: 	//or just the ones I scheduled, 
sl@0: 	//or just the pending ones, 
sl@0: 	//or just the pending ones I scheduled
sl@0: 	
sl@0: 	TInt expectedCount = iClientMessage->GetIntL(0);
sl@0: 	TScheduleFilter sFilter = STATIC_CAST(TScheduleFilter, iClientMessage->GetIntL(1));
sl@0: 	TTaskFilter tFilter = STATIC_CAST(TTaskFilter, iClientMessage->GetIntL(2));
sl@0: 	CArrayFixFlat<TSchedulerItemRef>* refs 
sl@0: 		= new (ELeave) CArrayFixFlat<TSchedulerItemRef> (KSchedulerArrayGranularity);
sl@0: 	CleanupStack::PushL(refs);
sl@0: 	
sl@0: 	//GetTaskRefs filters on clients schedule permssion as well.
sl@0: 	TInt actualCount = iTaskScheduler->GetTaskRefsL(refs, sFilter, tFilter,iClient, iClientMessage->Message());
sl@0: 	
sl@0: 	// Must find enough tasks.
sl@0: 	if((actualCount != expectedCount) || (refs->Count() == 0))
sl@0: 		User::Leave(KErrArgument);
sl@0: 	
sl@0: 	// Write array back to client
sl@0: 	TPtrC8 pR(REINTERPRET_CAST(TUint8*,&refs->At(0)),sizeof(TSchedulerItemRef)*expectedCount);
sl@0: 	iClientMessage->WriteL(3, pR);
sl@0: 	CleanupStack::PopAndDestroy();//refs
sl@0: 	}
sl@0: 
sl@0: void CSchSession::CountTasksL()
sl@0: 	{
sl@0: 	//count either all of 'em or just mine
sl@0: 	
sl@0: 	TScheduleFilter sFilter = STATIC_CAST(TScheduleFilter, iClientMessage->GetIntL(1));
sl@0: 	TTaskFilter tFilter = STATIC_CAST(TTaskFilter, iClientMessage->GetIntL(2));
sl@0: 
sl@0: 	//GetTaskRefs filters on clients schedule permssion as well.
sl@0: 	TInt count = iTaskScheduler->GetTaskRefsL(NULL, sFilter, tFilter,iClient, iClientMessage->Message());
sl@0: 
sl@0: 	TPInt pCount(count);
sl@0: 	iClientMessage->WriteL(0,pCount);
sl@0: 	}
sl@0: 
sl@0: void CSchSession::GetTaskInfoL()
sl@0: 	{
sl@0: 	// Get task
sl@0: 	TInt taskId				= iClientMessage->GetIntL(0);
sl@0: 	TInt scheduleId			= (taskId/KScheduleIdDifferential)*KScheduleIdDifferential;
sl@0: 	CSchedule* schedule		= iTaskScheduler->FindL(scheduleId);
sl@0: 	
sl@0: 	//check that user has permission to get this task info (based on owning 
sl@0: 	//schedules info).
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	TScheduledTask* task = schedule->Task(taskId);
sl@0: 	if	(!task)
sl@0: 		User::Leave(KErrNotFound);
sl@0: 
sl@0: 	TPBTaskInfo pI(task->Info());
sl@0: 
sl@0: 	iClientMessage->WriteL(1, pI);//write info	
sl@0: 	
sl@0: 	// If there isn't enough room to hold the task data in the client buffer then
sl@0: 	// indicate by returning KErrArgument
sl@0: 	TInt clientBufferSize = iClientMessage->GetIntL(2);
sl@0: 	if	(clientBufferSize < task->Data().Length())
sl@0: 		User::Leave(KErrArgument);
sl@0: 	iClientMessage->WriteL(3, task->Data());
sl@0: 	}
sl@0: 
sl@0: void CSchSession::GetScheduleItemRefAndDueTimeL()
sl@0: 	{
sl@0: 	// Get CSchedule object
sl@0: 	TInt taskId = iClientMessage->GetIntL(0);
sl@0: 	TInt scheduleId = (taskId/KScheduleIdDifferential)*KScheduleIdDifferential;
sl@0: 	CSchedule* schedule = iTaskScheduler->FindL(scheduleId);
sl@0: 
sl@0: 	//check that user has permission to get this schedules info.
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	TSchedulerItemRef ref;
sl@0: 	ref.iHandle	= schedule->Id();
sl@0: 	ref.iName	= schedule->Name();
sl@0: 
sl@0: 	TPBSchedulerItemRef pRef(ref);
sl@0: 	iClientMessage->WriteL(1, pRef);
sl@0: 	
sl@0: 	TTsTime dueTime(schedule->DueTime());
sl@0: 	TPBTime pDueTime(dueTime);
sl@0: 	iClientMessage->WriteL(2, pDueTime);
sl@0: 	}
sl@0: 
sl@0: void CSchSession::GetTaskDataSizeL()
sl@0: 	{
sl@0: 	TInt taskId = iClientMessage->GetIntL(0);
sl@0: 	TInt scheduleId = (taskId/KScheduleIdDifferential)*KScheduleIdDifferential;
sl@0: 	CSchedule* schedule = iTaskScheduler->FindL(scheduleId);
sl@0: 
sl@0: 	//check that user has permission to get this task info (based on owning 
sl@0: 	//schedules info).
sl@0: 	schedule->CheckAccessAllowedL(iClientMessage->Message());
sl@0: 	
sl@0: 	TScheduledTask* task = schedule->Task(taskId);
sl@0: 	if	(!task)
sl@0: 		User::Leave(KErrNotFound);
sl@0: 
sl@0: 	TInt size = task->Data().Length();
sl@0: 	TPInt pSize(size);
sl@0: 	iClientMessage->WriteL(1,pSize);
sl@0: 	}
sl@0: 
sl@0: void  CSchSession::CheckCapabilityL()
sl@0: 	{
sl@0: 	if( !( iClientMessage->Message().HasCapability(ECapabilityWriteDeviceData)
sl@0: 		|| (PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement)==0 ))) // Enforcement off
sl@0: 		User::Leave(KErrPermissionDenied);	
sl@0: 	}
sl@0: 	
sl@0: void CSchSession::CheckPersistsInBackupL(const CSchedule& aSchedule)
sl@0: 	{
sl@0: 	// backup or restore in progress, so don't allow functions that might write to store	
sl@0: 	if ((iTaskScheduler->BUROperationInProgress() != EBUROperationNoActivity) && (aSchedule.Persists()))
sl@0: 		{
sl@0: 		User::Leave(KErrServerBusy);
sl@0: 		}
sl@0: 	}
sl@0: