--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/taskscheduler/SCHCLI/CSCH_CLI.CPP Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,1382 @@
+// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Implements RScheduler functions: client-side session with the task scheduler
+//
+//
+
+#include "CSCH_CLI.H" //definition of RScheduler
+#include "CSCHCODE.H" //opcodes
+#include "SCHEXE.H"
+#include <schinfointernal.h>
+
+/** Default constructor. */
+EXPORT_C RScheduler::RScheduler()
+ {
+ }
+
+/**
+Connects a client to the Task Scheduler server, creating a session with that
+server.
+
+@return KErrNone, if successful; otherwise one of the other system wide error
+codes.
+*/
+EXPORT_C TInt RScheduler::Connect()
+ {
+ TInt r=CreateSession(KSchSvrName, Version(),0);
+ if (r==KErrNotFound)
+ {
+ r=StartSch32();
+ if (r!=KErrNone)
+ return r;
+ r=CreateSession(KSchSvrName, Version(),0);
+ }
+ return(r);
+ }
+
+/**
+Gets the client side version number.
+
+@return The version number.
+*/
+EXPORT_C TVersion RScheduler::Version() const
+ {
+ return(TVersion(KESchMajorVersionNumber,KESchMinorVersionNumber,KESchBuildVersionNumber));
+ }
+
+/**
+Registers a client with the Task Scheduler.
+
+A client must register with the Task Scheduler before scheduling any tasks,
+but does not need to register just to create and edit schedules.
+
+@param aFileName The name and full path of a program that encapsulates the
+client-specific knowledge for implementing tasks. On the emulator, the program
+should be a DLL; on an ARM processor, it should be an executable.
+@param aPriority A priority value.
+@return KErrNone, if successful; otherwise one of the other system wide error
+codes.
+*/
+EXPORT_C TInt RScheduler::Register(const TFileName& aFileName,const TInt aPriority)
+ {
+ return SendReceive(ERegisterClient,TIpcArgs(&aFileName,aPriority));
+ }
+
+/**
+Creates a persistent time based schedule.
+
+This schedule has no tasks associated with it but merely contains information
+about start and finish times.
+
+@capability WriteDeviceData
+@param aRef Definition of the new schedule. On return this contains a valid
+handle to the newly created schedule.
+@param aEntryList The set of schedule entries that make up the new schedule.
+@return KErrNone, if successful, KErrArgument if the condition array is
+empty, or an entry has an interval less than 1, KErrServerBusy, if a backup or
+restore operation is taking place, KErrPermissionDenied if the client
+does not have WriteDeviceData capability.
+Otherwise one of the other system wide error codes.
+@see TScheduleEntryInfo2
+*/
+EXPORT_C TInt RScheduler::CreatePersistentSchedule(TSchedulerItemRef& aRef,
+ const CArrayFixFlat<TScheduleEntryInfo2>& aEntryList)
+ {
+ TScheduleSettings2 settings;
+ settings.iPersists = ETrue;
+ settings.iEntryCount = aEntryList.Count();
+ settings.iName = aRef.iName;
+ return CreateSchedule(aRef, aEntryList, settings);
+ }
+
+/**
+Creates a persistent condition based schedule.
+
+This schedule has no tasks associated with it but merely contains information
+about conditions that must be satified to complete this schedule.
+
+@capability WriteDeviceData
+@param aRef Definition of the new schedule. On return this contains a valid
+handle to the newly created schedule.
+@param aConditions An array of system agent conditons
+that make up the schedule.
+@param aDefaultRunTime The time at which the schedule with run if no
+conditions are met. If this is a local time based value, the schedule will remain
+at that local time regardless of timezone and DST changes (ie. it will float)
+If the value is UTC based, the schedule will remain at that UTC time (will not float).
+@return KErrNone, if successful, KErrArgument if the condition array is
+empty or if the publish and subscribe variables have an invalid category,
+KErrServerBusy, if a backup or restore operation is taking place,
+KErrPermissionDenied if the client does not have WriteDeviceData capability.
+Otherwise one of the other system wide error codes.
+@see TTaskSchedulerCondition
+@internalAll
+*/
+EXPORT_C TInt RScheduler::CreatePersistentSchedule(TSchedulerItemRef& aRef,
+ const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,
+ const TTsTime& aDefaultRunTime)
+ {
+ TScheduleSettings2 settings;
+ settings.iPersists = ETrue;
+ settings.iEntryCount = aConditions.Count();
+ settings.iName = aRef.iName;
+ return CreateSchedule(aRef, aConditions, aDefaultRunTime, settings);
+ }
+
+static TBool ScheduleEntriesAreBad(const CArrayFixFlat<TScheduleEntryInfo2>& aEntries)
+ {//must have at least 1 entry, each entry's interval must be at least 1
+ TInt count = aEntries.Count();
+ if (count==0)
+ return ETrue;
+ for (TInt i=0; i < count; i++)
+ {
+ const TScheduleEntryInfo2* entry = &(aEntries.At(i));
+ if (entry->Interval() < 1)
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+TInt RScheduler::CreateSchedule(TSchedulerItemRef& aRef,
+ const CArrayFixFlat<TScheduleEntryInfo2>& aEntryList,
+ const TScheduleSettings2& aSettings)
+ {//check critical aspects of input here (client-side)
+ if (ScheduleEntriesAreBad(aEntryList))
+ return KErrArgument;
+
+ //write settings (entry count + persists flag + name)
+ TPckgC<TScheduleSettings2> pSettings(aSettings);
+ //write entries
+ TPtrC8 pA((TUint8*)&aEntryList.At(0), sizeof(TScheduleEntryInfo2)*aSettings.iEntryCount);
+
+ //read back generated ID
+ TPckg<TInt> id(aRef.iHandle);
+ return SendReceive(ECreateTimeSchedule, TIpcArgs(&pSettings, &pA, &id));
+ }
+
+static TBool ScheduleEntriesAreBad(const CArrayFixFlat<TTaskSchedulerCondition>& aConditions)
+ {//must have at least 1 condition in array. The category for a condition cannot be KNullUid.
+ TInt count = aConditions.Count();
+ if (count==0)
+ return ETrue;
+ for (TInt i=0; i < count; i++)
+ {
+ const TTaskSchedulerCondition* entry = &(aConditions.At(i));
+ if (entry->iCategory == KNullUid)
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+TInt RScheduler::CreateSchedule(TSchedulerItemRef& aRef,
+ const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,
+ const TTsTime& aDefaultRunTime,
+ const TScheduleSettings2& aSettings)
+ {//check critical aspects of input here (client-side)
+ if (ScheduleEntriesAreBad(aConditions))
+ return KErrArgument;
+
+ //write settings (entry count + persists flag + name)
+ TPckgC<TScheduleSettings2> pSettings(aSettings);
+ //write entries
+ TPtrC8 pA((TUint8*)&aConditions.At(0), sizeof(TTaskSchedulerCondition)*aSettings.iEntryCount);
+ //write Time
+ TPckgC<TTsTime> pTime(aDefaultRunTime);
+
+ //read back generated ID
+ TPckg<TInt> id(aRef.iHandle);
+ return SendReceive(ECreateConditionSchedule, TIpcArgs(&pSettings, &pA, &pTime, &id));
+ }
+
+/**
+Changes a time based schedule.
+
+Note that changing a schedule is implemented by supplying a replacement set
+of schedule entries.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@param aEntryList The set of schedule entries that will make up the new schedule.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrArgument if the schedule is not a time based one,
+KErrPermissionDenied if the client does not have the same SID as the schedules
+creator or has WriteDeviceData capability, KErrServerBusy, if a backup or
+restore operation is taking place or any of the other system wide error
+codes.
+@see TScheduleEntryInfo2
+*/
+EXPORT_C TInt RScheduler::EditSchedule(const TInt aScheduleHandle, const CArrayFixFlat<TScheduleEntryInfo2>& aEntryList)
+ {
+ if (ScheduleEntriesAreBad(aEntryList))
+ return KErrArgument;
+ TInt count = aEntryList.Count();
+ TPtrC8 pA((TUint8*) &aEntryList.At(0), sizeof(TScheduleEntryInfo2)*count);
+ return SendReceive(EEditTimeSchedule, TIpcArgs(count, aScheduleHandle, &pA));
+ }
+
+/**
+Changes a condition based schedule.
+
+Note that changing a schedule is implemented by supplying a replacement set
+of schedule conditons and time.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@param aConditions An array of system agent conditons
+that make up the schedule.
+@param aDefaultRunTime The time at which the schedule with run if no
+conditions are met. If this is a local time based value, the schedule will remain
+at that local time regardless of timezone and DST changes (ie. it will float)
+If the value is UTC based, the schedule will remain at that UTC time (will not float).
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrArgument if the schedule is not a condition based one
+or if the publish and subscribe variables, defined by aConditions category
+and key values, do not exist or are not of integral type,
+KErrPermissionDenied if the client does not have the same SID as the schedules
+creator or has WriteDeviceData capability, KErrServerBusy, if a backup or
+restore operation is taking place, or any of the other system wide error
+codes.
+
+@internalAll
+*/
+EXPORT_C TInt RScheduler::EditSchedule(TInt aScheduleHandle,
+ const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,
+ const TTsTime& aDefaultRunTime)
+ {
+ TInt count = aConditions.Count();
+ TPtrC8 pA((TUint8*) &aConditions.At(0), sizeof(TTaskSchedulerCondition)*count);
+ //write Time
+ TPckgC<TTsTime> pTime(aDefaultRunTime);
+ return SendReceive(EEditConditionSchedule, TIpcArgs(count, aScheduleHandle, &pA, &pTime));
+ }
+
+
+/**
+Deletes the specified schedule.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+Note that a schedule cannot be deleted if there are tasks associated with
+it; the tasks must be explicitly deleted first.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrArgument if there are outstanding tasks associated with
+the schedule, KErrPermissionDenied if the client does not have the same SID as
+the schedules creator or has WriteDeviceData capability, KErrServerBusy, if a
+backup or restore operation is taking place or any of the other
+system wide error codes.
+*/
+EXPORT_C TInt RScheduler::DeleteSchedule(const TInt aScheduleHandle) const
+ {
+ return SendReceive(EDeleteSchedule, TIpcArgs(aScheduleHandle));
+ }
+
+/**
+Disables the specified schedule.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrPermissionDenied if the client does not have the same SID
+as the schedules creator or has WriteDeviceData capability, KErrServerBusy, if a
+backup or restore operation is taking place or any of the other
+system wide error codes.
+*/
+EXPORT_C TInt RScheduler::DisableSchedule(const TInt aScheduleHandle) const
+ {
+ return SendReceive(EDisableSchedule, TIpcArgs(aScheduleHandle));
+ }
+
+/**
+Enables the specified schedule.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@return KErrNone if successful. KErrNotFound if there is no schedule with
+the specified Id, KErrPermissionDenied if the client does not have the same SID
+as the schedules creator or has WriteDeviceData capability, KErrServerBusy, if a
+backup or restore operation is taking place or any of the other
+system wide error codes.
+*/
+EXPORT_C TInt RScheduler::EnableSchedule(const TInt aScheduleHandle) const
+ {
+ return SendReceive(EEnableSchedule, TIpcArgs(aScheduleHandle));
+ }
+
+/**
+Adds a task to an existing persistent schedule.
+
+Behaviour of execution after a Backup and Restore operation should be
+considered when adding tasks to a persistent schedule. Persistent schedules might be
+backed up when a one-off task might be pending, and become due and executed some time
+after the backup operation. When the backup is restored, the tasks might be executed
+again if they are still valid (restore done during the validation period for time-based
+schedules, or conditions satisfied after restore for condition-based schedules). Clients
+should refrain from creating tasks that might have undesired effects under these
+conditions (e.g. by incurring a cost to the user by sending an SMS twice).
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aTaskInfo Information about the task to be added to the schedule. On return
+the task Id is written into this class.
+@param aTaskData Data that is passed to the task on execution.
+@param aScheduleHandle The Id that identifies the schedule to be used.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrArgument if a task with a repeat vale other than 0 is
+being tried to be assigned to a condition based schedule,
+KErrPermissionDenied if the client does not have the same SID as the schedules
+creator or has WriteDeviceData capability, KErrServerBusy, if a backup or
+restore operation is taking place or any of the other system wide error
+codes.
+@panic CTaskScheduler 0 The client has not registered. The client must register
+before adding tasks to the schedule.
+*/
+EXPORT_C TInt RScheduler::ScheduleTask(TTaskInfo& aTaskInfo,
+ HBufC& aTaskData,
+ const TInt aScheduleHandle)
+ {
+ TPckgC<TTaskInfo> pI(aTaskInfo);
+ //scheduler writes back task id
+ TPckg<TInt> id(aTaskInfo.iTaskId);
+ TPtr pD(aTaskData.Des());
+ return SendReceive(EScheduleTask, TIpcArgs(&pI,aScheduleHandle,&id, &pD));
+ }
+
+/**
+Creates a new, transient, time based schedule and adds a task to it.
+
+Note that a transient schedule is destroyed when the task is destroyed or
+power is lost.
+
+@param aTaskInfo Information about the task to be added to the transient schedule.
+On return the task Id is written into this class.
+@param aTaskData Data that is passed to the task on execution.
+@param aRef Definition of the new transient schedule.
+@param aEntryList The set of schedule entries that make up the new transient
+schedule.
+@return KErrNone, if successful, or any of the other system wide error codes.
+@panic CTaskScheduler 0 The client has not registered. The client must register
+before adding tasks to the schedule.
+@see TScheduleEntryInfo2
+*/
+EXPORT_C TInt RScheduler::ScheduleTask(TTaskInfo& aTaskInfo,
+ HBufC& aTaskData,
+ TSchedulerItemRef& aRef,
+ const CArrayFixFlat<TScheduleEntryInfo2>& aEntryList)
+ {
+ TScheduleSettings2 settings;
+ settings.iPersists = EFalse;
+ settings.iEntryCount = aEntryList.Count();
+ settings.iName = aRef.iName;
+ TInt res = CreateSchedule(aRef, aEntryList, settings);
+ if (res==KErrNone)
+ {
+ res = ScheduleTask(aTaskInfo, aTaskData, aRef.iHandle);
+ //the schedule here needs a task: so if we can't schedule a task,
+ //need to delete schedule
+ if (res!=KErrNone)
+ DeleteSchedule(aRef.iHandle);
+ }
+ return res;
+ }
+
+/**
+Creates a new, transient, condition based schedule and adds a task to it.
+
+Note that a transient schedule is destroyed when the task is destroyed or
+power is lost.
+
+@param aTaskInfo Information about the task to be added to the transient schedule.
+On return the task Id is written into this class.
+@param aTaskData Data that is passed to the task on execution.
+@param aRef Definition of the new transient schedule.
+@param aConditions An array of schedule conditons that make up the schedule.
+@param aDefaultRunTime The time at which the schedule will run if no
+conditions are met. If this is a local time based value, the schedule will remain
+at that local time regardless of timezone and DST changes (ie. it will float)
+If the value is UTC based, the schedule will remain at that UTC time (will not float).
+@return KErrNone, if successful, KErrArgument if the publish and subscribe
+variables, defined by aConditions category and key values, do not exist or
+are not of integral type, or any of the other system wide error codes.
+@panic CTaskScheduler 0 The client has not registered. The client must register
+before adding tasks to the schedule.
+
+@internalAll
+*/
+EXPORT_C TInt RScheduler::ScheduleTask(TTaskInfo& aTaskInfo,
+ HBufC& aTaskData,
+ TSchedulerItemRef& aRef,
+ const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,
+ const TTsTime& aDefaultRunTime)
+ {
+ TScheduleSettings2 settings;
+ settings.iPersists = EFalse;
+ settings.iEntryCount = aConditions.Count();
+ settings.iName = aRef.iName;
+ TInt res = CreateSchedule(aRef, aConditions, aDefaultRunTime, settings);
+ if (res==KErrNone)
+ {
+ res = ScheduleTask(aTaskInfo, aTaskData, aRef.iHandle);
+ //the schedule here needs a task: so if we can't schedule a task,
+ //need to delete schedule
+ if (res!=KErrNone)
+ DeleteSchedule(aRef.iHandle);
+ }
+ return res;
+ }
+
+/**
+Deletes the specified task.
+
+@capability Note Only clients with the same SID as the relevant schedule
+creator, or WriteDeviceData capability can sucessfully call this API.
+
+@param aTaskId The Id that identifies the task.
+@return KErrNone if successful, KErrNotFound if there is no task with the
+specified Id, KErrPermissionDenied if the client does not have the same SID as
+the schedules creator or has WriteDeviceData capability, KErrServerBusy, if a
+backup or restore operation is taking place or any of the
+other system wide error codes.
+*/
+EXPORT_C TInt RScheduler::DeleteTask(const TInt aTaskId) const
+ {
+ return SendReceive(EDeleteTask, TIpcArgs(aTaskId));
+ }
+
+/**
+Gets a list of all schedules, or a subset of schedules.
+
+@capability Note A call to this API will only retrieve schedules created with
+the caller's SID. If the caller has WriteDeviceData capability all schedules
+will be retrieved.
+
+@param aScheduleRefArray On return, a populated array of schedule definitions.
+Note that populating the array could cause this function to leave because
+of an out of memory condition.
+@param aFilter The schedule filter.
+@return KErrNone if successful otherwise one of the other system wide error
+codes.
+@see TSchedulerItemRef
+*/
+EXPORT_C TInt RScheduler::GetScheduleRefsL(CArrayFixFlat<TSchedulerItemRef>& aScheduleRefArray,
+ const TScheduleFilter aFilter)
+ {
+ //1) get number of refs
+ TInt count;//scheduler writes back count
+ TPckg<TInt> pCount(count);
+ TInt res = SendReceive(ECountSchedules, TIpcArgs(&pCount, aFilter));
+ if (res!=KErrNone)
+ return res;
+ aScheduleRefArray.ResizeL(count);
+ //2) get refs, if there are any
+ if (count>0)
+ {
+ TPtr8 sPtr((TUint8*)&(aScheduleRefArray.At(0)), count*sizeof(TSchedulerItemRef));
+ res = SendReceive(EGetScheduleRefs, TIpcArgs(count, aFilter, &sPtr));
+ }
+ return res;
+ }
+
+/**
+Gets information relating to a specified time based schedule.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@param aState On return, the state of the specified schedule.
+@param aEntries On return, a populated array of schedule entries that make
+up the schedule. Note that populating the array could cause this function
+to leave because of an out of memory condition.
+@param aTasks On return, a populated array of tasks associated with the schedule.
+Note that populating the array could cause this function to leave because
+of an out of memory condition.
+@param aDueTime On return, the time that the schedule is next due. This value may
+be local time or UTC based,dependent on the type of time used for schedule entries.
+Comparisons used within the scheduler to find the next due time are UTC based.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrArgument if the schedule is not a time based one,
+KErrPermissionDenied if the client does not have the same SID as the schedules
+creator or has WriteDeviceData capability, or any of the other system wide error
+codes.
+@see TScheduleEntryInfo2
+@see TTaskInfo
+*/
+EXPORT_C TInt RScheduler::GetScheduleL(const TInt aScheduleHandle,
+ TScheduleState2& aState,
+ CArrayFixFlat<TScheduleEntryInfo2>& aEntries,
+ CArrayFixFlat<TTaskInfo>& aTasks,
+ TTsTime& aDueTime)
+ {
+ TScheduleInfo info;
+ TInt res = GetScheduleInfo(aScheduleHandle, info, aDueTime);
+ if (res != KErrNone)
+ return res;
+ aState = info.iState;
+ res = GetScheduleDataL(aScheduleHandle, info, aEntries);
+ if (res != KErrNone)
+ return res;
+ res = GetTaskDataL(aScheduleHandle, info, aTasks);
+ return res;
+ }
+
+/**
+Gets information relating to a specified condition based schedule.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@param aState On return, the state of the specified schedule.
+@param aConditions On return, a populated array of schedule conditons
+that make up the schedule. Note that populating the array could cause
+this function to leave because of an out of memory condition.
+@param aDefaultRunTime On return, the time at which the schedule with run if
+no conditions are met. If this is a local time based value, the schedule will remain
+at that local time regardless of timezone and DST changes (ie. it will float)
+If the value is UTC based, the schedule will remain at that UTC time (will not float).
+@param aTasks On return, a populated array of tasks associated with the schedule.
+Note that populating the array could cause this function to leave because
+of an out of memory condition.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrArgument if the schedule is not a condition based one,
+KErrPermissionDenied if the client does not have the same SID as the schedules
+creator or has WriteDeviceData capability, or any of the other system wide error
+codes.
+@see TTaskSchedulerCondition
+@see TTaskInfo
+
+@internalAll
+*/
+EXPORT_C TInt RScheduler::GetScheduleL(TInt aScheduleHandle,
+ TScheduleState2& aState,
+ CArrayFixFlat<TTaskSchedulerCondition>& aConditions,
+ TTsTime& aDefaultRunTime,
+ CArrayFixFlat<TTaskInfo>& aTasks)
+ {
+ TScheduleInfo info;
+ TTsTime dummyTime;
+ TInt res = GetScheduleInfo(aScheduleHandle, info, dummyTime);
+ if (res != KErrNone)
+ return res;
+ aState = info.iState;
+ res = GetScheduleDataL(aScheduleHandle,
+ info,
+ aConditions,
+ aDefaultRunTime);
+ if (res != KErrNone)
+ return res;
+ res = GetTaskDataL(aScheduleHandle, info, aTasks);
+ return res;
+ }
+
+/**
+Gets the schedule type.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule
+@param aScheduleType On return the type of schedule relating to the handle.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrPermissionDenied if the client does not have the same SID
+as the schedules creator or has WriteDeviceData capability, or any of the other
+system wide error codes.
+
+@internalAll
+*/
+EXPORT_C TInt RScheduler::GetScheduleTypeL(TInt aScheduleHandle,
+ TScheduleType& aScheduleType)
+ {
+ TPckg<TScheduleType> id(aScheduleType);
+ return SendReceive(EGetScheduleType, TIpcArgs(aScheduleHandle, &id));
+ }
+
+/**
+Gets a list of all tasks, or a subset of tasks.
+
+Note that if more than one client has supplied the same information when registering,
+then it is possible for a list of tasks to be returned, which the calling
+client has not scheduled.
+
+@capability Note A call to this API will only retrieve tasks created with
+the caller's SID. If the caller has WriteDeviceData capability all tasks
+will be retrieved.
+
+@param aTasks On return, a populated array of schedule definitions. The schedule
+definitions are those whose associated tasks satisfy the selection criteria.
+Note that populating the array could cause this function to leave because
+of an out of memory condition.
+@param aScheduleFilter The schedule filter.
+@param aTaskFilter The task filter.
+@return KErrNone if successful otherwise one of the other system wide error
+codes.
+@see TSchedulerItemRef
+*/
+EXPORT_C TInt RScheduler::GetTaskRefsL(CArrayFixFlat<TSchedulerItemRef>& aTasks,
+ const TScheduleFilter aScheduleFilter,
+ const TTaskFilter aTaskFilter)
+ {
+ //1)get number of tasks
+ TInt count;
+ TPckg<TInt> pCount(count);
+ TInt res = SendReceive(ECountTasks, TIpcArgs(&pCount, aScheduleFilter, aTaskFilter));
+ if (res!=KErrNone)
+ return res;
+ aTasks.ResizeL(count);
+ //2)get taskrefs
+ if (count >0)
+ {
+ TPtr8 pTasks(REINTERPRET_CAST(TUint8*, &(aTasks.At(0))), count*sizeof(TSchedulerItemRef));
+ res = SendReceive(EGetTaskRefs, TIpcArgs(count, aScheduleFilter, aTaskFilter, &pTasks));
+ }
+ return res;
+ }
+
+/**
+Gets information relating to a specified task.
+
+@capability Note Only clients with the same SID as the relevant schedule
+creator, or WriteDeviceData capability can sucessfully call this API.
+
+@param aTaskId The Id that identifies the task.
+@param aTaskInfo On return, information about the task.
+@param aTaskData On return, a pointer descriptor representing the data that
+is passed to the program to be executed. The caller must set up this pointer
+descriptor before calling the function. The required length of the descriptor
+can be found by calling GetTaskDataSize().
+@param aRef On return, the associated schedule definition.
+@param aNextDue On return, the time that the task is next due. This value may
+be local time or UTC based. Comparisons used to find the next due time are based on UTC.
+@return KErrNone, if successful. KErrNotFound, if there is no task with the
+specified Id, KErrPermissionDenied if the client does not have the same SID as
+the schedules creator or has WriteDeviceData capability.
+*/
+EXPORT_C TInt RScheduler::GetTaskInfoL(const TInt aTaskId, TTaskInfo& aTaskInfo, TPtr& aTaskData, TSchedulerItemRef& aRef, TTsTime& aNextDue)
+ {
+ // First of all retrieve the normal stuff
+ TPtr8 pInfo((TUint8*)&aTaskInfo,sizeof(TTaskInfo));
+ TInt size = aTaskData.MaxLength();
+ TInt res = SendReceive(EGetTask, TIpcArgs(aTaskId, &pInfo, size, &aTaskData));
+ if (res != KErrNone)
+ return res;
+
+ // Next retrieve the TSchedulerItemRef and next due time
+ TPtr8 pItemRef((TUint8*)&aRef, sizeof(TSchedulerItemRef));
+ TPtr8 pDueTime((TUint8*)&aNextDue, sizeof(TTsTime));
+ return SendReceive(EGetSchedulerItemRefAndNextDueTime, TIpcArgs(aTaskId, &pItemRef, &pDueTime));
+ }
+
+/**
+Gets the size of the data to be passed to the task's program.
+
+This function should be called before calling GetTaskInfoL() so that a descriptor
+of the correct size can be set up.
+
+@capability Note Only clients with the same SID as the relevant schedule
+creator, or WriteDeviceData capability can sucessfully call this API.
+
+@param aTaskId The Id that identifies the task.
+@param aSize The size of the task's data.
+@return KErrNone if successful, KErrNotFound if there is no task with the
+specified Id, KErrPermissionDenied if the client does not have the same SID as
+the schedules creator or has WriteDeviceData capability, otherwise any of the
+other system wide error codes.
+*/
+EXPORT_C TInt RScheduler::GetTaskDataSize(const TInt aTaskId, TInt& aSize)
+ {
+ TPckg<TInt> pSize(aSize);
+ return SendReceive(EGetTaskDataSize, TIpcArgs(aTaskId, &pSize));
+ }
+
+//Converts array of TScheduleEntryInfos to an array of TScheduleEntryInfo2s.
+void ConvertArrayToEntryInfo2L(const CArrayFixFlat<TScheduleEntryInfo>& aEntryList,
+ CArrayFixFlat<TScheduleEntryInfo2>& aEntry2List)
+ {
+ aEntry2List.ResizeL(aEntryList.Count());
+
+ TScheduleEntryInfo entryInfo;
+ for (TInt i=0; i < aEntryList.Count(); i++)
+ {
+ entryInfo = aEntryList.At(i);
+ //create new TScheduleEntryInfo2 object from old TScheduleEntryInfo object
+ //assume local time for backwards compatibility
+ TScheduleEntryInfo2 entryInfo2(entryInfo);
+ aEntry2List.At(i) = entryInfo2;
+ }
+ }
+
+//Converts array of TScheduleEntryInfo2s to an array of TScheduleEntryInfos.
+void ConvertArrayFromEntryInfo2L(const CArrayFixFlat<TScheduleEntryInfo2>& aEntry2List,
+ CArrayFixFlat<TScheduleEntryInfo>& aEntryList)
+ {
+ TScheduleEntryInfo entryInfo;
+ TScheduleEntryInfo2 entryInfo2;
+
+ aEntryList.ResizeL(aEntry2List.Count());
+ for(TInt i=0; i<aEntry2List.Count(); i++)
+ {
+ entryInfo2 = aEntry2List.At(i);
+
+ //use local time for backwards compatibility
+ entryInfo.iStartTime = entryInfo2.StartTime().GetLocalTime();
+ entryInfo.iIntervalType = entryInfo2.IntervalType();
+ entryInfo.iInterval = entryInfo2.Interval();
+ entryInfo.iValidityPeriod = entryInfo2.ValidityPeriod();
+
+ aEntryList.At(i) = entryInfo;
+ }
+ }
+
+/**
+Creates a persistent time based schedule.
+
+This schedule has no tasks associated with it but merely contains information
+about start and finish times.
+
+@capability WriteDeviceData
+@param aRef Definition of the new schedule. On return this contains a valid
+handle to the newly created schedule.
+@param aEntryList The set of schedule entries that make up the new schedule.
+Start times of all entries are assumed to be local time based.
+@return KErrNone, if successful, KErrArgument if the condition array is
+empty, or an entry has an interval less than 1, KErrServerBusy, if a backup or
+restore operation is taking place, KErrPermissionDenied if the
+client does not have WriteDeviceData capability.
+Otherwise one of the other system wide error codes.
+@see TScheduleEntryInfo
+@deprecated See note in CSch_Cli.h
+*/
+EXPORT_C TInt RScheduler::CreatePersistentSchedule(TSchedulerItemRef& aRef,
+ const CArrayFixFlat<TScheduleEntryInfo>& aEntryList)
+ {
+ //create schedule settings object
+ TScheduleSettings2 settings;
+ settings.iPersists = ETrue;
+ settings.iName = aRef.iName;
+ settings.iEntryCount = aEntryList.Count();
+
+ //create array of TScheduleEntryInfo2's from array of TScheduleEntryInfo's.
+ //assume local time for backwards compatibility.
+ CArrayFixFlat<TScheduleEntryInfo2>* entryInfo2List = new (ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1);
+ CleanupStack::PushL(entryInfo2List);
+ ConvertArrayToEntryInfo2L(aEntryList, *entryInfo2List);
+
+ //create schedule using new array of TScheduleEntryInfo2s.
+ TInt err = CreateSchedule(aRef, *entryInfo2List, settings);
+
+ CleanupStack::PopAndDestroy(entryInfo2List);
+ return err;
+ }
+
+
+
+/**
+Creates a persistent condition based schedule.
+
+This schedule has no tasks associated with it but merely contains information
+about conditions that must be satified to complete this schedule.
+
+@capability WriteDeviceData
+@param aRef Definition of the new schedule. On return this contains a valid
+handle to the newly created schedule.
+@param aConditions An array of system agent conditons
+that make up the schedule.
+@param aDefaultRunTime The time at which the schedule with run if no
+conditions are met. Default run times of all schedules created
+using this API are assumed to be local time based.
+@return KErrNone, if successful, KErrArgument if the condition array is
+empty or if the publish and subscribe variables have an invalid category.
+KErrServerBusy, if a backup or restore operation is taking place.
+KErrPermissionDenied if the client does not have WriteDeviceData capability.
+Otherwise one of the other system wide error codes.
+@see TTaskSchedulerCondition
+@internalAll
+@deprecated See note in CSch_Cli.h
+*/
+EXPORT_C TInt RScheduler::CreatePersistentSchedule(TSchedulerItemRef& aRef,
+ const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,
+ const TTime& aDefaultRunTime)
+ {
+ //create schedule settings object
+ TScheduleSettings2 settings;
+ settings.iPersists = ETrue;
+ settings.iEntryCount = aConditions.Count();
+ settings.iName = aRef.iName;
+
+ // create TTsTime object from TTime argument aDefaultRunTime.
+ // assume aDefaultTime is local time based for backwards compatibility
+ TTsTime defaultRunTime(aDefaultRunTime, EFalse);
+
+ return CreateSchedule(aRef, aConditions, defaultRunTime, settings);
+ }
+
+
+/**
+Changes a time based schedule.
+
+Note that changing a schedule is implemented by supplying a replacement set
+of schedule entries.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@param aEntryList The set of schedule entries that will make up the new schedule.
+Start times of all entries are assumed to be local time based.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrArgument if the schedule is not a time based one,
+KErrPermissionDenied if the client does not have the same SID as the schedules
+creator or has WriteDeviceData capability, KErrServerBusy, if a backup or
+restore operation is taking place or any of the other system wide error
+codes.
+@see TScheduleEntryInfo
+@deprecated See note in CSch_Cli.h
+*/
+EXPORT_C TInt RScheduler::EditSchedule(const TInt aScheduleHandle, const CArrayFixFlat<TScheduleEntryInfo>& aEntryList)
+ {
+ TInt count = aEntryList.Count();
+
+ CArrayFixFlat<TScheduleEntryInfo2>* entryInfo2List = new (ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1);
+ CleanupStack::PushL(entryInfo2List);
+
+ //creates array of TScheduleEntryInfo2's from array of TScheduleEntryInfo's.
+ //assumes local time for backwards compatibility.
+ ConvertArrayToEntryInfo2L(aEntryList, *entryInfo2List);
+
+ if (ScheduleEntriesAreBad(*entryInfo2List))
+ return KErrArgument;
+
+ TPtrC8 pA((TUint8*) &entryInfo2List->At(0), sizeof(TScheduleEntryInfo2)*count);
+ TInt err = SendReceive(EEditTimeSchedule, TIpcArgs(count, aScheduleHandle, &pA));
+ CleanupStack::PopAndDestroy(entryInfo2List);
+ return err;
+ }
+
+/**
+Changes a condition based schedule.
+
+Note that changing a schedule is implemented by supplying a replacement set
+of schedule conditons and time.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@param aConditions An array of system agent conditons
+that make up the schedule.
+@param aDefaultRunTime The time at which the schedule with run if no
+conditions are met. Note that this parameter is assumed to be local time based.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrArgument if the schedule is not a condition based one
+or if the publish and subscribe variables, defined by aConditions category
+and key values, do not exist or are not of integral type,
+KErrPermissionDenied if the client does not have the same SID as the schedules
+creator or has WriteDeviceData capability, KErrServerBusy, if a backup or
+restore operation is taking place or any of the other system wide error
+codes.
+
+@internalAll
+@deprecated See note in CSch_Cli.h
+*/
+EXPORT_C TInt RScheduler::EditSchedule(TInt aScheduleHandle,
+ const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,
+ const TTime& aDefaultRunTime)
+ {
+ TInt count = aConditions.Count();
+ TPtrC8 pA((TUint8*) &aConditions.At(0), sizeof(TTaskSchedulerCondition)*count);
+
+ // create TTsTime object from aDefaultRunTime.
+ // aDefaultRunTime is assumed to be local time based for backwards compatibility
+ TTsTime defaultRunTime(aDefaultRunTime, EFalse);
+ //write Time
+ TPckgC<TTsTime> pTime(defaultRunTime);
+ return SendReceive(EEditConditionSchedule, TIpcArgs(count, aScheduleHandle, &pA, &pTime));
+ }
+
+
+/**
+Creates a new, transient, time based schedule and adds a task to it.
+
+Note that a transient schedule is destroyed when the task is destroyed or
+power is lost.
+
+@param aTaskInfo Information about the task to be added to the transient schedule.
+On return the task Id is written into this class.
+@param aTaskData Data that is passed to the task on execution.
+@param aRef Definition of the new transient schedule.
+@param aEntryList The set of schedule entries that make up the new transient
+schedule. All entry start times are assumed to be local time based.
+@return KErrNone, if successful, otherwise one of the other system wide error
+codes.
+@panic CTaskScheduler 0 The client has not registered. The client must register
+before adding tasks to the schedule.
+@see TScheduleEntryInfo
+@deprecated See note in CSch_Cli.h
+*/
+EXPORT_C TInt RScheduler::ScheduleTask(TTaskInfo& aTaskInfo,
+ HBufC& aTaskData,
+ TSchedulerItemRef& aRef,
+ const CArrayFixFlat<TScheduleEntryInfo>& aEntryList)
+ {
+ TScheduleSettings2 settings;
+ settings.iPersists = EFalse;
+ settings.iEntryCount = aEntryList.Count();
+ settings.iName = aRef.iName;
+
+ CArrayFixFlat<TScheduleEntryInfo2>* entryInfo2List = new (ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1);
+ CleanupStack::PushL(entryInfo2List);
+
+ //creates array of TScheduleEntryInfo2's from array of TScheduleEntryInfo's.
+ //assumes local time for backwards compatibility.
+ ConvertArrayToEntryInfo2L(aEntryList, *entryInfo2List);
+
+ TInt res = CreateSchedule(aRef, *entryInfo2List, settings);
+ CleanupStack::PopAndDestroy(entryInfo2List);
+
+ if (res==KErrNone)
+ {
+ res = ScheduleTask(aTaskInfo, aTaskData, aRef.iHandle);
+ //the schedule here needs a task: so if we can't schedule a task,
+ //need to delete schedule
+ if (res!=KErrNone)
+ DeleteSchedule(aRef.iHandle);
+ }
+ return res;
+ }
+
+
+/**
+Creates a new, transient, condition based schedule and adds a task to it.
+
+Note that a transient schedule is destroyed when the task is destroyed or
+power is lost.
+
+@param aTaskInfo Information about the task to be added to the transient schedule.
+On return the task Id is written into this class.
+@param aTaskData Data that is passed to the task on execution.
+@param aRef Definition of the new transient schedule.
+@param aConditions An array of schedule conditons that make up the schedule.
+@param aDefaultRunTime The time at which the schedule with run if no
+conditions are met. aDefaultRunTime is assumed to be local time based.
+@return KErrNone, if successful, KErrArgument if the publish and subscribe
+variables, defined by aConditions category and key values, do not exist or
+are not of integral type, otherwise one of the other system wide error codes.
+@panic CTaskScheduler 0 The client has not registered. The client must register
+before adding tasks to the schedule.
+
+@internalAll
+@deprecated See note in CSch_Cli.h
+*/
+EXPORT_C TInt RScheduler::ScheduleTask(TTaskInfo& aTaskInfo,
+ HBufC& aTaskData,
+ TSchedulerItemRef& aRef,
+ const CArrayFixFlat<TTaskSchedulerCondition>& aConditions,
+ const TTime& aDefaultRunTime)
+ {
+ // create schedule settings object
+ TScheduleSettings2 settings;
+ settings.iPersists = EFalse;
+ settings.iEntryCount = aConditions.Count();
+ settings.iName = aRef.iName;
+
+ // create TTsTime object from aDefaultRunTime.
+ // assumes aDefaultRunTime is local time based for backwards compatibility
+ TTsTime defaultRunTime(aDefaultRunTime, EFalse);
+
+ TInt res = CreateSchedule(aRef, aConditions, defaultRunTime, settings);
+ if (res==KErrNone)
+ {
+ res = ScheduleTask(aTaskInfo, aTaskData, aRef.iHandle);
+ //the schedule here needs a task: so if we can't schedule a task,
+ //need to delete schedule
+ if (res!=KErrNone)
+ DeleteSchedule(aRef.iHandle);
+ }
+ return res;
+ }
+
+
+/**
+Gets information relating to a specified time based schedule.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@param aState On return, the state of the specified schedule.
+On return, aState will have a local time based iDueTime member, regardless
+of whether the schedule is UTC or local time based. If the schedule is UTC
+based, the due time will be converted to a local time based value before returning.
+@param aEntries On return, a populated array of schedule entries that make
+up the schedule. All entry start times returned will be local time based,
+though they may be UTC or local time based within the scheduler. The scheduler will
+convert any UTC based times to local time before returning.
+Note that populating the array could cause this function
+to leave because of an out of memory condition.
+@param aTasks On return, a populated array of tasks associated with the schedule.
+Note that populating the array could cause this function to leave because
+of an out of memory condition.
+@param aDueTime On return, the time that the schedule is next due. This value
+will be local time based, regardless of whether the schedule is UTC or local
+time based. If the schedule is UTC based, the due time will be converted to
+a local time based value before returning.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrArgument if the schedule is not a time based one,
+KErrPermissionDenied if the client does not have the same SID as the schedules
+creator or has WriteDeviceData capability, or any of the other system wide error
+codes.
+@see TScheduleEntryInfo
+@see TTaskInfo
+@deprecated See note in CSch_Cli.h
+*/
+EXPORT_C TInt RScheduler::GetScheduleL(const TInt aScheduleHandle,
+ TScheduleState& aState,
+ CArrayFixFlat<TScheduleEntryInfo>& aEntries,
+ CArrayFixFlat<TTaskInfo>& aTasks,
+ TTime& aDueTime)
+ {
+ // set up vars required->scheduleState, entries, and time
+ TTsTime dueTime;
+ TScheduleState2 state;
+ CArrayFixFlat<TScheduleEntryInfo2>* entryInfo2List = new (ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1);
+ CleanupStack::PushL(entryInfo2List);
+
+ // call new API
+ TInt res = GetScheduleL(aScheduleHandle,
+ state,
+ *entryInfo2List,
+ aTasks,
+ dueTime);
+
+ // convert vars back to old versions
+ // use local time for backwards compatibility
+ aDueTime = dueTime.GetLocalTime();
+ aState = TScheduleState(state);
+ ConvertArrayFromEntryInfo2L(*entryInfo2List, aEntries);
+
+ CleanupStack::PopAndDestroy(entryInfo2List);
+ return res;
+
+ }
+
+/**
+Gets information relating to a specified condition based schedule.
+
+@capability Note Only clients with the same SID as the schedule creator, or
+WriteDeviceData capability can sucessfully call this API.
+
+@param aScheduleHandle The Id that identifies the schedule.
+@param aState On return, the state of the specified schedule.
+On return, aState will have a local time based iDueTime member, regardless
+of whether the schedule is UTC or local time based. If the schedule is UTC
+based, the due time will be converted to a local time based value before returning.
+@param aConditions On return, a populated array of schedule conditons
+that make up the schedule. Note that populating the array could cause
+this function to leave because of an out of memory condition.
+@param aDefaultRunTime On return, the time at which the schedule with run if
+no conditions are met. This value will be local time based, regardless of
+whether the schedule is UTC or local time based. If the schedule is UTC based,
+the due time will be converted to a local time based value before returning.
+@param aTasks On return, a populated array of tasks associated with the schedule.
+Note that populating the array could cause this function to leave because
+of an out of memory condition.
+@return KErrNone if successful, KErrNotFound if there is no schedule with
+the specified Id, KErrArgument if the schedule is not a condition based one,
+KErrPermissionDenied if the client does not have the same SID as the schedules
+creator or has WriteDeviceData capability, or any of the other system wide error
+codes.
+@see TTaskSchedulerCondition
+@see TTaskInfo
+
+@internalAll
+@deprecated See note in CSch_Cli.h
+*/
+EXPORT_C TInt RScheduler::GetScheduleL(TInt aScheduleHandle,
+ TScheduleState& aState,
+ CArrayFixFlat<TTaskSchedulerCondition>& aConditions,
+ TTime& aDefaultRunTime,
+ CArrayFixFlat<TTaskInfo>& aTasks)
+ {
+ TScheduleInfo info;
+ TTsTime dummyTime;
+ TInt res = GetScheduleInfo(aScheduleHandle, info, dummyTime);
+ if (res != KErrNone)
+ return res;
+ aState = TScheduleState(info.iState);
+ TTsTime defaultRunTime;
+ res = GetScheduleDataL(aScheduleHandle,
+ info,
+ aConditions,
+ defaultRunTime);
+
+ //uses local time for backwards compatibility
+ aDefaultRunTime = defaultRunTime.GetLocalTime();
+
+ if (res != KErrNone)
+ return res;
+ res = GetTaskDataL(aScheduleHandle, info, aTasks);
+ return res;
+ }
+
+
+/**
+Gets information relating to a specified task.
+
+@capability Note Only clients with the same SID as the relevant schedule
+creator, or WriteDeviceData capability can sucessfully call this API.
+
+@param aTaskId The Id that identifies the task.
+@param aTaskInfo On return, information about the task.
+@param aTaskData On return, a pointer descriptor representing the data that
+is passed to the program to be executed. The caller must set up this pointer
+descriptor before calling the function. The required length of the descriptor
+can be found by calling GetTaskDataSize().
+@param aRef On return, the associated schedule definition.
+@param aNextDue On return, the time that the task is next due. This value
+will be local time based, regardless of whether the schedule is UTC or local
+time based. If the schedule is UTC based, the due time will be converted to
+a local time based value before returning.
+@return KErrNone, if successful. KErrNotFound, if there is no task with the
+specified Id, KErrPermissionDenied if the client does not have the same SID as
+the schedules creator or has WriteDeviceData capability.
+@deprecated See note in CSch_Cli.h
+*/
+EXPORT_C TInt RScheduler::GetTaskInfoL(const TInt aTaskId, TTaskInfo& aTaskInfo, TPtr& aTaskData, TSchedulerItemRef& aRef, TTime& aNextDue)
+ {
+ // First of all retrieve the normal stuff
+ TPtr8 pInfo((TUint8*)&aTaskInfo,sizeof(TTaskInfo));
+ TInt size = aTaskData.MaxLength();
+ TInt res = SendReceive(EGetTask, TIpcArgs(aTaskId, &pInfo, size, &aTaskData));
+ if (res != KErrNone)
+ return res;
+
+ // Next retrieve the TSchedulerItemRef and next due time
+ TTsTime nextDueTime;
+ TPtr8 pItemRef((TUint8*)&aRef, sizeof(TSchedulerItemRef));
+ TPtr8 pDueTime((TUint8*)&nextDueTime, sizeof(TTsTime));
+ res = SendReceive(EGetSchedulerItemRefAndNextDueTime, TIpcArgs(aTaskId, &pItemRef, &pDueTime));
+
+ // use local time for backwards compatibility
+ aNextDue = nextDueTime.GetLocalTime();
+ return res;
+ }
+
+
+//private
+// TScheduleInfo.iEntryCount is number of schedule entries for time schedules
+// and number of conditions for condition based schedules.
+TInt RScheduler::GetScheduleInfo(const TInt aScheduleHandle, TScheduleInfo& aInfo, TTsTime& aNextDue)
+ {
+ TPtr8 pInfo((TUint8*)&aInfo,sizeof(TScheduleInfo));//scheduler writes back info
+ TPtr8 pDueTime((TUint8*)&aNextDue,sizeof(TTsTime));//scheduler writes back dueTime
+ // get info for number of entries & tasks
+ TInt res = SendReceive(EGetScheduleInfo, TIpcArgs(aScheduleHandle, &pInfo, &pDueTime));
+ return res;
+ }
+
+TInt RScheduler::GetTaskDataL(const TInt aScheduleHandle,
+ const TScheduleInfo& aInfo,
+ CArrayFixFlat<TTaskInfo>& aTasks)
+ {
+ // resize array
+ aTasks.ResizeL(aInfo.iTaskCount);
+
+ // get entries & taskrefs & flags
+ TPBScheduleInfo pckgInfo(aInfo);
+ TInt res = KErrNone;
+ if (aInfo.iTaskCount > 0)
+ {
+ TPtr8 pTasks((TUint8*)&(aTasks.At(0)), aInfo.iTaskCount*sizeof(TTaskInfo));
+ res = SendReceive(EGetTaskData, TIpcArgs(aScheduleHandle, &pckgInfo, &pTasks));
+ }
+ return res;
+ }
+
+TInt RScheduler::GetScheduleDataL(const TInt aScheduleHandle,
+ const TScheduleInfo& aInfo,
+ CArrayFixFlat<TScheduleEntryInfo2>& aEntries)
+ {
+ // resize array
+ aEntries.ResizeL(aInfo.iEntryCount);
+
+ // get entries
+ TPBScheduleInfo pckgInfo(aInfo);
+ TPtr8 pEntries((TUint8*)&(aEntries.At(0)), aInfo.iEntryCount*sizeof(TScheduleEntryInfo2));
+ return SendReceive(EGetTimeScheduleData, TIpcArgs(aScheduleHandle, &pckgInfo, &pEntries));
+ }
+
+TInt RScheduler::GetScheduleDataL(const TInt aScheduleHandle,
+ const TScheduleInfo& aInfo,
+ CArrayFixFlat<TTaskSchedulerCondition>& aConditions,
+ TTsTime& aDefaultRunTime)
+ {
+ // resize arrays
+ aConditions.ResizeL(aInfo.iEntryCount);
+
+ // get entries
+ TPtr8 pDefaultTime((TUint8*)&aDefaultRunTime,sizeof(TTsTime));//scheduler writes back defaultTime
+ TPBScheduleInfo pckgInfo(aInfo);
+ TPtr8 pEntries((TUint8*)&(aConditions.At(0)), aInfo.iEntryCount*sizeof(TTaskSchedulerCondition));
+ return SendReceive(EGetConditionScheduleData, TIpcArgs(aScheduleHandle, &pckgInfo, &pEntries, &pDefaultTime));
+ }
+
+
+#if defined (_DEBUG)
+/**
+Marks the start of checking the current thread's heap.
+
+This is used for debugging, and is only implemented in debug builds.
+
+@return In debug builds, KErrNone, if successful, otherwise one of the other
+system wide error codes. In release builds, KErrNone always.
+@see __UHEAP_MARK
+@internalComponent
+*/
+EXPORT_C TInt RScheduler::__DbgMarkHeap()
+ {
+ return SendReceive(ESchDbgMarkHeap);
+ }
+
+/**
+Checks that the number of allocated cells on the current thread's heap is the
+same as the specified value.
+
+This is used for debugging, and is only implemented in debug builds.
+
+@param aCount In debug builds, the number of heap cells expected to be allocated.
+In release builds, this parameter is not used.
+@return In debug builds, KErrNone, if successful, otherwise one of the other
+system wide error codes. In release builds, KErrNone always.
+@see __UHEAP_CHECK
+@internalComponent
+*/
+EXPORT_C TInt RScheduler::__DbgCheckHeap(TInt aCount)
+ {
+ return SendReceive(ESchDbgCheckHeap,TIpcArgs(aCount));
+ }
+
+/**
+Marks the end of checking the current thread's heap.
+
+This is used for debugging, and is only implemented in debug builds.
+
+@param aCount In debug builds, the number of heap cells expected to remain
+allocated. In release builds, this parameter is not used.
+@return In debug builds, KErrNone, if successful, otherwise one of the other
+system wide error codes. In release builds, KErrNone always.
+@see __UHEAP_MARKENDC
+@internalComponent
+*/
+EXPORT_C TInt RScheduler::__DbgMarkEnd(TInt aCount)
+ {
+ return SendReceive(ESchDbgMarkEnd,TIpcArgs(aCount));
+ }
+
+/**
+Simulates heap allocation failure.
+
+This is used for debugging, and is only implemented in debug builds.
+
+@param aCount In debug builds, the rate of failure - heap allocation fails
+every aCount attempts. In release builds, this parameter is not used.
+@return In debug builds, KErrNone, if successful, otherwise one of the other
+system wide error codes. In release builds, KErrNone always.
+@see __UHEAP_FAILNEXT
+@internalComponent
+*/
+EXPORT_C TInt RScheduler::__DbgFailNext(TInt aCount)
+ {
+ return SendReceive(ESchDbgFailNext,TIpcArgs(aCount));
+ }
+
+/**
+Cancels simulated heap allocation failure for the current thread's heap.
+
+This is used for debugging, and is only implemented in debug builds.
+
+@return In debug builds, KErrNone, if successful, otherwise one of the other
+system wide error codes. In release builds, KErrNone always.
+@see __UHEAP_RESET
+@internalComponent
+*/
+EXPORT_C TInt RScheduler::__DbgResetHeap()
+ {
+ return SendReceive(ESchDbgResetHeap);
+ }
+
+
+/**
+It tries to kill the server (schsvr).
+
+This is used for debugging, and is only implemented in debug builds.
+
+@return In debug builds, KErrNone, if successful, otherwise one of the other
+system wide error codes. In release builds, KErrNone always.
+@internalComponent
+*/
+EXPORT_C TInt RScheduler::__FaultServer()
+ {
+ return SendReceive(ESchFaultServer);
+ }
+
+#else
+//release build exports empty versions of these for rel/deb compatibility
+EXPORT_C TInt RScheduler::__DbgMarkHeap()
+ {
+ return KErrNone;
+ }
+
+EXPORT_C TInt RScheduler::__DbgCheckHeap(TInt /*aCount*/)
+ {
+ return KErrNone;
+ }
+
+EXPORT_C TInt RScheduler::__DbgMarkEnd(TInt /*aCount*/)
+ {
+ return KErrNone;
+ }
+
+EXPORT_C TInt RScheduler::__DbgFailNext(TInt /*aCount*/)
+ {
+ return KErrNone;
+ }
+
+EXPORT_C TInt RScheduler::__DbgResetHeap()
+ {
+ return KErrNone;
+ }
+
+EXPORT_C TInt RScheduler::__FaultServer()
+ {
+ return KErrNone;
+ }
+
+#endif // _DEBUG
+
+
+
+
+