#include <e32base.h>
| class CServer2 : public CActive |
| Protected Attributes | |
|---|---|
| TDblQueIter< CSession2 > | iSessionIter |
| Public Member Enumerations | |
|---|---|
| enum | TPanic { EBadMessageNumber, ESessionNotConnected, ESessionAlreadyConnected, EClientDoesntHaveRequiredCaps } |
| enum | TServerType { EUnsharableSessions, ESharableSessions, EGlobalSharableSessions } |
| Public Member Functions | |
|---|---|
| pure virtual | ~CServer2() |
| IMPORT_C void | ReStart() |
| RServer2 | Server() |
| IMPORT_C void | SetMaster(const CServer2 *) |
| IMPORT_C void | SetPinClientDescriptors(TBool) |
| IMPORT_C TInt | Start(const TDesC &) |
| IMPORT_C void | StartL(const TDesC &) |
| Protected Member Functions | |
|---|---|
| CServer2(TInt, TServerType) | |
| virtual IMPORT_C void | DoCancel() |
| virtual IMPORT_C void | DoConnect(const RMessage2 &) |
| virtual IMPORT_C TInt | Extension_(TUint, TAny *&, TAny *) |
| const RMessage2 & | Message() |
| virtual IMPORT_C TInt | RunError(TInt) |
| virtual IMPORT_C void | RunL() |
| Inherited Attributes | |
|---|---|
| CActive::iStatus | |
| Inherited Enumerations | |
|---|---|
| CActive:TPriority | |
Abstract base class for servers (version 2).
This is an active object. It accepts requests from client threads and forwards them to the relevant server-side client session. It also handles the creation of server-side client sessions as a result of requests from client threads.
A server must define and implement a derived class.
(Note that this class should be used instead of CServer)
This enumeration defines the maximum sharability of sessions opened with this server; for backwards compatibilty, these should be have the same values as the corresponding EIpcSessionType enumeration
| IMPORT_C | CServer2 | ( | TInt | aPriority, |
| TServerType | aType = EUnsharableSessions | |||
| ) | [protected] | |||
Constructs the server object, specifying the server type and the active object priority.
Derived classes must define and implement a constructor through which the priority can be specified. A typical implementation calls this server base class constructor through a constructor initialization list.
| Parameter | Description |
|---|---|
| aPriority | The priority of this active object. |
| aType | Indicates the type of session that the server creates. If not explicitly stated, then the server creates a session that is not sharable with other threads. |
| IMPORT_C | ~CServer2 | ( | ) | [pure virtual] |
Frees resources prior to destruction.
Specifically, it cancels any outstanding request for messages, and deletes all server-side client session objects.
| IMPORT_C void | DoCancel | ( | ) | [protected, virtual] |
Reimplemented from CActive::DoCancel()
Implements the cancellation of any outstanding request for messages.
| IMPORT_C void | DoConnect | ( | const RMessage2 & | aMessage | ) | [protected, virtual] |
Handles the connect request from the client. We trap Leaves, to ensure that existing sessions aren't affected by failure to create a new one.
| Parameter | Description |
|---|---|
| aMessage | The Connect message sent by the client requesting the connection. aMessage.Ptr0() is the required Version. |
Reimplemented from CActive::Extension_(TUint,TAny *&,TAny *)
Extension function
| const RMessage2 & | Message | ( | ) | const [protected, inline] |
Gets a reference to the server's current message.
Returns: The current message that contains the client request details.
Reimplemented from CActive::RunError(TInt)
Handles the situation where a call to CServer2::RunL(), leaves.
This is the server active object's implementation of the active object framework's RunError() function.
In practice, the leave can only be caused by a session's ServiceL() function, which is called from this RunL(); this error is reflected back to that session by calling its ServiceError() function.
See also: CActive::RunL() CActive::RunError() CSession2::ServiceError()
| Parameter | Description |
|---|---|
| aError | The leave code. |
Returns: KErrNone.
| IMPORT_C void | RunL | ( | ) | [protected, virtual] |
Reimplemented from CActive::RunL()
Handles the receipt of a message.
| RServer2 | Server | ( | ) | const [inline] |
Gets a handle to the server.
Note that the RServer2 object is classified as Symbian internal, and its member functions cannot be acessed. However, the handle can be passed to the RSessionBase::CreateSession() variants that take a server handle.
Returns: The handle to the server.
| IMPORT_C void | SetMaster | ( | const CServer2 * | aServer | ) |
Assigns a role (master or slave) for this server.
The master server is typically named, and receives all Connect messages from clients. It can hand off some sessions to be processed by one or more anonymous slave servers, each running in a separate thread.
Both master and slave servers must call this function before calling Start(), in order to define their roles. Once the server is started, its role cannot be changed.
See also: CServer2::Start()
| IMPORT_C void | SetPinClientDescriptors | ( | TBool | aPin | ) |
Sets whether the kernel will pin descriptors passed to this server in the context of the client thread.
Setting this is one way of ensuring that the server will not take page faults when accessing client descriptors, which would otherwise happen if the data was paged out.
This method overrides the default pinning policy of the server which is for the server to pin its client's descriptors if the process creating the server is not data paged. I.e. if CServer2::SetPinClientDescriptors() is not invoked on the server and RProcess::DefaultDataPaged() of the process creating the server returns EFalse, the server will pin its client's descriptors, otherwise the server will not pin its client's descriptors.
This method must be called prior to starting the server by calling the Start() method.
See also: CServer2::Start()
| Parameter | Description |
|---|---|
| aPin | Set to ETrue for the server to pin its client's descriptors, set to EFalse otherwise. |
Adds the server with the specified name to the active scheduler, and issues the first request for messages.
If KNullDesC is specified for the name, then an anonymous server will be created. To create a session to such a server, an overload of RSessionBase::CreateSession() which takes RServer2 object as a parameter can be used.
| Parameter | Description |
|---|---|
| aName | The name of the server. KNullDesC, to create anonymous servers. |
Returns: KErrNone, if successful, otherwise one of the other system wide error codes.
| IMPORT_C void | StartL | ( | const TDesC & | aName | ) |
Adds the server with the specified name to the active scheduler, and issues the first request for messages, and leaves if the operation fails.
If KNullDesC is specified for the name, then an anonymous server will be created. To create a session to such a server, the overload of RSessionBase::CreateSession() which takes an RServer2 object as a parameter can be used.
| Parameter | Description |
|---|---|
| aName | The name of the server. KNullDesC, to create anonymous servers. |