Fixed "extra qualification" syntax errors.
/*
* Copyright (c) 2005 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:
*
*/
#ifndef MCEACTIONSET_H
#define MCEACTIONSET_H
#include <e32std.h>
#include "mcesrv.h"
#include "mcesession.h"
#include "mcestate.h"
#include "mcesipsession.h"
#include "mcedefs.h"
// FORWARD DECLARATION
class CMceSipSession;
class CSIPServerTransaction;
class CSIPClientTransaction;
class CMceMsgBase;
class CMceMediaManager;
class CSIPHeaderBase;
class CSdpDocument;
class CSIPMessageElements;
class CMceComSession;
class CSIPResponseElements;
class CMceMsgSIPReply;
class CMceMsgSIPData;
class TMceMccComEvent;
class TMceStateTransitionEvent;
const TInt KMceAutoReasonPhrase = KErrNotFound;
// CLASS DECLARATION
/**
* MCE SIP session.
*
* @lib
* @since
*/
class TMceActionSet
{
public: // Constructors and destructor
/**
* C++ constructor
* @param aSession, reference to session.
*/
TMceActionSet( CMceSipSession& aSession );
public://state changing related
/**
* Changes server state
* @param aNewState new server state
*/
void StateChanged( TMceStateIndex aNewState );
/**
* Changes client state synchronously as a response
* to client's ITC call
* @param aIds set of ids defining ITC call context
* @param aNewState new client state
* @param aStatus status
*/
void ClientStateChanged( TMceIds& aIds,
CMceSession::TState aNewState,
TInt aStatus = KErrNone );
/**
* Changes client state.
* This is called when there is no SIP data for client
* explaining the reason of state change. This happens,
* for example, when client is establishing session and
* there is no response, but media manager fails in offer
* creation.
* @param aNewState new client state
* @param aReason a reason of state change
*/
void ClientStateChangedL( CMceSession::TState aNewState,
TInt aReason = KErrNone );
/**
* Changes client state.
* This is called when there is SIP response explaining
* the reason of state change. If handling of response fails
* (error) reason is used for identifying the problem.
* @param aNewState new client state
* @param aResponse SIP response
* @param aReason a reason of state change
*/
void ClientStateChangedL( CMceSession::TState aNewState,
CSIPClientTransaction& aResponse,
TInt aReason = KErrNone );
/**
* Changes client state.
* This is called when there is SIP request explaining
* the reason of state change. Only BYE is supported.
* This method should not be used when handling INVITE request,
* becauseINVITE causes always new incoming session creation and thus
* state change is always EIncoming.
* @param aNewState new client state
* @param aRequest SIP request
* @param aReason a reason of state change
*/
void ClientStateChangedL( CMceSession::TState aNewState,
CSIPServerTransaction& aRequest );
/**
* Changes client state. Used in session update.
* This is called when there is SIP response explaining
* the reason of state change and client session (body) must be
* updated because of it. If handling of response has been
* failed (error) reason is used for identifying the problem.
* If reason is other than KErrNone, EMceItcUpdateFailed is
* used in callback.
* @param aNewState new client state
* @param aBody client session
* @param aResponse SIP response
* @param aReason a reason of state change
*/
void ClientStateChangedL( CMceSession::TState aNewState,
CMceComSession& aBody,
CSIPClientTransaction& aResponse,
TInt aReason = KErrNone );
/**
* Changes client state. Used in session update.
* This is called when client session (body) must be
* updated. This happens, for example, when client is updating
* session, but media manager fails in update creation and
* rollback is needed.
* EMceItcUpdateFailed call back is used always
* used in callback.
* @param aNewState new client state
* @param aBody client session
* @param aReason a reason of state change
*/
void ClientStateChangedL( CMceSession::TState aNewState,
CMceComSession& aBody,
TInt aReason );
/**
* informs client of occured severe error
* @param aError a reason of error
*/
void ClientErrorOccured( TInt aError );
public://basic session establisment and update
/**
* Encode body to SDP. Encoded body can me obtained with
* Offer() method.
*/
void EncodeL();
/**
* Decode body from SDP, which is created with
* method CreateSDP() and stored as session offer.
* @return warning code
*/
TMceSipWarningCode DecodeL();
/**
* Decode body from SDP, which is created with
* method CreateSDP() and stored as session offer.
* @return warning code
*/
TMceSipWarningCode Decode();
/**
* Update media manager according to body
* @return return status:
* -System error < 0: error situation
* -KMceReady: update was synchronous
* -KMceAsync: updating asynchronously, wait EMEMediaUpdated event.
*/
TMceReturnStatus UpdateL();
/**
* Update media manager according to body
* @return return status:
* -System error < 0: error situation
* -KMceReady: update was synchronous
* -KMceAsync: updating asynchronously, wait EMEMediaUpdated event.
*/
TMceReturnStatus Update();
/**
* Reserve resources
* @return return status:
* -System error < 0: error situation
* -KMceReady: reservation was synchronous or not needed
* -KMceAsync: reserving asynchronously, wait EMEMediaReserved event.
*/
TMceReturnStatus ReserveL();
/**
* Update clients parameters in body
* @param aIds set of ids defining ITC call context
* @param aBody client session
*/
void UpdateBodyL( TMceIds& aIds, CMceMsgBase& aBody );
/**
* Create body candidate for session update.
* @param aType the direction of the body candidate
*/
void CreateBodyCandidateL( CMceComSession::TType aType );
/**
* Returns truth value, reservation needed.
* @return ETrue, if reservation is needed
*/
TBool ReservationNeeded();
/**
* Sends INVITE with SDP
*/
void SendInviteL();
/**
* Informs client about new incoming session
* @param aInvite server transaction
*/
void ClientUpdateIncomingSessionL( CSIPServerTransaction& aInvite );
/**
* Informs client about new incoming session update
* @param aInvite server transaction
* @param aCallback callback for client
*/
void ClientUpdateSessionL( CSIPServerTransaction& aInvite,
TUint32 aCallback = EMceItcIncomingUpdate );
public://requests
/**
* Sends INVITE
* @param aData session body for creation of SDP content
*/
void SendInviteL( CMceComSession& aData );
/**
* Sends ACK to response (2XX)
* @param aResponse client transaction
*/
void SendACKL( CSIPClientTransaction& aResponse );
/**
* Sends BYE with default headers
*/
void SendBYEL();
/**
* Sends BYE with client defined headers and content
* This is called when client terminates (EMceItcTerminateSession)
* @param aData data containing headers
*/
void SendBYEL( CMceMsgBase& aData );
/**
* Sends CANCEL
* @return ETrue, if CANCEL was sent
*/
TBool SendCancelL();
/**
* Sends UPDATE
* @return ETrue, if UPDATE was sent
*/
void SendUpdateRequestL();
/**
* Sends PRACK
* @param aContent if ETrue, use content in PRACK
* @return ETrue, if PRACK was sent
*/
void SendPrackL( TBool aContent = ETrue );
/**
* Sends Extension Request
* @param aData SIP data
* @param aIds set of ids defining ITC call context
*/
void SendExtensionRequestL( CMceMsgBase& aData, TMceIds& aIds );
/**
* Receive Response to the Extension Requests sent.
* @param aEvent, event
*/
void ReceiveExtensionRequestL( TMceStateTransitionEvent& aEvent );
/**
* Receive Error for an Extension Request sent.
* Error Can be anything like ICMP, SIP Timeout.
* @param aRequest, request for which error is received.
*/
void ReceiveExtensionError( CSIPTransactionBase& aTransaction, TInt aError );
public://responses
/**
* Sends answer to offer carried by INVITE
* This is called when client accepts (EMceItcAcceptSession)
* @param aRequest server transaction
* @param aReply user defined response (CMceMsgSIPReply)
*/
void SendAnswerL( CSIPServerTransaction& aRequest,
CMceMsgBase& aReply );
/**
* Sends answer to offer carried by re-INVITE
* @param aRequest the re-invite
*/
void SendAnswerL( CSIPServerTransaction& aRequest );
/**
* Sends rejection 488 Not Acceptable Here to offer with warning,
* if warning is assigned to one of 3xx warnings. If warning is assigned
* to 4xx, 5xx or 6xx it is been interpretet as response code.
* @param aReason reason why 488 or response code is sent
* @param aInvite server transaction
*/
void SendRejectOfferWithWarningL( TMceSipWarningCode aReason,
CSIPServerTransaction& aInvite );
/**
* Sends 200OK reponse (to BYE)
* @param aRequest server transaction
*/
void Send200OKL( CSIPServerTransaction& aRequest );
/**
* Sends 603 Decline or user response to request (INVITE)
* @param aRequest server transaction
* @param aReply user defined response (CMceMsgSIPReply)
*/
void SendDeclineL( CSIPServerTransaction& aRequest,
CMceMsgBase& aReply );
/**
* Sends 180 Ringing to request (INVITE)
* @param aRequest server transaction
* @param aReply user defined response (CMceMsgSIPReply)
* @return ETrue, if response was sent reliably
*/
TBool SendRingL( CSIPServerTransaction& aRequest,
CMceMsgBase& aReply );
/**
* Sends 182 SipQueued message to request (INVITE)
* @param aRequest server transaction
* @param aReply user defined response (CMceMsgSIPReply)
* @return ETrue, if response was sent reliably
*/
TBool SendSipQueuedL( CSIPServerTransaction& aRequest,
CMceMsgBase& aReply );
/**
* Sends a response to request (INVITE).
* For responses sent automatically by state machine,
* not for those coming from client.
* @param aRequest server transaction
* @param aCode the reason code
* @param aReason the reasn phrase as string pool index
*/
void SendResponseL( CSIPServerTransaction& aRequest,
TUint32 aCode,
TInt aReason );
/**
* Seize re-sending UPDATE/PRACK.
* @return ETrue if interrupt succeeded.
*/
TBool InterruptConfirming();
/**
* Receive Responses to the Extnesion request sent.
* @param aResponse, response need to be sent to the client
* @param aBody session body
*/
void ReceiveExtensionResponseL( CSIPClientTransaction& aResponse,
CMceComSession& aBody );
/**
* Sends a response to the extension requests received
* @param aData SIP data
* @param aIds set of ids defining ITC call context
*/
void SendExtensionResponseL( CMceMsgBase& aData, TMceIds& aIds );
public://new functions
/**
* Called when update has been succeed
*/
void UpdateSucceed();
/**
* Called when update has been failed
*/
void UpdateFailed();
/**
* Encodes session body
* @return aEncodedBody place holder to encode session body
*/
HBufC8* BodyToTextL();
/**
* Creates SDP document based on client/server transaction
* @param aSDPContainer transaction
* containing SDP document in its content
* @return system wide error / SDP error
*/
TInt CreateSDP( CSIPTransactionBase& aSDPContainer );
/**
* Process the ReliableResponse
* @return EFalse if response contains RSeq value that is not one higher than the last one.
*/
TBool ProcessReliableResponse( const CSIPResponseElements& aResponseElements );
/**
* Handle Reliable Response
* @return EFalse if response contains RSeq value that is not one higher than the last one.
*/
TBool NeedToProcessL( TMceStateTransitionEvent& aEvent );
/**
* Check if session response contact header has sips uri or tls parameters
* @param aTransaction sip transaction msgs
* @return void
*/
void CheckContactIsSecureL( CSIPTransactionBase& aTransaction );
/**
* Finds if the Request is Extenssion Request
* @return ETrue if the Request is Extension Request
*/
TBool IsExtensionRequest( RStringF method );
public://Session timer related
/**
* Process session timer data in received INVITE
* @param aRequest the request
*/
void ProcessSessionTimerServerL( CSIPServerTransaction& aRequest );
/**
* Process session timer data in received response
* @param aResponse the response
*/
void ProcessSessionTimerClientL( CSIPClientTransaction& aResponse );
/**
* Resets session timer
*/
void ResetSessionTimerL();
/**
* Stop pending timer
*/
void StopPendingTimer();
/**
* Sends re-invite indicating session refresh
*/
void SendSessionRefreshL();
public://Media related
/**
* Handles ITC function, which controls media
* @param aIds set of ids defining ITC call context
* @param aAction ITC function defining the action
* @return aReturnMessage message to return
*/
HBufC8* ControlMediaL( TMceIds& aIds, TMceItcFunctions aAction );
/**
* Handles ITC function, which controls media
* @param aIds set of ids defining ITC call context
* @param aAction ITC function defining the action
* @param aMessage message
*/
void ControlMediaL( TMceIds& aIds, TMceItcFunctions aAction,
const TDesC8& aMessage );
/**
* Handles ITC function, which controls media
* @param aIds set of ids defining ITC call context
* @param aAction ITC function defining the action
* @param aMessage message
*/
void ControlMediaL( TMceIds& aIds, TMceItcFunctions aAction,
TPtr8& aMessage );
/**
* Stops all media
*/
void StopMedia();
/*
* stop the ongoing updating media
*/
void StopUpdatingMedia();
/**
* Informs client about new incoming session update
* @param aInvite server transaction
*/
void ClientMediaStateChangedL( TMceMccComEvent* aMccEvent,
TMceMediaEventCode aEvent = EMceMediaEventReceived );
protected://methods
/**
* Converts SDP document to text
* @param aDocument SDP document
* @return SDP document as text
*/
HBufC8* CreateSDPContentLC( CSdpDocument& aDocument );
/**
* Creates multipart-mixed content
* @param aDocument SDP document
* @param aUserContentType user defined content type to be mixed in
* @param aUserContent user content to be mixed in
* @return multipart-mixed content
*/
HBufC8* CreateMultipartContentLC( CSdpDocument& aDocument,
const TDesC8& aUserContentType,
const TDesC8& aUserContent );
/**
* Process session timer data in received INVITE
* @param aElements message elements
*/
void ProcessSessionTimerServerL( const CSIPMessageElements& aElements );
/**
* Adds session timer headers, when session is acting as server,
* to response
* @param aSipHeaders SIP headers container
*/
void AddSessionTimerFieldsServerL(
RPointerArray<CSIPHeaderBase>& aHeaders );
/**
* Adds session timer headers, when session is acting as client,
* to request
* @param aSipHeaders SIP headers container
*/
void AddSessionTimerFieldsClientL(
RPointerArray<CSIPHeaderBase>& aSipHeaders );
/**
* Sends response to request.
* @param aRequest the request
* @param aResponse the response from client
* @return ETrue, if response was sent reliably
*/
TBool SendResponseL( CSIPServerTransaction& aRequest,
CMceMsgSIPReply& aResponse );
/**
* Sends warning response to request.
* @param aResponseCode the response code
* @param aWarnCode the warning code
* @param aRequest the request
*/
void SendWarningResponseL( const TUint aResponseCode,
const TUint aWarnCode,
CSIPServerTransaction& aRequest );
/**
* Processes invite
* @param aBody session body
* @param aInvite the invite
*/
const CSIPMessageElements* ProcessInviteL(
CMceComSession& aBody,
CSIPServerTransaction& aInvite );
/**
* Sends session body via callback mechanism to client (session)
* @param aIds set of ids defining ITC callback context
* @param aBody session body
* @param aContent content of message
*/
void SendBodyToClientL( TMceIds& aIds,
CMceComSession& aBody,
HBufC8* aContent );
/**
* Sends SIP data via callback mechanism to client (session)
* @param aIds set of ids defining ITC callback context
* @param aData SIP data
* @param aContent content of message
*/
void SendSIPDataToClientL( TMceIds& aIds,
CMceMsgBase& aData,
HBufC8* aContent );
/**
* Fills client reply from SIP response
* @param aReply client reply
* @param aResponse SIP response
* @return message elements
*/
const CSIPMessageElements* ResponseDataL(
CMceMsgSIPReply& aReply,
CSIPClientTransaction& aResponse,
CMceComSession& aBody );
/**
* Fills session body from SIP request
* @param aContainer session body
* @param aRequest SIP request
* @return message elements
*/
const CSIPMessageElements* RequestDataL( CMceComSession& aContainer,
CSIPServerTransaction& aRequest );
/**
* Fills client (request) data from SIP request
* @param aContainer client (request) data
* @param aRequest SIP request
* @return message elements
*/
const CSIPMessageElements* RequestDataL( CMceMsgSIPData& aContainer,
CSIPServerTransaction& aRequest );
/**
* Adds SIP headers to SIP request/response. If no headers, adds
* default headers
* @param aMessageElements message elements of SIP request/response
* @param aPrimaryHeaders headers
* @param aMethodInd if request, indicates method, whose default headers
* @param aContact if ETrue, the Contact header is created and added
* will be added
*/
void AddHeadersL( CSIPMessageElements& aMessageElements,
CDesC8Array* aPrimaryHeaders,
TInt aMethodInd = KErrNotFound );
/**
* Adds SIP headers to SIP request/response. If no headers, adds
* default headers
* @param aHeaders SIP headers container
* @param aPrimaryHeaders headers
* @param aMethodInd if request, indicates method, whose default headers
* @param aContact if ETrue, the Contact header is created and added
* will be added
*/
void AddHeadersL( RPointerArray<CSIPHeaderBase>& aHeaders,
CDesC8Array* aPrimaryHeaders,
TInt aMethodInd = KErrNotFound );
/**
* Adds the SIP extension headers according to support of the extensions.
* @param aHeaders SIP headers container
* @param aTransactionType the transaction type as SIP string constant
* @param aIsBody ETrue, if request/response will contain a body
* @param aIsResponse ETrue, if the headers are for response
* @param aResponseCode the response code
* @return ETrue if this yelds to a relibly sent provisional response.
*/
TBool AddExtensionHeadersL( RPointerArray<CSIPHeaderBase>& aHeaders,
TInt aTransactionType,
TBool aIsBody,
TBool aIsResponse = EFalse,
TUint aResponseCode = KErrNone );
/**
* Sends specified request. Supports INVITE, PRACK and UPDATE.
* @param the request method as SIP string
* @param client data
* @param aContent if ETrue, use content in request
*/
void SendRequestL( TInt aMethod, CMceComSession* aData = NULL,
TBool aContent = ETrue );
/**
* Find active body for sip session.
* @return active body
*/
CMceComSession& ActiveBody();
private://data
//SIP session instance
CMceSipSession& iSession;
//definitions for unit testing
MCESRV_UT_DEFINITIONS
};
/**
* implementaion of event handler interface
*
*/
class TMceComEventHandler : public MMceEventHandler
{
public:
TMceComEventHandler( CMceMediaManager& aMediaManager );
TMceComEventHandler( CMceMediaManager& aMediaManager,
TPtr8& aWriteData );
TMceComEventHandler( CMceMediaManager& aMediaManager,
const TDesC8& aReadData );
TMceComEventHandler( CMceMediaManager& aMediaManager,
HBufC8*& aWriteData );
/**
* Handles event for sink
* @param aTarget target
* @param aEvent event
*/
TInt HandleL( CMceComMediaSink& aTarget, TMceComEvent& aEvent );
/**
* Handles event for source
* @param aTarget target
* @param aEvent event
*/
TInt HandleL( CMceComMediaSource& aTarget, TMceComEvent& aEvent );
/**
* Handles event for rtp sink
* @param aTarget target
* @param aEvent event
*/
TInt HandleL( CMceComRtpSink& aTarget, TMceComEvent& aEvent );
/**
* Handles event for rtp source
* @param aTarget target
* @param aEvent event
*/
TInt HandleL( CMceComRtpSource& aTarget, TMceComEvent& aEvent );
/**
* Handles event for speaker sink
* @param aTarget target
* @param aEvent event
*/
TInt HandleL( CMceComSpeakerSink& aTarget, TMceComEvent& aEvent );
/**
* Handles event for display sink
* @param aTarget target
* @param aEvent event
*/
TInt HandleL( CMceComDisplaySink& aTarget, TMceComEvent& aEvent );
/**
* Handles event for mic source
* @param aTarget target
* @param aEvent event
*/
TInt HandleL( CMceComMicSource& aTarget, TMceComEvent& aEvent );
/**
* Handles event for camera source
* @param aTarget target
* @param aEvent event
*/
TInt HandleL( CMceComCameraSource& aTarget, TMceComEvent& aEvent );
/**
* Handles event for file source
* @param aTarget target
* @param aEvent event
*/
TInt HandleL( CMceComFileSource& aTarget, TMceComEvent& aEvent );
/**
* Handles event for file sink
* @param aTarget target
* @param aEvent event
*/
TInt HandleL( CMceComFileSink& aTarget, TMceComEvent& aEvent );
private://NOT owned data
//media manager instance
CMceMediaManager& iMediaManager;
TPtr8* iWriteData;
const TDesC8* iReadData;
HBufC8** iReturnData;
};
#endif //MCEACTIONSET_H
// End of File