![[Index]](../../../stock/btn_index.gif){kind=small}
![[Glossary]](../../../stock/btn_glossary.gif){kind=small}
![[Previous]](../../../stock/btn_prev.gif){kind=small}
![[Next]](../../../stock/btn_next.gif){kind=small}
| |
|
| |
Location:
e32base.h
Link against: euser.lib
CActiveScheduler
Supported from 5.0
Controls the handling of asynchronous requests as represented by active objects.
An active scheduler is used to schedule the sequence in which active object request completion events are handled by a single event-handling thread.
An active scheduler can be instantiated and used directly if either:
the RunL() function of all of its active objects
is guaranteed not to leave
or:
each of its active objects implements a suitable
RunError() function to provide suitable cleanup
If any of the active scheduler's active objects does not provide a
RunError() function, then a CActiveScheduler derived
class must be defined and an implementation of the Error()
function provided to perform the cleanup required.
There is one active scheduler per thread and the static functions provided by the class always refer to the current active scheduler.
|
Defined in CActiveScheduler:
Add(), CActiveScheduler(), Current(), Error(), Install(), OnStarting(), OnStopping(), Replace(), RunIfReady(), Start(), Stop(), WaitForAnyRequest(), ~CActiveScheduler()
Inherited from CBase:
operator new()
CActiveScheduler();
Constructs an active scheduler. After construction, the scheduler should be installed.
~CActiveScheduler();
Frees resources prior to destruction. Specifically, it removes all active objects from the active scheduler’s list of active objects.
An active scheduler should only be destroyed when the top-level
call to Start() has returned.
|
virtual void WaitForAnyRequest();
Wait for an asynchronous request to complete.
The default implementation just calls
User::WaitForAnyRequest().
Derived classes can replace this. Typically, this would be done to
implement code for maintaining an outstanding request; this would be followed
by a call to User::WaitForAnyRequest().
virtual void Error(TInt anError) const;
Handles the result of a leave occurring in an active object’s
RunL() function. An active scheduler always invokes an active
object’s RunL() function under a trap harness.
The default implementation raises an E32USER-CBase 47 panic and must
be replaced. Any cleanup relevant to the possible causes of leaving should be
performed. If Stop() is called from within this function, the
current wait loop terminates. This may be an appropriate response to
catastrophic error conditions.
|
private: virtual void OnStarting();
Supported from 6.0
Called when the Active Scheduler is started.
Derived classes can override this. The default implementation does nothing.
private: virtual void OnStopping();
Supported from 6.0
Called when the Active Scheduler is stopped.
Derived classes can override this. The default implementation does nothing.
|
static void Install(CActiveScheduler* aScheduler);
Installs the specified active scheduler as the current active scheduler. The installed active scheduler now handles events for this thread.
The current active scheduler can be uninstalled by passing a NULL pointer.
|
static void Add(CActive* anActive);
Adds the specified active object to the current active scheduler.
An active object can be removed from an active scheduler either by destroying the active object or by using its Deque() member function.
The thread must have an active scheduler installed, otherwise the function raises an E32USER-CBase 44 panic.
|
static CActiveScheduler* Replace(CActiveScheduler* aNewActiveScheduler);
Supported from 6.0
Allows the current active scheduler to be replaced, while retaining its active objects.
|
|
|
static TBool RunIfReady(TInt& aError, TInt aMinimumPriority);
Supported from 6.0
Causes the RunL() function of at most one pending active object of priority aMinimumPriority or greater to be run.
|
|
static void Start();
Starts a new wait loop under the control of the current active scheduler.
At least one active object, with an outstanding request, must be added to the scheduler before the wait loop is started, otherwise no events will occur and the thread will hang or any events that do occur will be counted as stray signals, raising a panic.
While Start() is executing, user code runs only:
in the RunL() function of active objects known to the
current active scheduler
in the current active scheduler’s Error() function,
if an active object’s RunL() leaves.
Start() returns only when a corresponding
Stop() is issued.
Nested wait loops can also be started. Typically, a nested wait loop is used when the handling of a completed event in an active object requires processing further events from the other active objects before it can complete. This is a form of modal processing.
The thread must have an active scheduler installed, otherwise the function raises an E32USER-CBase 44 panic.
static void Stop();
Stops the wait loop started by the most recent call to
Start().
Typically, this is called by the RunL() of one of the
scheduler’s active objects. When this RunL() finishes, the
scheduler’s wait loop terminates, i.e. it does not wait for the
completion of the next request.
Stop() may also be called from Error().
|
static CActiveScheduler* Current();
Returns a pointer to the currently installed active scheduler.
|
Copyright ©2002 Symbian Ltd. 6.1-00174 |
|
![[Top]](../../../stock/arrow_up_2.gif){kind=icon}
![[Top]](../../../stock/arrow_up.gif){kind=icon}