CMceCsSubSession Class Reference

class CMceCsSubSession : public CBase

Client-Server sub-session is the base class for SIP sessions, which have created to encapsulate SIP dialogs. This class provides methods to handle CS subsession specifig ITC functions and to receive SIP requests and responses.

Since

Inherits from

Public Member Functions
~CMceCsSubSession()
TBool AcceptDialogTransaction(CSIPServerTransaction &)
TBool AcceptMethod(RStringF)
TBool AcceptStandAloneTransaction(CSIPServerTransaction &)
TBool AutoEvent()
TBool CanDispose()
voidCanceled()
CMceCsSessionImplementation &Client()
TBool ClientExists()
TMceCsSessionType ClientType()
voidConnectionStateChanged(CSIPConnection::TState)
TBool Consumes(CSIPDialog &, CSIPServerTransaction &, TBool &)
TBool Consumes(CSIPTransactionBase &)
CSIPDialogAssocBase *CreateIncomingDialogL(CSIPServerTransaction &)
CSIPDialogAssocBase *CreateOutgoingDialogL(TMceDialogType, CDesC8Array &, CSIPDialog &)
CSIPDialogAssocBase *CreateOutgoingDialogL(TMceDialogType, CDesC8Array &)
CDesC8Array &DefaultHeaders(TInt)
CSIPDialogAssocBase *Dialog()
TUint32 DialogId()
TBool DialogRequestReceived(CSIPServerTransaction *, CSIPDialog &)
voidDialogResponseReceived(CSIPClientTransaction &)
voidDoConnectionStateChanged(TBool)
voidDoErrorOccured(TInt, CSIPTransactionBase &)
voidDoInitializeIncomingDialogL(CSIPServerTransaction &)
HBufC8 *DoServiceL(TMceIds &, TMceItcFunctions)
voidDoServiceL(TMceIds &, TMceItcFunctions, const TDesC8 &)
voidDoServiceL(TMceIds &, TMceItcFunctions, TPtr8 &)
voidDoServiceL(TMceIds &, TMceItcFunctions, CMceMsgBase &)
voidErrorOccured(TInt, CSIPTransactionBase &)
voidErrorOccured(TInt)
voidErrorResponseReceived()
const CFCSession *FCSession()
CSIPServerTransaction &InitialRequest()
voidInitializeIncomingDialogL(CSIPServerTransaction *)
voidInviteCompleted(CSIPClientTransaction &)
TBool IsProfileContactSecureL()
CMceSipManager &Manager()
TBool MessageRequestReceived(CSIPServerTransaction *)
voidMessageResponseReceived(CSIPClientTransaction &)
TInetAddr *NextHopL(TInetAddr &)
const RPointerArray< CSIPServerTransaction > &PendingReceivedRequests()
CSIPClientTransaction *PendingTransaction(RStringF)
const RPointerArray< CSIPClientTransaction > &PendingTransactions()
HBufC8 *PopClientContent()
CSIPServerTransaction *PopRequest()
CSIPClientTransaction *PopResponse()
CSIPProfile &Profile()
TBool ProfileConfigured()
voidProvisionalResponseReceived()
voidRedirectionResponseReceived()
voidRemoveCompletedRequests(TBool)
TBool RemovePendingTrx(CSIPClientTransaction &)
CSIPServerTransaction &Request()
voidRequestReceived(TBool, CSIPDialog &)
voidResetInitialInvite()
CSIPClientTransaction &Response()
voidResponseReceived()
voidResponseReceivedWithinDialog(CSIPClientTransaction &, CSIPDialogAssocBase &)
CMceSipConnection &SIPConnection()
TInt SendErrorToClient(TMceIds &, TInt)
TInt SendToClient(TMceIds &)
voidSendToClientL(TMceIds &, HBufC8 *, HBufC8 *)
CMceServerCore &ServerCore()
voidServiceL(TMceIds &, TMceItcFunctions, const RMessage2 &)
voidSetAutoEvent(TBool)
voidSetDialog(TType, CSIPDialogAssocBase *, TUint32)
voidSetPendingTransactionL(CSIPClientTransaction *)
voidSetProfile(CSIPProfile &)
voidStandAloneRequestReceived()
voidStandAloneResponseReceived(TMceSipResponseType)
voidStoreAutoEventL(TMceStateTransitionEvent *, CSIPServerTransaction *)
voidStoreClientContent(HBufC8 *)
TMceStateTransitionEvent *StoredAutoEvent()
TBool Terminate()
TType Type()
Protected Member Functions
CMceCsSubSession(TMceCsSessionType, CMceCsSession &, CMceSipConnection &)
CMceCsSubSession(TMceCsSessionType, CMceCsSession &, CMceSipConnection &, CSIPProfile &)
voidConstructL(CMceCsSession &)
TBool HasInitialInviteTransactionBeenCompleted()
TBool IsOrphan()
Private Member Functions
voidCancelClientReceiveL()
voidClientReadyToReceiveL(const RMessage2 &)
voidDoServiceL(TMceIds &, TMceItcFunctions, const RMessage2 &)
voidReceiveL(const RMessage2 &)
voidRegisterDialogAssoc(CSIPDialogAssocBase &)
TBool RemovePendingCompletedTrx(CSIPClientTransaction &)
voidSetClient(CMceCsSessionImplementation &)
voidSetResponse(CSIPClientTransaction &)
voidSetSessionReceiver(CMceCsSubSessionReceiver *)
Inherited Functions
CBase::CBase()
CBase::Delete(CBase *)
CBase::Extension_(TUint,TAny *&,TAny *)
CBase::operator new(TUint)
CBase::operator new(TUint,TAny *)
CBase::operator new(TUint,TLeave)
CBase::operator new(TUint,TLeave,TUint)
CBase::operator new(TUint,TUint)
CBase::~CBase()
Public Member Enumerations
enumTType { EUnknown = -1, EInSession, EOutSession, EOutSIPSession }
Protected Attributes
TMceStateTransitionEvent *iAutoEvent
CSIPServerTransaction *iAutoEventAssociatedRequest
TBool iAutoEventEnabled
TMceIds *iAutoEventIds
CMceMsgBase *iAutoEventMsg
CSIPDialogAssocBase *iCurrentDialog
TMceStateTransitionEvent *iCurrentlyProcessedAutoEvent
CSIPDialogAssocBase *iDialog
CFCSession *iFCSession
RPointerArray< CSIPServerTransaction >iPendingReceivedRequests
RPointerArray< CSIPClientTransaction >iPendingTransactions
Private Attributes
HBufC8 *iClientContent
TBool iClientExists
CMceCsSessionImplementation *iClientSession
TMceCsSessionType iClientType
TUint32 iDialogId
CSIPClientTransaction *iInitialInvite
CSIPProfile *iProfile
CMceCsSubSessionReceiver *iReceiver
CSIPClientTransaction *iResponse
CMceSipConnection &iSIPConnection
CMceServerCore &iServerCore
TType iType

Constructor & Destructor Documentation

CMceCsSubSession(TMceCsSessionType, CMceCsSession &, CMceSipConnection &)

CMceCsSubSession(TMceCsSessionTypeaType,
CMceCsSession &aClientSession,
CMceSipConnection &aSIPConnection
)[protected]

Parameters

TMceCsSessionType aType
CMceCsSession & aClientSession
CMceSipConnection & aSIPConnection

CMceCsSubSession(TMceCsSessionType, CMceCsSession &, CMceSipConnection &, CSIPProfile &)

CMceCsSubSession(TMceCsSessionTypeaType,
CMceCsSession &aClientSession,
CMceSipConnection &aSIPConnection,
CSIPProfile &aProfile
)[protected]

Parameters

TMceCsSessionType aType
CMceCsSession & aClientSession
CMceSipConnection & aSIPConnection
CSIPProfile & aProfile

~CMceCsSubSession()

~CMceCsSubSession()

Destructor.

Member Functions Documentation

AcceptDialogTransaction(CSIPServerTransaction &)

TBool AcceptDialogTransaction(CSIPServerTransaction &aTransaction)[virtual]

Returns ETrue, if session accepts transaction

Parameters

CSIPServerTransaction & aTransactionnew (incoming) transaction

AcceptMethod(RStringF)

TBool AcceptMethod(RStringFaMethod)[pure virtual]

Checks if session accepts method of incoming request

Parameters

RStringF aMethodthe method

AcceptStandAloneTransaction(CSIPServerTransaction &)

TBool AcceptStandAloneTransaction(CSIPServerTransaction &aTransaction)[virtual]

Returns ETrue, if session accepts stand-alone transaction

Parameters

CSIPServerTransaction & aTransactionnew (incoming) stand-alone transaction

AutoEvent()

TBool AutoEvent()

Checks whether the session should automatically generate an event at next state change.

CanDispose()

TBool CanDispose()[pure virtual]

Returns ETrue, if session can be deleted

CancelClientReceiveL()

voidCancelClientReceiveL()[private]

Canceled()

voidCanceled()[pure virtual]

Handles situation where incoming INVITE was canceled with the CANCEL

Client()

CMceCsSessionImplementation &Client()const

Returns client

ClientExists()

TBool ClientExists()

Returns ETrue, if client has called ready to receive

ClientReadyToReceiveL(const RMessage2 &)

voidClientReadyToReceiveL(const RMessage2 &aMessage)[private]

Parameters

const RMessage2 & aMessage

ClientType()

TMceCsSessionType ClientType()const

Returns client type of session. The type represents type of dialog used in session.

ConnectionStateChanged(CSIPConnection::TState)

voidConnectionStateChanged(CSIPConnection::TStateaState)

Handles situation where SIP connection state has changed. If connection state has changed to EInactive or EUnavailable, SIP stack terminates all pending SIP client transactions and no errors are reported back to the client about the terminated transactions.

Parameters

CSIPConnection::TState aStateindicates the current connection state

ConstructL(CMceCsSession &)

voidConstructL(CMceCsSession &aClientSession)[protected]

Parameters

CMceCsSession & aClientSession

Consumes(CSIPDialog &, CSIPServerTransaction &, TBool &)

TBool Consumes(CSIPDialog &aDialog,
CSIPServerTransaction &aTransaction,
TBool &aAssociatesWithDialog
)[virtual]

Returns ETrue, if session will consume the transaction

Parameters

CSIPDialog & aDialogSIP dialog
CSIPServerTransaction & aTransactionthe pending transaction
TBool & aAssociatesWithDialog

Consumes(CSIPTransactionBase &)

TBool Consumes(CSIPTransactionBase &aTransaction)[virtual]

Returns ETrue, if session will consume the transaction

Parameters

CSIPTransactionBase & aTransactionpending or new (incoming) transaction

CreateIncomingDialogL(CSIPServerTransaction &)

CSIPDialogAssocBase *CreateIncomingDialogL(CSIPServerTransaction &aInitialRequest)[pure virtual]

Creates new incoming dialog (association)

Parameters

CSIPServerTransaction & aInitialRequestrequest causing creation

CreateOutgoingDialogL(TMceDialogType, CDesC8Array &, CSIPDialog &)

CSIPDialogAssocBase *CreateOutgoingDialogL(TMceDialogTypeaDialogType,
CDesC8Array &aParams,
CSIPDialog &aExistingDialog
)[pure virtual]

Creates new outgoing dialog (association) from existing dialog

Parameters

TMceDialogType aDialogTypetype of new dialog
CDesC8Array & aParamsparameters for creation
CSIPDialog & aExistingDialogexisting dialog

CreateOutgoingDialogL(TMceDialogType, CDesC8Array &)

CSIPDialogAssocBase *CreateOutgoingDialogL(TMceDialogTypeaDialogType,
CDesC8Array &aParams
)[pure virtual]

Creates outgoing dialog (association) based on given parameters

Parameters

TMceDialogType aDialogTypetype of new dialog
CDesC8Array & aParamsparameters for creation

DefaultHeaders(TInt)

CDesC8Array &DefaultHeaders(TIntaMethodInd)

Returns the default headers

Parameters

TInt aMethodIndthe methond index in SIP strings

Dialog()

CSIPDialogAssocBase *Dialog()const [virtual]

Returns SIP dialog (assoc)

DialogId()

TUint32 DialogId()const

Returns dialog id

DialogRequestReceived(CSIPServerTransaction *, CSIPDialog &)

TBool DialogRequestReceived(CSIPServerTransaction *aTransaction,
CSIPDialog &aDialog
)

Handles SIP request, which has been received inside a dialog

Parameters

CSIPServerTransaction * aTransactionserver transaction representing a request
CSIPDialog & aDialogdialog to wich transaction belongs

DialogResponseReceived(CSIPClientTransaction &)

voidDialogResponseReceived(CSIPClientTransaction &aTransaction)

Handles SIP response, which has been received inside a dialog

Parameters

CSIPClientTransaction & aTransactionclient transaction representing a response

DoConnectionStateChanged(TBool)

voidDoConnectionStateChanged(TBoolaIsActive)[pure virtual]

Handles situation where SIP connection state has changed. If connection state has changed to EInactive or EUnavailable, SIP stack terminates all pending SIP client transactions and no errors are reported back to the client about the terminated transactions.

Parameters

TBool aIsActiveindicates if the current connection is active

DoErrorOccured(TInt, CSIPTransactionBase &)

voidDoErrorOccured(TIntaError,
CSIPTransactionBase &aTransaction
)[pure virtual]

Handles situation where an asynchronous error has occured related to a request within an existing dialog.

Parameters

TInt aErrorerror code
CSIPTransactionBase & aTransactionthe transaction

DoInitializeIncomingDialogL(CSIPServerTransaction &)

voidDoInitializeIncomingDialogL(CSIPServerTransaction &aTransaction)[pure virtual]

Initializes incoming dialog

Parameters

CSIPServerTransaction & aTransactionserver transaction representing a request, which caused dialog creation

DoServiceL(TMceIds &, TMceItcFunctions)

HBufC8 *DoServiceL(TMceIds &aIds,
TMceItcFunctionsaFunction
)[virtual]

Executes ITC function called by client. Default implementation leaves with KErrNotSupported

Parameters

TMceIds & aIdsset of ids defining ITC call context
TMceItcFunctions aFunctionITC function to be executed

DoServiceL(TMceIds &, TMceItcFunctions, const TDesC8 &)

voidDoServiceL(TMceIds &aIds,
TMceItcFunctionsaFunction,
const TDesC8 &aMessage
)[virtual]

Executes ITC function called by client. Default implementation leaves with KErrNotSupported

Parameters

TMceIds & aIdsset of ids defining ITC call context
TMceItcFunctions aFunctionITC function to be executed
const TDesC8 & aMessagemessage context from client

DoServiceL(TMceIds &, TMceItcFunctions, TPtr8 &)

voidDoServiceL(TMceIds &aIds,
TMceItcFunctionsaFunction,
TPtr8 &aMessage
)[virtual]

Executes ITC function called by client. Default implementation leaves with KErrNotSupported

Parameters

TMceIds & aIdsset of ids defining ITC call context
TMceItcFunctions aFunctionITC function to be executed
TPtr8 & aMessagemessage context from client

DoServiceL(TMceIds &, TMceItcFunctions, CMceMsgBase &)

voidDoServiceL(TMceIds &aIds,
TMceItcFunctionsaFunction,
CMceMsgBase &aMessage
)[virtual]

Executes ITC function called by client. Default implementation leaves with KErrNotSupported

Parameters

TMceIds & aIdsset of ids defining ITC call context
TMceItcFunctions aFunctionITC function to be executed
CMceMsgBase & aMessagedecoded message context from client

DoServiceL(TMceIds &, TMceItcFunctions, const RMessage2 &)

voidDoServiceL(TMceIds &aIds,
TMceItcFunctionsaFunction,
const RMessage2 &aMessage
)[private]

Parameters

TMceIds & aIds
TMceItcFunctions aFunction
const RMessage2 & aMessage

ErrorOccured(TInt, CSIPTransactionBase &)

voidErrorOccured(TIntaError,
CSIPTransactionBase &aTransaction
)[virtual]

Handles situation where an asynchronous error has occured related to a request within an existing dialog.

Parameters

TInt aErrorerror code
CSIPTransactionBase & aTransactionthe transaction

ErrorOccured(TInt)

voidErrorOccured(TIntaError)[pure virtual]

Called when error has been occured within dialog

Parameters

TInt aErrorerror code

ErrorResponseReceived()

voidErrorResponseReceived()[pure virtual]

Called when error response (4XX-7XX) has been received to pending transaction. Response can be obtained by calling Response() method

FCSession()

const CFCSession *FCSession()const

Returns floor control session instance

HasInitialInviteTransactionBeenCompleted()

TBool HasInitialInviteTransactionBeenCompleted()const [protected]

InitialRequest()

CSIPServerTransaction &InitialRequest()const

Returns initial request which caused session creation.

InitializeIncomingDialogL(CSIPServerTransaction *)

voidInitializeIncomingDialogL(CSIPServerTransaction *aTransaction)

Initializes incoming dialog

Parameters

CSIPServerTransaction * aTransactionserver transaction representing a request, which caused dialog creation

InviteCompleted(CSIPClientTransaction &)

voidInviteCompleted(CSIPClientTransaction &aTransaction)[virtual]

Parameters

CSIPClientTransaction & aTransaction

IsOrphan()

TBool IsOrphan()[protected]

IsProfileContactSecureL()

TBool IsProfileContactSecureL()

Check Profile contact secure status

Manager()

CMceSipManager &Manager()const

Returns SIP manager instance

MessageRequestReceived(CSIPServerTransaction *)

TBool MessageRequestReceived(CSIPServerTransaction *aTransaction)

Handles SIP request, which has been received outside a dialog

Parameters

CSIPServerTransaction * aTransactionserver transaction representing a request

MessageResponseReceived(CSIPClientTransaction &)

voidMessageResponseReceived(CSIPClientTransaction &aTransaction)

Handles SIP response, which has been received outside a dialog

Parameters

CSIPClientTransaction & aTransactionclient transaction representing a response

NextHopL(TInetAddr &)

TInetAddr *NextHopL(TInetAddr &aNextHop)

Return NextHop

Parameters

TInetAddr & aNextHop

PendingReceivedRequests()

const RPointerArray< CSIPServerTransaction > &PendingReceivedRequests()

PendingTransaction(RStringF)

CSIPClientTransaction *PendingTransaction(RStringFaType)

Returns pending transaction based on type

Parameters

RStringF aTypetype of transaction

PendingTransactions()

const RPointerArray< CSIPClientTransaction > &PendingTransactions()

Returns all pending transactions

PopClientContent()

HBufC8 *PopClientContent()

Transferes ownership of client message content

PopRequest()

CSIPServerTransaction *PopRequest()

Transferes ownership of current (pending) request

PopResponse()

CSIPClientTransaction *PopResponse()

Transferes ownership of current (pending) response

Profile()

CSIPProfile &Profile()const

Return profile

ProfileConfigured()

TBool ProfileConfigured()const

Checks if profile configured.

ProvisionalResponseReceived()

voidProvisionalResponseReceived()[pure virtual]

Called when response (1XX) has been received to pending transaction. Response can be obtained by calling Response() method

ReceiveL(const RMessage2 &)

voidReceiveL(const RMessage2 &aMessage)[private]

Parameters

const RMessage2 & aMessage

RedirectionResponseReceived()

voidRedirectionResponseReceived()[pure virtual]

Called when response (3XX) has been received to pending transaction. Response can be obtained by calling Response() method

RegisterDialogAssoc(CSIPDialogAssocBase &)

voidRegisterDialogAssoc(CSIPDialogAssocBase &aDialogAssoc)[private]

Parameters

CSIPDialogAssocBase & aDialogAssoc

RemoveCompletedRequests(TBool)

voidRemoveCompletedRequests(TBoolaAll = EFalse)

Parameters

TBool aAll = EFalse

RemovePendingCompletedTrx(CSIPClientTransaction &)

TBool RemovePendingCompletedTrx(CSIPClientTransaction &aTransaction)[private]

Parameters

CSIPClientTransaction & aTransaction

RemovePendingTrx(CSIPClientTransaction &)

TBool RemovePendingTrx(CSIPClientTransaction &aTransaction)

Removes the pending transaction.

Parameters

CSIPClientTransaction & aTransactionthe transaction to be removed

Request()

CSIPServerTransaction &Request()const

Returns current (pending) request

RequestReceived(TBool, CSIPDialog &)

voidRequestReceived(TBoolaInsideDialog,
CSIPDialog &aDialog
)[pure virtual]

Called when request has been received. Request can be obtained by calling Request() method

Parameters

TBool aInsideDialogtells whether request was received inside dialog
CSIPDialog & aDialog

ResetInitialInvite()

voidResetInitialInvite()

Resets the initial INVITE.

Response()

CSIPClientTransaction &Response()const

Returns current (pending) response

ResponseReceived()

voidResponseReceived()[pure virtual]

Called when response (2XX) has been received to pending transaction. Response can be obtained by calling Response() method

ResponseReceivedWithinDialog(CSIPClientTransaction &, CSIPDialogAssocBase &)

voidResponseReceivedWithinDialog(CSIPClientTransaction &aTransaction,
CSIPDialogAssocBase &aDialogAssoc
)

Handles SIP request, which has been received inside a dialog. this will call DialogResponseReceived

Parameters

CSIPClientTransaction & aTransactionserver transaction representing a request
CSIPDialogAssocBase & aDialogAssocthe dialog

SIPConnection()

CMceSipConnection &SIPConnection()const

Returns SIP connection instance

SendErrorToClient(TMceIds &, TInt)

TInt SendErrorToClient(TMceIds &aIds,
TIntaError
)

Sends error via callback mechanism to client session

Parameters

TMceIds & aIdsset of ids defining ITC callback context
TInt aErrorthe error

SendToClient(TMceIds &)

TInt SendToClient(TMceIds &aIds)

Sends data via callback mechanism to client session

Parameters

TMceIds & aIdsset of ids defining ITC callback context

SendToClientL(TMceIds &, HBufC8 *, HBufC8 *)

voidSendToClientL(TMceIds &aIds,
HBufC8 *aContext,
HBufC8 *aContent
)

Sends data via callback mechanism to client session

Parameters

TMceIds & aIdsset of ids defining ITC callback context
HBufC8 * aContextencoded context of message
HBufC8 * aContentcontent of message

ServerCore()

CMceServerCore &ServerCore()const

Returns server core instance

ServiceL(TMceIds &, TMceItcFunctions, const RMessage2 &)

voidServiceL(TMceIds &aIds,
TMceItcFunctionsaFunction,
const RMessage2 &aMessage
)

Executes ITC function called by client

Parameters

TMceIds & aIdsset of ids defining ITC call context
TMceItcFunctions aFunctionITC function to be executed
const RMessage2 & aMessagemessage from the client.

SetAutoEvent(TBool)

voidSetAutoEvent(TBoolaIsEnabled)

Controls whether the session should generate automatically event at next state change.

Parameters

TBool aIsEnabled

SetClient(CMceCsSessionImplementation &)

voidSetClient(CMceCsSessionImplementation &aClient)[private]

Parameters

CMceCsSessionImplementation & aClient

SetDialog(TType, CSIPDialogAssocBase *, TUint32)

voidSetDialog(TTypeaType,
CSIPDialogAssocBase *aDialog,
TUint32aDialogId
)

Stores SIP dialog

Parameters

TType aTypethe type of session
CSIPDialogAssocBase * aDialogSIP dialog
TUint32 aDialogIdgenerated dialog id

SetPendingTransactionL(CSIPClientTransaction *)

voidSetPendingTransactionL(CSIPClientTransaction *aTransaction)

Sets client transaction which is waiting response from peer

Parameters

CSIPClientTransaction * aTransactionthe pending transaction

SetProfile(CSIPProfile &)

voidSetProfile(CSIPProfile &aProfile)

Set profile

Parameters

CSIPProfile & aProfileProfile to be used

SetResponse(CSIPClientTransaction &)

voidSetResponse(CSIPClientTransaction &aTransaction)[private]

Parameters

CSIPClientTransaction & aTransaction

SetSessionReceiver(CMceCsSubSessionReceiver *)

voidSetSessionReceiver(CMceCsSubSessionReceiver *aSessionReceiver)[private]

Parameters

CMceCsSubSessionReceiver * aSessionReceiver

StandAloneRequestReceived()

voidStandAloneRequestReceived()[pure virtual]

Called when stand-alone request has been received. Request can be obtained by calling Request() method

StandAloneResponseReceived(TMceSipResponseType)

voidStandAloneResponseReceived(TMceSipResponseTypeaResponseType)[pure virtual]

Called when stand-alone response (any) has been received to pending transaction. Response can be obtained by calling Response() method

Parameters

TMceSipResponseType aResponseTyperesponse type

StoreAutoEventL(TMceStateTransitionEvent *, CSIPServerTransaction *)

voidStoreAutoEventL(TMceStateTransitionEvent *aEvent,
CSIPServerTransaction *aAssociatedRequest
)

Stores event which will be used when automatic event generation occurs. Request which is associated with the event may be defined.

Parameters

TMceStateTransitionEvent * aEvent
CSIPServerTransaction * aAssociatedRequest

StoreClientContent(HBufC8 *)

voidStoreClientContent(HBufC8 *aClientContent)

Stores client's message content

Parameters

HBufC8 * aClientContentthe message content

StoredAutoEvent()

TMceStateTransitionEvent *StoredAutoEvent()

Returns stored automatic event.

Terminate()

TBool Terminate()[pure virtual]

Handles situation where session must be forcefully terminated

Type()

TType Type()const

Returns type of session

Member Enumerations Documentation

Enum TType

Enumerators

EUnknown = -1
EInSession
EOutSession
EOutSIPSession

Member Data Documentation

TMceStateTransitionEvent * iAutoEvent

TMceStateTransitionEvent *iAutoEvent[protected]

CSIPServerTransaction * iAutoEventAssociatedRequest

CSIPServerTransaction *iAutoEventAssociatedRequest[protected]

TBool iAutoEventEnabled

TBool iAutoEventEnabled[protected]

TMceIds * iAutoEventIds

TMceIds *iAutoEventIds[protected]

CMceMsgBase * iAutoEventMsg

CMceMsgBase *iAutoEventMsg[protected]

HBufC8 * iClientContent

HBufC8 *iClientContent[private]

TBool iClientExists

TBool iClientExists[private]

CMceCsSessionImplementation * iClientSession

CMceCsSessionImplementation *iClientSession[private]

TMceCsSessionType iClientType

TMceCsSessionType iClientType[private]

CSIPDialogAssocBase * iCurrentDialog

CSIPDialogAssocBase *iCurrentDialog[protected]

TMceStateTransitionEvent * iCurrentlyProcessedAutoEvent

TMceStateTransitionEvent *iCurrentlyProcessedAutoEvent[protected]

CSIPDialogAssocBase * iDialog

CSIPDialogAssocBase *iDialog[protected]

TUint32 iDialogId

TUint32 iDialogId[private]

CFCSession * iFCSession

CFCSession *iFCSession[protected]

CSIPClientTransaction * iInitialInvite

CSIPClientTransaction *iInitialInvite[private]

RPointerArray< CSIPServerTransaction > iPendingReceivedRequests

RPointerArray< CSIPServerTransaction >iPendingReceivedRequests[protected]

RPointerArray< CSIPClientTransaction > iPendingTransactions

RPointerArray< CSIPClientTransaction >iPendingTransactions[protected]

CSIPProfile * iProfile

CSIPProfile *iProfile[private]

CMceCsSubSessionReceiver * iReceiver

CMceCsSubSessionReceiver *iReceiver[private]

CSIPClientTransaction * iResponse

CSIPClientTransaction *iResponse[private]

CMceSipConnection & iSIPConnection

CMceSipConnection &iSIPConnection[private]

CMceServerCore & iServerCore

CMceServerCore &iServerCore[private]

TType iType

TType iType[private]