Merge.
// 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);
}
}