CServer2 Class Reference

#include <e32base.h>

class CServer2 : public CActive

Inherits from

Detailed Description

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)

Member Attribute Documentation

iSessionIter

TDblQueIter< CSession2 >iSessionIter[protected]

Member Enumeration Documentation

Enum TPanic

Enum TServerType

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

EnumeratorValueDescription
EUnsharableSessionsEIpcSession_Unsharable
ESharableSessionsEIpcSession_Sharable
EGlobalSharableSessionsEIpcSession_GlobalSharable

Constructor & Destructor Documentation

CServer2 ( TInt, TServerType )

IMPORT_CCServer2(TIntaPriority,
TServerTypeaType = 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.

Parameters
aPriorityThe priority of this active object.
aTypeIndicates 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.

~CServer2 ( )

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.

Member Function Documentation

DoCancel ( )

IMPORT_C voidDoCancel()[protected, virtual]

Reimplemented from CActive::DoCancel()

Implements the cancellation of any outstanding request for messages.

DoConnect ( const RMessage2 & )

IMPORT_C voidDoConnect(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.

Parameters
aMessageThe Connect message sent by the client requesting the connection. aMessage.Ptr0() is the required Version.

Extension_ ( TUint, TAny *&, TAny * )

IMPORT_C TIntExtension_(TUintaExtensionId,
TAny *&a0,
TAny *a1
)[protected, virtual]

Extension function

Message ( )

const RMessage2 &Message()const [protected, inline]

Gets a reference to the server's current message.

Return Value
The current message that contains the client request details.

ReStart ( )

IMPORT_C voidReStart()

Restarts the server.

The function issues a request for messages.

RunError ( TInt )

IMPORT_C TIntRunError(TIntaError)[protected, virtual]

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()

Parameters
aErrorThe leave code.
Return Value
KErrNone.

RunL ( )

IMPORT_C voidRunL()[protected, virtual]

Reimplemented from CActive::RunL()

Handles the receipt of a message.

Server ( )

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.

Return Value
The handle to the server.

SetMaster ( const CServer2 * )

IMPORT_C voidSetMaster(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.

E32USER-CBase-? When this method is invoked after the server has been started.

See also: CServer2::Start()

SetPinClientDescriptors ( TBool )

IMPORT_C voidSetPinClientDescriptors(TBoolaPin)

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()

Parameters
aPinSet to ETrue for the server to pin its client's descriptors, set to EFalse otherwise. E32USER-CBase 106 When this method is invoked after the server has been started.

Start ( const TDesC & )

IMPORT_C TIntStart(const TDesC &aName)

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.

ProtServ if aName starts with a '!' character

Parameters
aNameThe name of the server. KNullDesC, to create anonymous servers.
Return Value
KErrNone, if successful, otherwise one of the other system wide error codes.

StartL ( const TDesC & )

IMPORT_C voidStartL(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.

Parameters
aNameThe name of the server. KNullDesC, to create anonymous servers. ProtServ if aName starts with a '!' character