--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommsengine/mmcesrv/mmceserver/src/mceactionset.cpp Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,3788 @@
+/*
+* 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:
+*
+*/
+
+
+
+
+#include <e32math.h>
+#include <sipinvitedialogassoc.h>
+#include <sipfromheader.h>
+#include <siptoheader.h>
+#include <sipcontenttypeheader.h>
+#include <sipextensionheader.h>
+#include <sipaddress.h>
+#include <sipprofile.h>
+#include <sipmessageelements.h>
+#include <sipsupportedheader.h>
+#include <siprequireheader.h>
+#include <sdpdocument.h>
+#include <siprseqheader.h>
+#include "mceactionset.h"
+#include "mcecssession.h"
+#include "mcecssessionimplementation.h"
+#include "mcecomsession.h"
+#include "mcecomrtpsink.h"
+#include "mcecomrtpsource.h"
+#include "mcecomspeakersink.h"
+#include "mcecomfilesource.h"
+#include "mcecommicsource.h"
+#include "mcesipsession.h"
+#include "mcemediamanager.h"
+#include "mcesipconnection.h"
+#include "mcesipextensions.h"
+#include "mcesip.h"
+#include "mcesrvlogs.h"
+#include "mcetimermanager.h"
+#include "mcereliablesender.h"
+#include "mcecomcamerasource.h"
+
+const TInt KMaxLengthOfSDPMessage = 1000;
+const TInt KMaxLengthOfSessionExpires = 40;
+
+#define MCE_HANDLER_WRITE( aType, aData )\
+ aType writeBuf( aData );\
+ iWriteData->Copy( writeBuf );
+
+#define MCE_HANDLER_READ_DATA( aCastType, aType, aData, aBuffer )\
+ aCastType readBuf;\
+ readBuf.Copy( *aBuffer );\
+ aType aData = readBuf();
+#define MCE_HANDLER_READ( aCastType, aType, aData )\
+ MCE_HANDLER_READ_DATA( aCastType, aType, aData, iReadData )
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::TMceActionSet
+// -----------------------------------------------------------------------------
+//
+TMceActionSet::TMceActionSet( CMceSipSession& aSession )
+ : iSession ( aSession )
+ {
+ }
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::StateChanged
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::StateChanged( TMceStateIndex aNewState )
+ {
+ iSession.NextState( aNewState );
+ //for long session, once session established, key updated need to be turn on
+
+ if ( aNewState == KMceStateEstablished &&
+ ActiveBody().SecureSession())
+ {
+ if ( ActiveBody().SecureSession()->iCryptoContextUpdate )
+ {
+ ActiveBody().SecureSession()->iKeyNeedUpdated = ETrue;
+ }
+ else
+ {
+ ActiveBody().SecureSession()->iKeyNeedUpdated = EFalse;
+ }
+ }
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ClientStateChanged
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ClientStateChanged( TMceIds& aIds,
+ CMceSession::TState aNewState,
+ TInt aStatus )
+ {
+ MCESRV_DEBUG("TMceActionSet::ClientStateChanged( sync ), Entry");
+ MCESRV_DEBUG_CLISTATE("new state", aNewState );
+ MCESRV_DEBUG_DVALUE("status", aStatus );
+
+ ActiveBody().iState = aNewState;
+ aIds.iState = aNewState;
+ aIds.iStatus = aStatus;
+
+
+ MCESRV_DEBUG("TMceActionSet::ClientStateChanged( sync ), Exit");
+ }
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ClientStateChangedL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ClientStateChangedL( CMceSession::TState aNewState,
+ TInt aReason )
+ {
+ MCESRV_DEBUG("TMceActionSet::ClientStateChanged, Entry");
+ MCESRV_DEBUG_CLISTATE("new state", aNewState );
+
+ if ( &ActiveBody() )
+ {
+ ActiveBody().iState = aNewState;
+ }
+
+ TMceIds ids;
+ ids.iCallbackID = EMceItcStateChanged;
+ ids.iState = aNewState;
+
+ if ( aReason == KErrNone )
+ {
+ iSession.SendToClient( ids );
+ }
+ else
+ {
+ MCESRV_DEBUG_DVALUE("error", aReason )
+ ids.iStatus = aReason;
+
+ CMceMsgSIPReply* replyMsg = new (ELeave) CMceMsgSIPReply();
+ CleanupStack::PushL( replyMsg );
+ replyMsg->iCode = aReason;
+
+ SendSIPDataToClientL( ids, *replyMsg, NULL );
+ CleanupStack::PopAndDestroy( replyMsg );
+ }
+
+
+ MCESRV_DEBUG("TMceActionSet::ClientStateChanged, Exit");
+ }
+
+
+
+
+
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ClientStateChangedL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ClientStateChangedL( CMceSession::TState aNewState,
+ CSIPClientTransaction& aResponse,
+ TInt aReason )
+ {
+ MCESRV_DEBUG("TMceActionSet::ClientStateChangedL( response ), Entry");
+ MCESRV_DEBUG_CLISTATE("new state", aNewState );
+ MCESRV_DEBUG_DVALUE("error", aReason );
+
+
+ const CSIPResponseElements* response = aResponse.ResponseElements();
+ if ( !response )
+ {
+ ClientStateChangedL( aNewState, aReason );
+ return;
+ }
+
+ MCESRV_DEBUG_DVALUE("status code", response->StatusCode() );
+ MCESRV_DEBUG_SVALUE("reason", response->ReasonPhrase().DesC() );
+
+ ActiveBody().iState = aNewState;
+
+ TMceIds ids;
+ ids.iCallbackID = EMceItcStateChanged;
+ ids.iState = aNewState;
+ ids.iStatus = aReason;
+
+ HBufC8* content = NULL;
+
+ CMceMsgSIPReply* replyMsg = new (ELeave) CMceMsgSIPReply();
+ CleanupStack::PushL( replyMsg );
+ replyMsg->PushL();
+
+ const CSIPMessageElements* elements = ResponseDataL( *replyMsg, aResponse, ActiveBody() );
+
+ if ( elements )
+ {
+ content = elements->Content().AllocLC();
+ }
+
+ SendSIPDataToClientL( ids, *replyMsg, content );
+
+ if ( content )
+ {
+ CleanupStack::Pop( content );
+ }
+
+ CleanupStack::PopAndDestroy( replyMsg );
+
+
+ MCESRV_DEBUG("TMceActionSet::ClientStateChangedL( response ), Exit");
+
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ReceiveExtensionResponseL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ReceiveExtensionResponseL( CSIPClientTransaction& aResponse,
+ CMceComSession& aBody )
+ {
+
+ MCESRV_DEBUG("TMceActionSet::ReceiveExtensionResponseL( response ), Entry");
+ TUint count = KErrNone;
+ TUint TransactoinID = KMceNotAssigned;
+ count = iSession.PendingTransactions().Count();
+
+ if ( count )
+ {
+ for ( TUint i=0; i < count; i++ )
+ {
+ if ( *iSession.PendingTransactions()[i] == aResponse )
+ {
+ TransactoinID = reinterpret_cast <TUint>
+ (iSession.PendingTransactions()[i]);
+ }
+ }
+ }
+
+ const CSIPMessageElements* elements = NULL;
+ const CSIPResponseElements* response = aResponse.ResponseElements();
+
+ HBufC8* content = NULL;
+
+ if ( response )
+ {
+ MCESRV_DEBUG_DVALUE("status code", response->StatusCode() );
+ MCESRV_DEBUG_SVALUE("reason", response->ReasonPhrase().DesC() );
+
+ CMceMsgSIPReply* replyMsg = replyMsg = new (ELeave) CMceMsgSIPReply();
+ CleanupStack::PushL( replyMsg );
+
+ replyMsg->PushL();//takes ownership of its content
+
+ elements = ResponseDataL( *replyMsg, aResponse, aBody );
+
+
+ TMceIds ids;
+ ids.iCallbackID = EMceItcResponseReceived;
+ ids.iTransactionID = TransactoinID;
+
+ content = elements ? elements->Content().AllocLC() : NULL;
+
+ SendSIPDataToClientL( ids, *replyMsg, content );
+
+ if ( content )
+ {
+ CleanupStack::Pop( content );
+ }
+
+ CleanupStack::PopAndDestroy( replyMsg );
+
+ MCESRV_DEBUG(
+ "TMceActionSet::ReceiveExtensionResponseL( session, response ), Exit");
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ReceiveExtensionRequestL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ReceiveExtensionRequestL( TMceStateTransitionEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceActionSet::ReceiveExtensionRequestL, Entry");
+
+ CSIPServerTransaction& serverTransaction = aEvent.Session().Request();
+
+ const CSIPMessageElements* elements =
+ MceSip::ToMessageElements( serverTransaction );
+
+ HBufC8* method = MceSip::Method( serverTransaction ).DesC().AllocLC();
+
+ CDesC8Array* aSIPHeaders = NULL;
+
+ if ( aEvent.Dialog())
+ {
+ aSIPHeaders = MceSip::UserHeadersToTextArrayL( serverTransaction,
+ *aEvent.Dialog() );
+ CleanupStack::PushL( aSIPHeaders );
+ }
+
+ else
+ {
+ aSIPHeaders = MceSip::UserHeadersToTextArrayL( serverTransaction,
+ iSession.Dialog()->Dialog() );
+ CleanupStack::PushL( aSIPHeaders );
+ }
+
+ HBufC8* aSIPContentType = ( elements && elements->ContentType() ) ?
+ elements->ContentType()->ToTextValueL() :
+ KNullDesC8().AllocL();
+
+
+ CleanupStack::PushL( aSIPContentType );
+
+ TMceIds ids;
+ ids.iCallbackID = EMceItcRequestReceived;
+ ids.iTransactionID = reinterpret_cast <TUint> (&serverTransaction);
+
+
+ CMceMsgSIPRequest* requestMsg = new (ELeave) CMceMsgSIPRequest( *method,
+ *aSIPHeaders, *aSIPContentType );
+ requestMsg->PushL();
+
+ CleanupStack::Pop( aSIPContentType );
+ CleanupStack::Pop( aSIPHeaders );
+ CleanupStack::Pop( method );
+
+ CleanupStack::PushL( requestMsg );
+
+ HBufC8* content =
+ elements ? elements->Content().AllocLC() : KNullDesC8().AllocLC();
+
+ SendSIPDataToClientL( ids, *requestMsg, content );
+
+ if ( content )
+ {
+ CleanupStack::Pop( content );
+ }
+
+ CleanupStack::PopAndDestroy( requestMsg );
+
+ MCESRV_DEBUG("TMceActionSet::ReceiveExtensionRequestL, Exit");
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ReceiveExtensionError
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ReceiveExtensionError( CSIPTransactionBase& aTransaction,
+ TInt aError )
+ {
+ MCESRV_DEBUG("TMceActionSet::ReceiveExtensionErrorL, Entry");
+
+ TUint count = KErrNone;
+ TUint TransactoinID = KMceNotAssigned;
+ TBool found = EFalse;
+
+ // If Error is for Client Transaction:
+ if ( aTransaction.IsSIPClientTransaction() )
+
+ {
+ MCESRV_DEBUG("Error Received for Client Transaction");
+ CSIPClientTransaction& clientTransaction =
+ static_cast<CSIPClientTransaction&>( aTransaction );
+
+ count = iSession.PendingTransactions().Count();
+
+ if ( count )
+ {
+ for ( TUint i=0; i < count; i++ )
+ {
+ if ( *iSession.PendingTransactions()[i] == clientTransaction )
+ {
+ TransactoinID = reinterpret_cast <TUint>
+ (iSession.PendingTransactions()[i]);
+ found = ETrue;
+ }
+ }
+ }
+ }
+
+
+ // If Error is for Client Transaction:
+ else
+ {
+ MCESRV_DEBUG("Error Received for Server Transaction");
+ CSIPServerTransaction& serverTransaction =
+ static_cast<CSIPServerTransaction&>( aTransaction );
+
+ count = iSession.PendingReceivedRequests().Count();
+
+ if ( count )
+ {
+ for ( TUint i=0; i < count; i++ )
+ {
+ if ( *iSession.PendingReceivedRequests()[i] == serverTransaction )
+ {
+ TransactoinID = reinterpret_cast <TUint>
+ (iSession.PendingReceivedRequests()[i]);
+ found = ETrue;
+ }
+ }
+ }
+ }
+
+ // Send an Error Response to the Client if client or server transcation exisit
+ // for which we receive an error.
+ if ( found )
+ {
+ MCESRV_DEBUG("Tranaction Matched Sending Error Response");
+ TMceIds ids;
+ ids.iTransactionID = TransactoinID;
+ iSession.SendErrorToClient( ids, aError );
+ }
+
+ MCESRV_DEBUG("TMceActionSet::ReceiveExtensionErrorL, Exit");
+ }
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendExtensionResponseL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendExtensionResponseL( CMceMsgBase& aData, TMceIds& aIds )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendExtensionResponseL, Entry");
+
+ TUint count = KErrNone;
+ TInt index = KErrNotFound;
+ CSIPServerTransaction* PendingRequest = NULL;
+
+ count = iSession.PendingReceivedRequests().Count();
+
+ if ( count )
+ {
+ for ( TUint i=0; i < count; i++ )
+ {
+ if ( reinterpret_cast <TUint> (iSession.PendingReceivedRequests()[i]) ==
+ aIds.iTransactionID )
+ {
+ PendingRequest = iSession.PendingReceivedRequests()[i];
+ index = i;
+ }
+ }
+
+ if ( index != KErrNotFound )
+
+ {
+ CMceMsgSIPReply* data = static_cast<CMceMsgSIPReply*>( &aData );
+ SendResponseL( *PendingRequest, *data );
+ }
+
+ else
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ }
+
+ MCESRV_DEBUG("TMceActionSet::SendExtensionResponseL, Exit");
+ }
+
+
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ClientStateChangedL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ClientStateChangedL( CMceSession::TState aNewState,
+ CSIPServerTransaction& aRequest )
+ {
+ MCESRV_DEBUG("TMceActionSet::ClientStateChangedL( request ), Entry");
+ MCESRV_DEBUG_CLISTATE("new state", aNewState );
+ MCESRV_DEBUG_SVALUE("request", MceSip::Method( aRequest ).DesC() );
+
+
+ const CSIPRequestElements* request = aRequest.RequestElements();
+
+ if ( !request )
+ {
+ ClientStateChangedL( aNewState );
+ return;
+ }
+
+ ActiveBody().iState = aNewState;
+
+ TMceIds ids;
+ ids.iCallbackID = EMceItcStateChanged;
+ ids.iState = aNewState;
+
+ CMceMsgSIPData* requestMsg = new (ELeave) CMceMsgSIPData();
+ CleanupStack::PushL( requestMsg );
+ requestMsg->PushL();
+
+ const CSIPMessageElements* elements =
+ RequestDataL( *requestMsg, aRequest );
+
+ HBufC8* content = elements ? elements->Content().AllocLC() :
+ KNullDesC8().AllocLC();
+
+ SendSIPDataToClientL( ids, *requestMsg, content );
+
+ if ( content )
+ {
+ CleanupStack::Pop( content );
+ }
+
+ CleanupStack::PopAndDestroy( requestMsg );
+
+ MCESRV_DEBUG("TMceActionSet::ClientStateChangedL( request ), Exit");
+
+
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ClientStateChangedL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ClientStateChangedL( CMceSession::TState aNewState,
+ CMceComSession& aBody,
+ CSIPClientTransaction& aResponse,
+ TInt aReason )
+ {
+
+ MCESRV_DEBUG(
+ "TMceActionSet::ClientStateChangedL( session, response ), Entry");
+ MCESRV_DEBUG_CLISTATE("new state", aNewState );
+ MCESRV_DEBUG_DVALUE("error", aReason );
+ TMceComFactory factory;
+
+ aBody.iState = aNewState;
+
+ const CSIPMessageElements* elements = NULL;
+ const CSIPResponseElements* response = aResponse.ResponseElements();
+
+ HBufC8* content = NULL;
+
+ CMceMsgArray<TMceComFactory>* messageArray =
+ new (ELeave) CMceMsgArray<TMceComFactory>( factory );
+ CleanupStack::PushL( messageArray );
+
+
+ if ( response )
+ {
+ MCESRV_DEBUG_DVALUE("status code", response->StatusCode() );
+ MCESRV_DEBUG_SVALUE("reason", response->ReasonPhrase().DesC() );
+
+ CMceMsgSIPReply* replyMsg = replyMsg = new (ELeave) CMceMsgSIPReply();
+ CleanupStack::PushL( replyMsg );
+ replyMsg->PushL();//takes ownership of its content
+
+ elements = ResponseDataL( *replyMsg, aResponse, aBody );
+
+ messageArray->iArray.AppendL( replyMsg );
+ CleanupStack::Pop( replyMsg );
+
+ }
+
+
+ CMceMsgObject<CMceComSession>* sessionMsg =
+ new (ELeave) CMceMsgObject<CMceComSession>
+ ( aBody, EMceItcMsgTypeSession );
+ CleanupStack::PushL( sessionMsg );
+
+ messageArray->iArray.AppendL( sessionMsg );
+ CleanupStack::Pop( sessionMsg );
+
+
+ TMceIds ids;
+ ids.iState = aNewState;
+ ids.iCallbackID = EMceItcStateChanged;
+ ids.iStatus = aReason;
+
+
+ if ( aReason != KErrNone &&
+ iSession.SubState() == CMceSipSession::EUpdating )
+ {
+ MCESRV_DEBUG("ClientStateChangedL: update failed");
+ ids.iCallbackID = EMceItcUpdateFailed;
+ }
+ else
+ {
+ MCESRV_DEBUG("ClientStateChangedL: basic");
+ }
+
+ content = elements ? elements->Content().AllocLC() : NULL;
+
+
+ SendSIPDataToClientL( ids, *messageArray, content );
+
+ if ( content )
+ {
+ CleanupStack::Pop( content );
+ }
+
+ //pops and destroys also its content
+ CleanupStack::PopAndDestroy( messageArray );
+
+
+ MCESRV_DEBUG(
+ "TMceActionSet::ClientStateChangedL( session, response ), Exit");
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ClientStateChangedL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ClientStateChangedL( CMceSession::TState aNewState,
+ CMceComSession& aBody,
+ TInt aReason )
+
+ {
+
+ MCESRV_DEBUG(
+ "TMceActionSet::ClientStateChangedL( newState, body. reason ), Entry");
+ MCESRV_DEBUG_CLISTATE("new state", aNewState );
+ MCESRV_DEBUG_DVALUE("error", aReason );
+
+ aBody.iState = aNewState;
+
+ TMceIds ids;
+ ids.iState = aNewState;
+
+ if ( aReason == KErrNone )
+ {
+ ids.iCallbackID = EMceItcStateChanged;
+ }
+ else
+ {
+ ids.iCallbackID = EMceItcUpdateFailed;
+ ids.iStatus = aReason;
+ }
+
+ SendBodyToClientL( ids, aBody, NULL );
+
+ MCESRV_DEBUG(
+ "TMceActionSet::ClientStateChangedL( newState, body. reason ), Entry");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::UpdateFailed
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::UpdateFailed()
+ {
+ MCESRV_DEBUG("TMceActionSet::UpdateFailed, Entry");
+
+ if ( iSession.SubState() == CMceSipSession::EUpdating )
+ {
+ iSession.UpdateRejected();
+ }
+ else
+ {
+ MCESRV_DEBUG("UpdateFailed: Called in wrong sub state!, Exit");
+ }
+
+ MCESRV_DEBUG("TMceActionSet::UpdateFailed, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::UpdateSucceed
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::UpdateSucceed()
+ {
+ if ( iSession.SubState() == CMceSipSession::EUpdating )
+ {
+ MCESRV_DEBUG("TMceActionSet::UpdateSucceed, Entry");
+ iSession.UpdateAccepted();
+ MCESRV_DEBUG("TMceActionSet::UpdateSucceed, Exit");
+ }
+ else
+ {
+ //NOP
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::CreateSDP
+// -----------------------------------------------------------------------------
+//
+TInt TMceActionSet::CreateSDP( CSIPTransactionBase& aSDPContainer )
+ {
+ CSdpDocument* sdp = NULL;
+ TInt status = KErrNone;
+
+ if ( aSDPContainer.IsSIPClientTransaction() )
+ {
+ CSIPClientTransaction& answer =
+ static_cast<CSIPClientTransaction&>( aSDPContainer );
+ const CSIPResponseElements* elements = answer.ResponseElements();
+
+ TRAP( status, sdp =
+ CSdpDocument::DecodeL( elements->MessageElements().Content() ) );
+ }
+ else
+ {
+ CSIPServerTransaction& offer =
+ static_cast<CSIPServerTransaction&>( aSDPContainer );
+ const CSIPRequestElements* elements = offer.RequestElements();
+
+ TRAP( status, sdp =
+ CSdpDocument::DecodeL( elements->MessageElements().Content() ) );
+ }
+
+ if ( status == KErrNone )
+ {
+ iSession.StorePrevOffer();
+ iSession.SetOffer( sdp );
+ iSession.IncrementReceivedSdpCount();
+ }
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::CreateBodyCandidateL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::CreateBodyCandidateL( CMceComSession::TType aType )
+ {
+ MCESRV_DEBUG("TMceActionSet::CreateBodyCandidateL, Entry");
+ __ASSERT_ALWAYS( iSession.Body(), User::Leave( KErrArgument ) );
+ __ASSERT_ALWAYS( !iSession.BodyCandidate(), User::Leave( KErrNotReady ) );
+
+ CSIPServerTransaction& request = iSession.Request();
+ CSIPServerTransaction* requestPtr = &iSession.Request();
+
+ if ( (requestPtr!=NULL) && !MceSip::HasContent( request ))
+ {
+ iSession.iNewBodyCandidate = iSession.Body()->CloneL( ETrue );
+ }
+ else
+ {
+ iSession.iNewBodyCandidate = iSession.Body()->CloneL();
+ }
+
+ iSession.iNewBodyCandidate->iType = aType;
+
+ iSession.SetSubState( CMceSipSession::EUpdating );
+
+ MCESRV_DEBUG("TMceActionSet::CreateBodyCandidateL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::UpdateBodyL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::UpdateBodyL( TMceIds& aIds, CMceMsgBase& aBody )
+ {
+ MCESRV_DEBUG("TMceActionSet::UpdateBodyL, Entry");
+
+ CMceSipSession::TSubState subState = iSession.SubState();
+ CMceMediaManager& mediaManager = iSession.Manager().MediaManager();
+ TMceComEventHandler handler( mediaManager );
+ CMceComSession* body = NULL;
+ CMceMsgObject<CMceComSession>* msg =
+ static_cast<CMceMsgObject<CMceComSession>*>( &aBody );
+
+ if ( !iSession.Body() )
+ {
+ iSession.SetBodyL( msg->iObject );
+ msg->Object();//ownership is transferred
+ body = iSession.Body();
+ }
+ else if ( subState != CMceSipSession::EUpdating )
+ {
+ body = iSession.Body();
+ TMceComEvent event( aIds, msg->iObject, EMceItcUpdate, handler );
+ body->EventReceivedL( event );
+ iSession.Extensions().Update( *body );
+ }
+ else
+ {
+ body = iSession.BodyCandidate();
+ TMceComEvent event( aIds, msg->iObject, EMceItcUpdate, handler );
+ body->EventReceivedL( event );
+ iSession.Extensions().Update( *body );
+ }
+
+ aBody.Close();
+
+ // transfer ownership of content to body
+ MCE_DELETE( body->iSIPContent );
+ body->iSIPContent = iSession.PopClientContent();
+
+ // If body's origin member is not set, parse origin from SIP profile.
+ if ( body->iType == CMceComSession::EOutSession &&
+ ( !body->iOriginator || body->iOriginator->Length() == 0 ) )
+ {
+ const TDesC8* userAor = NULL;
+ const CSIPProfile& profile = iSession.Profile();
+ TInt result = profile.GetParameter( KSIPUserAor, userAor );
+ if ( KErrNone == result && userAor && userAor->Size() != 0 )
+ {
+ MCESRV_DEBUG_SVALUE(
+ "TMceActionSet::UpdateBodyL, UPDATE ORIGINATOR", *userAor );
+ body->SetOriginatorL( *userAor );
+ }
+ }
+
+ MCESRV_DEBUG("TMceActionSet::UpdateBodyL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendInviteL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendInviteL()
+ {
+ MCESRV_DEBUG("TMceActionSet::SendInviteL, Entry");
+ CMceSipSession::TSubState subState = iSession.SubState();
+ CMceComSession* body = NULL;
+
+ if ( subState != CMceSipSession::EUpdating )
+ {
+ body = iSession.Body();
+ }
+ else
+ {
+ body = iSession.BodyCandidate();
+ }
+
+ //send invite
+ SendInviteL( *body );
+
+ MCESRV_DEBUG("TMceActionSet::SendInviteL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendSessionRefreshL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendSessionRefreshL()
+ {
+ MCESRV_DEBUG("TMceActionSet::SendSessionRefreshL, Entry");
+
+ iSession.SetSubState( CMceSipSession::ERefreshing );
+
+ SendInviteL( ActiveBody() );
+
+ MCESRV_DEBUG("TMceActionSet::SendSessionRefreshL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::EncodeL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::EncodeL()
+ {
+ MCESRV_DEBUG("TMceActionSet::EncodeL, Entry");
+
+ CMceComSession& body = ActiveBody();
+
+ CMceSipExtensions& ext = iSession.Extensions();
+ TInt localQosPreconds = ext.Local( CMceSipExtensions::EQosPreconds );
+ TInt remoteQosPreconds = ext.Remote( CMceSipExtensions::EQosPreconds );
+ body.iUseLocalPreconditions = localQosPreconds != CMceSipExtensions::ENotSupported;
+ body.iUseRemotePreconditions = remoteQosPreconds != CMceSipExtensions::ENotSupported;
+
+ CMceMediaManager& mediaManager = iSession.Manager().MediaManager();
+ iSession.StorePrevOffer();
+ iSession.SetOffer( mediaManager.EncodeL( body ) );
+
+ MCESRV_DEBUG("TMceActionSet::EncodeL, Exit");
+ }
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::DecodeL
+// -----------------------------------------------------------------------------
+//
+TMceSipWarningCode TMceActionSet::DecodeL()
+ {
+ MCESRV_DEBUG("TMceActionSet::DecodeL, Entry");
+
+ TMceSipWarningCode status = KErrNone;
+
+ CMceMediaManager& mediaManager = iSession.Manager().MediaManager();
+
+ CMceComSession& body = ActiveBody();
+
+ CMceSipExtensions& ext = iSession.Extensions();
+ TInt localQosPreconds = ext.Local( CMceSipExtensions::EQosPreconds );
+ TInt remoteQosPreconds = ext.Remote( CMceSipExtensions::EQosPreconds );
+
+ body.iUseLocalPreconditions = localQosPreconds != CMceSipExtensions::ENotSupported;
+ body.iUseRemotePreconditions = remoteQosPreconds != CMceSipExtensions::ENotSupported;
+ //set remote sec precondtions only when it is invite or update
+ if ( &iSession.Request() )
+ {
+ if (
+ MceSip::Method( iSession.Request() ) == SIPStrings::StringF( SipStrConsts::EInvite ) ||
+ MceSip::Method( iSession.Request() ) == SIPStrings::StringF( SipStrConsts::EUpdate ) )
+ {
+ body.iRemoteSecPreconditionsRequired =
+ ext.Remote( CMceSipExtensions::ESecPreconds ) == CMceSipExtensions::ERequired;
+ }
+ }
+ else
+ {
+ body.iRemoteSecPreconditionsRequired =
+ ext.Remote( CMceSipExtensions::ESecPreconds ) != CMceSipExtensions::ENotSupported;
+ }
+ status = mediaManager.DecodeL( body, *iSession.Offer() );
+
+ MCESRV_DEBUG_DVALUE( "DecodeL: status", status);
+
+ MCESRV_DEBUG("TMceActionSet::DecodeL, Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::Decode
+// -----------------------------------------------------------------------------
+//
+TMceSipWarningCode TMceActionSet::Decode()
+ {
+ MCESRV_DEBUG("TMceActionSet::Decode, Entry");
+
+ TMceReturnStatus status = KErrNone;
+ TInt error = KErrNone;
+
+ TRAP( error, status = DecodeL() );
+
+ MCESRV_DEBUG_DVALUE( "Update: status", status );
+ MCESRV_DEBUG_DVALUE( "Update: error", error );
+
+ MCESRV_DEBUG("TMceActionSet::Decode, Exit");
+
+ return error != KErrNone ? error : status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::UpdateL
+// -----------------------------------------------------------------------------
+//
+TMceReturnStatus TMceActionSet::UpdateL()
+ {
+ MCESRV_DEBUG("TMceActionSet::UpdateL, Entry");
+
+ TMceReturnStatus status = KErrNone;
+
+ status = iSession.UpdateMediaL();
+
+ MCESRV_DEBUG_DVALUE( "UpdateL: status", status );
+
+ MCESRV_DEBUG("TMceActionSet::UpdateL, Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::Update
+// -----------------------------------------------------------------------------
+//
+TMceReturnStatus TMceActionSet::Update()
+ {
+ MCESRV_DEBUG("TMceActionSet::Update, Entry");
+
+ TMceReturnStatus status = KErrNone;
+ TInt error = KErrNone;
+
+ TRAP( error, status = UpdateL() );
+
+ MCESRV_DEBUG_DVALUE( "Update: status", status );
+ MCESRV_DEBUG_DVALUE( "Update: error", error );
+
+ MCESRV_DEBUG("TMceActionSet::Update, Exit");
+
+ return error != KErrNone ? error : status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ReserveL
+// -----------------------------------------------------------------------------
+//
+TMceReturnStatus TMceActionSet::ReserveL()
+ {
+ MCESRV_DEBUG("TMceActionSet::ReserveL, Entry");
+
+ TMceReturnStatus status = iSession.ReserveL();
+ MCESRV_DEBUG_DVALUE( "ReserveL: status", status);
+
+ MCESRV_DEBUG("TMceActionSet::ReserveL, Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ClientUpdateIncomingSessionL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ClientUpdateIncomingSessionL(
+ CSIPServerTransaction& aInvite )
+ {
+ MCESRV_DEBUG("TMceActionSet::ClientUpdateIncomingSessionL, Entry");
+
+ ClientUpdateSessionL( aInvite, EMceItcObjectAdded );
+
+ MCESRV_DEBUG("TMceActionSet::ClientUpdateIncomingSessionL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ClientUpdateSessionL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ClientUpdateSessionL( CSIPServerTransaction& aInvite,
+ TUint32 aCallback )
+ {
+ MCESRV_DEBUG("TMceActionSet::ClientUpdateSessionL, Entry");
+
+ CMceComSession& body = ActiveBody();
+
+ const CSIPMessageElements* elements =
+ ProcessInviteL( body, aInvite );
+
+ RequestDataL( body, aInvite );
+
+ HBufC8* content = elements ? elements->Content().AllocLC() : NULL;
+
+ TMceIds ids;
+ ids.iCallbackID = aCallback;
+ ids.iState = CMceSession::EIncoming;
+
+ if ( aCallback == EMceItcObjectAdded )
+ {
+ iSession.PrepareIdsL( ids );
+ }
+
+ SendBodyToClientL( ids, body, content );
+
+ if ( content )
+ {
+ CleanupStack::Pop( content );
+ }
+
+ MCESRV_DEBUG("TMceActionSet::ClientUpdateSessionL, Entry");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ProcessInviteL
+// -----------------------------------------------------------------------------
+//
+const CSIPMessageElements*
+TMceActionSet::ProcessInviteL( CMceComSession& aBody,
+ CSIPServerTransaction& aInvite )
+ {
+ MCESRV_DEBUG("TMceActionSet::ProcessInviteL, Entry");
+
+ const CSIPRequestElements* reqElements = aInvite.RequestElements();
+ const CSIPMessageElements* elements =
+ reqElements ? &reqElements->MessageElements() : NULL;
+
+
+ if ( reqElements )
+ {
+ const CSIPAddress& from = reqElements->FromHeader()->SIPAddress();
+ const CSIPAddress& to = reqElements->ToHeader()->SIPAddress();
+
+ MCE_DELETE( aBody.iOriginator );
+ MCE_DELETE( aBody.iRecipient );
+
+ aBody.iOriginator = MceSip::AddressToTextL( from );
+ aBody.iRecipient = MceSip::AddressToTextL( to );
+ }
+
+
+ MCESRV_DEBUG("TMceActionSet::ProcessInviteL, Exit");
+
+ return elements;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ResponseDataL
+// -----------------------------------------------------------------------------
+//
+const CSIPMessageElements*
+TMceActionSet::ResponseDataL( CMceMsgSIPReply& aContainer,
+ CSIPClientTransaction& aResponse,
+ CMceComSession& aBody )
+ {
+ const CSIPResponseElements* response = aResponse.ResponseElements();
+ const CSIPMessageElements* elements = NULL;
+
+ if ( response )
+ {
+ const CSIPAddress& to = response->FromHeader()->SIPAddress();
+ HBufC8* originator = MceSip::AddressToTextL( to );
+ if ( !aBody.iOriginator || aBody.iOriginator->Length() == 0 )
+ {
+ MCE_DELETE( aBody.iOriginator );
+ aBody.iOriginator = originator;
+ }
+ else
+ {
+ MCE_DELETE( originator );
+ }
+
+ elements = &response->MessageElements();
+
+ aContainer.iCode = response->StatusCode();
+ HBufC8* reason = response->ReasonPhrase().DesC().AllocLC();
+ HBufC8* contentType = elements && elements->ContentType() ?
+ elements->ContentType()->ToTextValueL() :
+ KNullDesC8().AllocL();
+ CleanupStack::PushL( contentType );
+ CDesC8Array* headers =
+ MceSip::UserHeadersToTextArrayL( aResponse,
+ iSession.Dialog()->Dialog() );
+ CleanupStack::Pop( contentType );
+ CleanupStack::Pop( reason );
+ aContainer.iReason = reason;
+ aContainer.iSIPHeaders = headers;
+ aContainer.iContentType = contentType;
+ }
+
+ return elements;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::RequestDataL
+// -----------------------------------------------------------------------------
+//
+const CSIPMessageElements*
+TMceActionSet::RequestDataL( CMceComSession& aContainer,
+ CSIPServerTransaction& aRequest )
+ {
+
+ const CSIPMessageElements* elements = MceSip::ToMessageElements( aRequest );
+
+
+ if ( elements )
+ {
+ MCE_DELETE( aContainer.iSIPHeaders );
+ MCE_DELETE( aContainer.iSIPContentType );
+
+ aContainer.iSIPHeaders =
+ MceSip::UserHeadersToTextArrayL( aRequest,
+ iSession.Dialog()->Dialog() );
+ aContainer.iSIPContentType = elements->ContentType() ?
+ elements->ContentType()->ToTextValueL() :
+ KNullDesC8().AllocL();
+ }
+
+ return elements;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::RequestDataL
+// -----------------------------------------------------------------------------
+//
+const CSIPMessageElements*
+TMceActionSet::RequestDataL( CMceMsgSIPData& aContainer,
+ CSIPServerTransaction& aRequest )
+ {
+ const CSIPMessageElements* elements = MceSip::ToMessageElements( aRequest );
+
+
+ if ( elements )
+ {
+ aContainer.iTrxType = aRequest.Type().Index( SIPStrings::Table() );
+ aContainer.iSIPHeaders =
+ MceSip::UserHeadersToTextArrayL( aRequest,
+ iSession.Dialog()->Dialog() );
+ aContainer.iContentType = elements->ContentType() ?
+ elements->ContentType()->ToTextValueL() :
+ KNullDesC8().AllocL();
+ }
+
+ return elements;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendBodyToClientL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendBodyToClientL( TMceIds& aIds,
+ CMceComSession& aBody,
+ HBufC8* aContent )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendBodyToClientL, Entry");
+//PaisRic MCESRV_DEBUG_COMSESSION((&aBody));
+
+ aBody.iID = MCE_SESSION_ID(&iSession);
+ aBody.iState = static_cast<CMceSession::TState>( aIds.iState );
+
+ CMceMsgObject<CMceComSession>* sessionMsg =
+ new (ELeave) CMceMsgObject<CMceComSession>( aBody,
+ EMceItcMsgTypeSession );
+ CleanupStack::PushL( sessionMsg );
+ sessionMsg->EncodeL();
+ aIds.iMsgType = sessionMsg->Type();
+
+ HBufC8* encSession = sessionMsg->EncodeBufferCloneL();
+ CleanupStack::PopAndDestroy( sessionMsg );
+ CleanupStack::PushL( encSession );
+
+ if ( aIds.iCallbackID == EMceItcObjectAdded )
+ {
+ MCESRV_DEBUG("SendBodyToClientL: sending to manager");
+ iSession.Client().SendToClientL( aIds, encSession, aContent );
+ }
+ else
+ {
+ MCESRV_DEBUG("SendBodyToClientL: sending to session");
+ iSession.SendToClientL( aIds, encSession, aContent );
+ }
+
+
+ CleanupStack::Pop( encSession );
+
+ MCESRV_DEBUG("TMceActionSet::SendBodyToClientL, Entry");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendSIPDataToClientL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendSIPDataToClientL( TMceIds& aIds,
+ CMceMsgBase& aData,
+ HBufC8* aContent )
+
+ {
+ aData.EncodeL();
+
+ aIds.iMsgType = aData.Type();
+
+ HBufC8* context = aData.EncodeBufferCloneL();
+ CleanupStack::PushL( context );
+
+ iSession.SendToClientL( aIds, context, aContent );
+ CleanupStack::Pop( context );
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendAnswerL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendAnswerL( CSIPServerTransaction& aRequest )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendAnswerL, Entry");
+
+ CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply();
+ CleanupStack::PushL( reply );
+
+ reply->iCode = KMceSipOK;
+ reply->iReasonAsPoolIndex = SipStrConsts::EPhraseOk;
+
+
+ SendAnswerL( aRequest, *reply );
+
+ CleanupStack::PopAndDestroy( reply );
+
+ MCESRV_DEBUG("TMceActionSet::SendAnswerL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendAnswerL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendAnswerL( CSIPServerTransaction& aRequest,
+ CMceMsgBase& aReply )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendAnswerL( message ), Entry");
+
+ //content, content type etc are stored to session in update
+
+ CMceMsgSIPReply* reply = static_cast<CMceMsgSIPReply*>( &aReply );
+ if ( !reply )
+ {
+ SendAnswerL( aRequest );
+ return;
+ }
+
+ CSdpDocument* offer = iSession.Offer();
+ HBufC8* sipContentType = ActiveBody().iSIPContentType;
+ HBufC8* sipContent = ActiveBody().iSIPContent;
+ if ( offer
+ && MCE_HAS_DATA( sipContentType )
+ && MCE_HAS_DATA( sipContent )
+ )
+ {
+ reply->iContentTypeId = EMceContentTypeMultiPart;
+ }
+ else if ( offer )
+ {
+ reply->iContentTypeId = EMceContentTypeSDP;
+ }
+ else
+ {
+ //NOP
+ }
+
+
+ SendResponseL( aRequest, *reply );
+ aReply.Close();
+
+ if ( iSession.SubState() == CMceSipSession::EAnswering )
+ {
+ iSession.StartSessionTimerL();
+ }
+
+ MCESRV_DEBUG("TMceActionSet::SendAnswerL( message ), Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::BodyToTextL
+// -----------------------------------------------------------------------------
+//
+HBufC8* TMceActionSet::BodyToTextL()
+ {
+ HBufC8* encodedBody = NULL;
+
+ CMceMsgObject<CMceComSession>* sessionMsg =
+ new (ELeave) CMceMsgObject<CMceComSession>( *iSession.Body(),
+ EMceItcMsgTypeSession );
+ CleanupStack::PushL( sessionMsg );
+ sessionMsg->EncodeL();
+
+ encodedBody = sessionMsg->EncodeBuffer().Ptr(0).AllocL();
+
+ CleanupStack::PopAndDestroy( sessionMsg );
+
+ return encodedBody;
+ }
+
+
+//
+// SIP Sending
+//
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendInviteL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendInviteL( CMceComSession& aData )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendInviteL, Entry");
+
+ SendRequestL( SipStrConsts::EInvite, &aData );
+
+ MCESRV_DEBUG("TMceActionSet::SendInviteL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendUpdateRequestL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendUpdateRequestL()
+ {
+ MCESRV_DEBUG("TMceActionSet::SendUpdateRequestL, Entry");
+
+ SendRequestL( SipStrConsts::EUpdate );
+
+ MCESRV_DEBUG("TMceActionSet::SendUpdateMethodL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendPrackL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendPrackL( TBool aContent )
+ {
+ MCESRV_DEBUG("SendPrackL::SendUpdateRequestL, Entry");
+
+ SendRequestL( SipStrConsts::EPrack, NULL, aContent );
+
+ MCESRV_DEBUG("SendPrackL::SendUpdateMethodL, Exit");
+ }
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendExtensionRequestL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendExtensionRequestL( CMceMsgBase& aData, TMceIds& aIds )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendExtensionRequestL, Entry");
+
+ CMceMsgSIPRequest* data = static_cast<CMceMsgSIPRequest*>( &aData );
+
+ CSIPMessageElements* elements = CSIPMessageElements::NewLC();
+
+ CSIPContentTypeHeader* contentType = NULL;
+
+ HBufC8* content = iSession.PopClientContent();
+
+ if ( MCE_HAS_DATA( content ) )
+ {
+ CleanupStack::PushL( content );
+
+ MCESRV_DEBUG_SVALUE( "Sending Session Request: content size", content->Length() );
+ if ( MCE_HAS_DATA( data->iContentType ) )
+ {
+ MCESRV_DEBUG_SVALUE( "SendExtensionRequestL: content type", *data->iContentType );
+ contentType = MceSip::ToContentTypeHeaderL(
+ EMceContentTypeUserDefined,
+ data->iContentType );
+ CleanupStack::PushL( contentType );
+ }
+ else
+ {
+ MCESRV_DEBUG( "SendSessionRequestL: no content type -> no content" );
+ CleanupStack::PopAndDestroy( content );
+ content = NULL;
+ }
+ }
+ else
+ {
+ delete content;
+ content = NULL;
+ }
+
+ if ( content )
+ {
+ elements->SetContentL( content , contentType );
+ CleanupStack::Pop( contentType );
+ CleanupStack::Pop( content );
+ }
+
+ RStringF methodStr = SIPStrings::Pool().OpenFStringL(data->RequestMethod()->Des());
+ CleanupClosePushL( methodStr );
+
+ TInt method = MceSip::SIPStringIndex( methodStr.DesC() );
+
+ //create extension headers
+ RPointerArray<CSIPHeaderBase> headers;
+ CSIPHeaderBase::PushLC( &headers );
+
+ // Add extension headers
+ AddExtensionHeadersL( headers, method, ETrue );
+
+
+ //Add Extra SIP Headers.
+ AddHeadersL( headers,
+ data->iSIPHeaders,
+ KErrNotFound );
+
+ //create session timer headers
+ AddSessionTimerFieldsClientL( headers );
+
+
+ //send request within session
+ elements->SetUserHeadersL( headers );
+ CleanupStack::PopAndDestroy( &headers );
+
+ CSIPInviteDialogAssoc* dialog =
+ static_cast<CSIPInviteDialogAssoc*>( iSession.Dialog() );
+
+ MCESRV_DEBUG_METHOD("SendRequestL: sending ", method );
+
+ CSIPClientTransaction* trx = NULL;
+
+ trx = dialog->SendNonTargetRefreshRequestL( methodStr, elements );
+
+ CleanupStack::PopAndDestroy(); //destroy methodStr
+ CleanupStack::Pop( elements );
+
+ CleanupStack::PushL( trx );
+
+ iSession.SetPendingTransactionL( trx );
+
+ CleanupStack::Pop( trx );
+
+ MCESRV_DEBUG_METHOD("SendExtensionRequestL: sent ", method );
+
+ aIds.iTransactionID = reinterpret_cast <TUint> (trx);
+
+ MCESRV_DEBUG("TMceActionSet::SendExtensionRequestL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendRequestL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendRequestL( TInt aMethod, CMceComSession* aData,
+ TBool aContent )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendRequestL, Entry");
+
+ __ASSERT_ALWAYS( iSession.Dialog(), User::Leave( KErrGeneral ) );
+
+ CSIPMessageElements* elements = CSIPMessageElements::NewLC();
+
+ //create content
+ CSdpDocument* offer = iSession.Offer();
+ CSIPContentTypeHeader* contentType = NULL;
+ HBufC8* content = NULL;
+
+ if ( aContent )
+ {
+
+ if ( offer
+ && aData
+ && MCE_HAS_DATA( aData->iSIPContentType )
+ && MCE_HAS_DATA( aData->iSIPContent )
+ )
+ {
+ MCESRV_DEBUG("SendRequestL: creating multi-part content");
+ content = CreateMultipartContentLC( *offer,
+ *aData->iSIPContentType,
+ *aData->iSIPContent );
+
+ contentType = MceSip::ToContentTypeHeaderL( EMceContentTypeMultiPart );
+ CleanupStack::PushL( contentType );
+ }
+ else if ( offer )
+ {
+ MCESRV_DEBUG("SendRequestL: creating SDP content");
+ content = CreateSDPContentLC( *offer );
+ contentType = MceSip::ToContentTypeHeaderL( EMceContentTypeSDP );
+ CleanupStack::PushL( contentType );
+ }
+ else
+ {
+ MCESRV_DEBUG("SendRequestL: NO OFFER");
+ //NOP
+ }
+ }
+ else
+ {
+ MCESRV_DEBUG("SendRequestL: NO OFFER");
+ //NOP
+ }
+
+
+ if ( content )
+ {
+ elements->SetContentL( content, contentType );
+ CleanupStack::Pop( contentType );
+ CleanupStack::Pop( content );
+ }
+
+
+ //create extension headers
+ RPointerArray<CSIPHeaderBase> headers;
+ CSIPHeaderBase::PushLC( &headers );
+
+ // Add extension headers
+ AddExtensionHeadersL( headers, aMethod, ETrue );
+
+ // Add user defined headers
+ AddHeadersL( headers,
+ ( aData ? aData->iSIPHeaders : ActiveBody().iSIPHeaders ),
+ aMethod );
+
+ //create session timer headers
+ AddSessionTimerFieldsClientL( headers );
+
+ //send invitation
+ elements->SetUserHeadersL( headers );
+ CleanupStack::PopAndDestroy( &headers );
+
+ CSIPInviteDialogAssoc* dialog =
+ static_cast<CSIPInviteDialogAssoc*>( iSession.Dialog() );
+
+ MCESRV_DEBUG_METHOD("SendRequestL: sending ", aMethod );
+
+ CSIPClientTransaction* trx = NULL;
+ switch ( aMethod )
+ {
+ case SipStrConsts::EInvite:
+ {
+ trx = dialog->SendInviteL( elements );
+ break;
+ }
+ case SipStrConsts::EUpdate:
+ {
+ trx = dialog->SendUpdateL( elements );
+ break;
+ }
+ case SipStrConsts::EPrack:
+ {
+ trx = dialog->SendPrackL( elements );
+ break;
+ }
+ default:
+ {
+ User::Leave( KErrNotSupported );
+ break;
+ }
+ }
+ CleanupStack::Pop( elements );
+
+ CleanupStack::PushL( trx );
+ iSession.SetPendingTransactionL( trx );
+
+ MCESRV_DEBUG_METHOD("SendRequestL: sent ", aMethod );
+
+ CleanupStack::Pop( trx );
+
+ if ( content )
+ {
+ iSession.IncrementSentSdpCount();
+ }
+
+ MCESRV_DEBUG("TMceActionSet::SendRequestL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendDeclineL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendDeclineL( CSIPServerTransaction& aRequest,
+ CMceMsgBase& aReply )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendDeclineL, Entry");
+
+ CMceMsgSIPReply* reply = static_cast<CMceMsgSIPReply*>( &aReply );
+ TBool userReply = MCE_NOT_NULL_PTR( reply );
+
+ if ( !userReply )
+ {
+ reply = new (ELeave) CMceMsgSIPReply();
+ CleanupStack::PushL( reply );
+ reply->iCode = KMceSipDecline;
+ reply->iReasonAsPoolIndex = SipStrConsts::EPhraseDecline;
+ }
+
+ SendResponseL( aRequest, *reply );
+ reply->Close();
+
+ if ( !userReply )
+ {
+ CleanupStack::PopAndDestroy( reply );
+ }
+
+ MCESRV_DEBUG("TMceActionSet::SendDeclineL, Exit");
+
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendRingL
+// -----------------------------------------------------------------------------
+//
+TBool TMceActionSet::SendRingL( CSIPServerTransaction& aRequest,
+ CMceMsgBase& aReply )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendRingL, Entry");
+
+ CMceMsgSIPReply* reply = static_cast<CMceMsgSIPReply*>( &aReply );
+ TBool userReply = MCE_NOT_NULL_PTR( reply );
+
+ if ( !userReply )
+ {
+ reply = new (ELeave) CMceMsgSIPReply();
+ CleanupStack::PushL( reply );
+ reply->iCode = KMceSipRinging;
+ reply->iReasonAsPoolIndex = SipStrConsts::EPhraseRinging;
+ }
+
+ TBool reliable = SendResponseL( aRequest, *reply );
+ reply->Close();
+
+ if ( !userReply )
+ {
+ CleanupStack::PopAndDestroy( reply );
+ }
+
+ MCESRV_DEBUG("TMceActionSet::SendRingL, Exit");
+ return reliable;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendSipQueuedL
+// -----------------------------------------------------------------------------
+
+TBool TMceActionSet::SendSipQueuedL( CSIPServerTransaction& aRequest,
+ CMceMsgBase& aReply )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendSipQueuedL, Entry");
+
+ CMceMsgSIPReply* reply = static_cast<CMceMsgSIPReply*>( &aReply );
+ TBool userReply = MCE_NOT_NULL_PTR( reply );
+
+ if ( !userReply )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ TBool reliable = SendResponseL( aRequest, *reply );
+ reply->Close();
+
+ if ( !userReply )
+ {
+ CleanupStack::PopAndDestroy( reply );
+ }
+
+ MCESRV_DEBUG("TMceActionSet::SendSipQueuedL, Exit");
+ return reliable;
+ }
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendResponseL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendResponseL( CSIPServerTransaction& aRequest,
+ TUint32 aCode,
+ TInt aReason )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendResponseL, Entry");
+
+
+ CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply();
+ CleanupStack::PushL( reply );
+ reply->iCode = aCode;
+ reply->iReasonAsPoolIndex = aReason;
+ reply->iContentTypeId = EMceContentTypeSDP;
+
+ if ( aReason == KMceAutoReasonPhrase )
+ {
+ RStringF reasonPhrase = MceSip::ReasonPhraseL( aCode );
+ CleanupClosePushL( reasonPhrase );
+ reply->iReasonAsPoolIndex = reasonPhrase.Index( SIPStrings::Table() );
+ reply->iContentTypeId = (TMceContentType)KMceNotAssigned;
+ CleanupStack::PopAndDestroy();//reasonPhrase
+
+ }
+ if ( aReason == KMceSipPreconditionFailure )
+ {
+ reply->iReasonAsPoolIndex = 0;
+ HBufC8* reason = KMceSipErrPhrase580().AllocLC();
+ MCE_DELETE( reply->iReason );
+ reply->iReason = reason;
+ CleanupStack::Pop( reason );
+ }
+
+ SendResponseL( aRequest, *reply );
+ //delete header, icontent type and iheader, reason
+ reply->Close();
+ CleanupStack::PopAndDestroy( reply );
+
+ MCESRV_DEBUG("TMceActionSet::SendResponseL, Exit");
+
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendRejectOfferWithWarningL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendRejectOfferWithWarningL(
+ TMceSipWarningCode aReason,
+ CSIPServerTransaction& aInvite )
+ {
+
+ if ( aReason >= KMceSipBadRequest &&
+ aReason <= KMceSip6XXNotAcceptable )
+ {
+ if ( aReason == KMceSipPreconditionFailure )
+ {
+ SendResponseL( aInvite, (TUint32)aReason, KMceSipPreconditionFailure );
+ }
+ else
+ {
+ SendResponseL( aInvite, (TUint32)aReason, KMceAutoReasonPhrase );
+ }
+ }
+ else
+ {
+ SendWarningResponseL( KMceSipNotAcceptableHere, aReason, aInvite );
+ }
+ }
+
+
+
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendWarningResponseL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendWarningResponseL( const TUint aResponseCode,
+ const TUint aWarnCode,
+ CSIPServerTransaction& aRequest )
+ {
+
+ MCESRV_DEBUG("TMceActionSet::SendWarningResponseL, Entry");
+ MCESRV_DEBUG_DVALUES( "response", aResponseCode, "warning", aWarnCode );
+
+ const TInt KPopCount = 2;
+
+ RStringF reasonPhrase = MceSip::ReasonPhraseL( aResponseCode );
+ CleanupClosePushL( reasonPhrase );
+ RStringF warningPhrase = MceSip::WarningPhraseL( aWarnCode );
+ CleanupClosePushL( warningPhrase );
+
+ CSIPResponseElements* response =
+ CSIPResponseElements::NewLC( aResponseCode, reasonPhrase );
+
+ CSIPMessageElements& responseMessageElements =
+ response->MessageElements();
+
+ const CSIPRequestElements* requestElements = aRequest.RequestElements();
+ const TDesC8& domain =
+ requestElements->RemoteUri().Uri().Extract( EUriHost );
+
+ // Create SIPExtensionHeader:
+ const TInt warnCodeLength = 3;
+ TInt warnLenght = KMceSipWarningPattern().Length() + domain.Length() +
+ warningPhrase.DesC().Length() + warnCodeLength;
+ HBufC8* warning = HBufC8::NewLC( warnLenght );
+ warning->Des().AppendFormat( KMceSipWarningPattern, aWarnCode,
+ &domain, &(warningPhrase.DesC()) );
+
+ RPointerArray< CSIPHeaderBase > headerArray;
+ CSIPHeaderBase::PushLC( &headerArray );
+
+ CSIPExtensionHeader* sipExtensionWarningHeader =
+ CSIPExtensionHeader::NewLC( KMceSipWarning, *warning );
+
+ headerArray.AppendL( sipExtensionWarningHeader );
+ CleanupStack::Pop( sipExtensionWarningHeader );
+
+ responseMessageElements.SetUserHeadersL( headerArray );
+ CleanupStack::Pop( &headerArray );// headerArray
+
+ CleanupStack::PopAndDestroy( warning );
+
+ aRequest.SendResponseL( response );
+
+
+ CleanupStack::Pop( response );
+ CleanupStack::PopAndDestroy( KPopCount );//warningPhrase,reasonPhrase
+
+ MCESRV_DEBUG("TMceActionSet::SendWarningResponseL, Entry");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendResponseL
+// -----------------------------------------------------------------------------
+//
+TBool TMceActionSet::SendResponseL( CSIPServerTransaction& aRequest,
+ CMceMsgSIPReply& aResponse )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendResponseL( custom ), Entry");
+ MCESRV_DEBUG_DVALUE( "reason", aResponse.iCode );
+
+ CSIPResponseElements* response = NULL;
+
+ if ( !aResponse.iReasonAsPoolIndex )
+ {
+ MCESRV_DEBUG_SVALUE( "phrase", *aResponse.iReason );
+
+ RStringF reasonPhrase =
+ SIPStrings::Pool().OpenFStringL( *aResponse.iReason );
+ CleanupClosePushL( reasonPhrase );
+
+ response =
+ CSIPResponseElements::NewL( aResponse.iCode, reasonPhrase );
+
+ CleanupStack::PopAndDestroy();//reasonPhrase
+ CleanupStack::PushL( response );
+ }
+ else
+ {
+ MCESRV_DEBUG_SVALUE( "phrase",
+ SIPStrings::StringF( aResponse.iReasonAsPoolIndex ).DesC() );
+
+ response =
+ CSIPResponseElements::NewLC( aResponse.iCode,
+ SIPStrings::StringF( aResponse.iReasonAsPoolIndex ) );
+ }
+
+ CSIPMessageElements& elements = response->MessageElements();
+ RPointerArray<CSIPHeaderBase> headers;
+ CSIPHeaderBase::PushLC( &headers );
+
+ TBool reliable = AddExtensionHeadersL(
+ headers,
+ aRequest.Type().Index( SIPStrings::Table() ),
+ aResponse.iContentTypeId == EMceContentTypeSDP ? ETrue : EFalse,
+ ETrue,
+ aResponse.iCode );
+
+ if ( !MCE_HAS_DATA( aResponse.iSIPHeaders ) )
+ {
+ AddHeadersL( headers,
+ ActiveBody().iSIPHeaders,
+ KErrNotFound );
+ }
+ else
+ {
+ AddHeadersL( headers,
+ aResponse.iSIPHeaders,
+ KErrNotFound );
+ }
+
+ if ( ( aRequest.Type() == SIPStrings::StringF( SipStrConsts::EInvite ) ||
+ aRequest.Type() == SIPStrings::StringF( SipStrConsts::EUpdate ) ) &&
+ aResponse.iCode == KMceSipOK )
+ {
+ //add timer headers only to 200 OK of invite
+ AddSessionTimerFieldsServerL( headers );
+ }
+
+ elements.SetUserHeadersL( headers );
+ CleanupStack::Pop( &headers );
+
+ CSIPContentTypeHeader* contentType = NULL;
+ HBufC8* content = NULL;
+ CSdpDocument* offer = iSession.Offer();
+
+ if ( aResponse.iContentTypeId == EMceContentTypeMultiPart )
+ {
+ MCESRV_DEBUG( "SendResponseL: content type=\"multipart/mixed\"");
+ content = CreateMultipartContentLC( *offer,
+ *ActiveBody().iSIPContentType,
+ *ActiveBody().iSIPContent );
+
+ contentType =
+ MceSip::ToContentTypeHeaderL( EMceContentTypeMultiPart );
+ CleanupStack::PushL( contentType );
+ }
+ else if ( aResponse.iContentTypeId == EMceContentTypeSDP )
+ {
+ MCESRV_DEBUG( "SendResponseL: content type=\"application/sdp\"");
+ content = CreateSDPContentLC( *offer );
+ contentType = MceSip::ToContentTypeHeaderL( EMceContentTypeSDP );
+ CleanupStack::PushL( contentType );
+ }
+ else if ( aResponse.iContentTypeId == EMceContentTypeUserDefined &&
+ MCE_HAS_DATA( aResponse.iContentType ) )
+ {
+ MCESRV_DEBUG_SVALUE(
+ "SendResponseL: content type", *aResponse.iContentType );
+ content = iSession.PopClientContent();
+ if ( content )
+ {
+ CleanupStack::PushL( content );
+ contentType = MceSip::ToContentTypeHeaderL(
+ EMceContentTypeUserDefined,
+ aResponse.iContentType );
+ CleanupStack::PushL( contentType );
+ }
+ else
+ {
+ MCESRV_DEBUG( "SendResponseL: no content");
+ }
+ }
+ else
+ {
+ MCESRV_DEBUG( "SendResponseL: no content");
+ }
+
+
+ if ( content )
+ {
+ elements.SetContentL( content, contentType );
+ CleanupStack::Pop( contentType );
+ CleanupStack::Pop( content );
+ }
+
+
+ if ( reliable )
+ {
+ CMceReliableSender& reliableSend = iSession.ReliableSender();
+ reliableSend.SendResponseL( aRequest, response );
+ CleanupStack::Pop( response );
+ }
+
+ else
+ {
+ aRequest.SendResponseL( response );
+ CleanupStack::Pop( response );
+ MCESRV_DEBUG("TMceActionSet::SendResponseL( custom ), Exit");
+ }
+
+ if ( aResponse.iContentTypeId == EMceContentTypeMultiPart ||
+ aResponse.iContentTypeId == EMceContentTypeSDP )
+ {
+ iSession.IncrementSentSdpCount();
+ }
+
+ return reliable;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendACKL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendACKL( CSIPClientTransaction& aResponse )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendACKL, Entry");
+
+ CSIPMessageElements* ack = CSIPMessageElements::NewLC();
+
+ AddHeadersL( *ack, NULL, SipStrConsts::EAck );
+ static_cast<CSIPInviteDialogAssoc*>
+ ( iSession.Dialog() )->SendAckL( aResponse, ack );
+ CleanupStack::Pop( ack );
+ MCESRV_DEBUG("TMceActionSet::SendACKL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendBYEL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendBYEL()
+ {
+ MCESRV_DEBUG("TMceActionSet::SendBYEL, Entry");
+
+ CSIPMessageElements* bye = CSIPMessageElements::NewLC();
+ AddHeadersL( *bye, NULL, SipStrConsts::EBye );
+
+ CSIPClientTransaction* trx = static_cast<CSIPInviteDialogAssoc*>
+ ( iSession.Dialog() )->SendByeL( bye );
+ CleanupStack::Pop( bye );
+ CleanupStack::PushL( trx );
+ iSession.SetPendingTransactionL( trx );
+ CleanupStack::Pop( trx );
+
+ MCESRV_DEBUG("TMceActionSet::SendBYEL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendBYEL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::SendBYEL( CMceMsgBase& aData )
+ {
+ MCESRV_DEBUG("TMceActionSet::SendBYEL(data), Entry");
+
+ CMceMsgSIPData* data = static_cast<CMceMsgSIPData*>( &aData );
+
+ if ( !data )
+ {
+ SendBYEL();
+ return;
+ }
+
+ CSIPMessageElements* bye = CSIPMessageElements::NewLC();
+
+ AddHeadersL( *bye, data->iSIPHeaders, SipStrConsts::EBye );
+
+ CSIPContentTypeHeader* contentType = NULL;
+ HBufC8* content = iSession.PopClientContent();
+ if ( MCE_HAS_DATA( content ) )
+ {
+ CleanupStack::PushL( content );
+ MCESRV_DEBUG_SVALUE( "SendBYEL: content size", content->Length() );
+ if ( MCE_HAS_DATA( data->iContentType ) )
+ {
+ MCESRV_DEBUG_SVALUE( "SendBYEL: content type", *data->iContentType );
+ contentType = MceSip::ToContentTypeHeaderL(
+ EMceContentTypeUserDefined,
+ data->iContentType );
+ CleanupStack::PushL( contentType );
+ }
+ else
+ {
+ MCESRV_DEBUG( "SendBYEL: no content type -> no content" );
+ CleanupStack::PopAndDestroy( content );
+ content = NULL;
+ }
+ }
+ else
+ {
+ delete content;
+ content = NULL;
+ }
+
+ if ( content )
+ {
+ bye->SetContentL( content , contentType );
+ CleanupStack::Pop( contentType );
+ CleanupStack::Pop( content );
+ }
+
+ aData.Close();
+
+ CSIPClientTransaction* trx = static_cast<CSIPInviteDialogAssoc*>
+ ( iSession.Dialog() )->SendByeL( bye );
+ CleanupStack::Pop( bye );
+ CleanupStack::PushL( trx );
+ iSession.SetPendingTransactionL( trx );
+ CleanupStack::Pop( trx );
+
+ MCESRV_DEBUG("TMceActionSet::SendBYEL(data), Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::Send200OKL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::Send200OKL( CSIPServerTransaction& aRequest )
+ {
+ MCESRV_DEBUG("TMceActionSet::Send200OKL, Entry");
+
+ CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply();
+ CleanupStack::PushL( reply );
+ reply->iCode = KMceSipOK;
+ reply->iReasonAsPoolIndex = SipStrConsts::EPhraseOk;
+
+ SendResponseL( aRequest, *reply );
+
+ CleanupStack::PopAndDestroy( reply );
+
+ MCESRV_DEBUG("TMceActionSet::Send200OKL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::SendCancelL
+// -----------------------------------------------------------------------------
+//
+TBool TMceActionSet::SendCancelL()
+ {
+ MCESRV_DEBUG("TMceActionSet::SendCancelL, Entry");
+ TBool cancelSent = ETrue;
+
+ CSIPClientTransaction* inviteTransaction = iSession.InviteTransaction();
+
+ __ASSERT_ALWAYS( inviteTransaction, User::Leave( KErrGeneral ) );
+ __ASSERT_ALWAYS( inviteTransaction->CancelAllowed(),
+ User::Leave( KErrGeneral ) );
+
+ CSIPTransactionBase::TState trxState =
+ MceSip::TrxState( *inviteTransaction );
+
+ if ( trxState == CSIPTransactionBase::EProceeding )
+ {
+ CSIPClientTransaction* trx = inviteTransaction->CancelL();
+ CleanupStack::PushL( trx );
+ iSession.SetPendingTransactionL( trx );
+ CleanupStack::Pop( trx );
+ }
+ else
+ {
+ MCESRV_DEBUG_DVALUE(
+ "SendCancelL: CANCEL is not sent. Trx state", trxState );
+ cancelSent = EFalse;
+ }
+
+ MCESRV_DEBUG("TMceActionSet::SendCancelL, Exit");
+
+ return cancelSent;
+
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::InterruptConfirming
+// -----------------------------------------------------------------------------
+//
+TBool TMceActionSet::InterruptConfirming()
+ {
+ MCESRV_DEBUG("TMceActionSet::InterruptConfirming, Entry");
+
+ TBool interrupted = EFalse;
+ CSIPClientTransaction* pending = iSession.PendingTransaction(
+ SIPStrings::StringF( SipStrConsts::EUpdate ) );
+ pending = ( pending && !MceSip::TrxCompleted( *pending )
+ ? pending : NULL );
+
+ if ( !pending )
+ {
+ MCESRV_DEBUG("TMceActionSet::InterruptConfirming, search PRACK");
+ // no UPDATE so search for PRACK
+ pending = iSession.PendingTransaction(
+ SIPStrings::StringF( SipStrConsts::EPrack ) );
+ pending = ( pending && !MceSip::TrxCompleted( *pending )
+ ? pending : NULL );
+ }
+
+ if ( pending )
+ {
+ MCESRV_DEBUG("TMceActionSet::InterruptConfirming, removing");
+ iSession.RemovePendingTrx( *pending );
+ delete pending;
+ interrupted = ETrue;
+ }
+
+ MCESRV_DEBUG("TMceActionSet::InterruptConfirming, Exit");
+ return interrupted;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ControlMediaL
+// -----------------------------------------------------------------------------
+//
+HBufC8* TMceActionSet::ControlMediaL( TMceIds& aIds, TMceItcFunctions aAction )
+
+ {
+ MCESRV_DEBUG("TMceActionSet::ControlMediaL, Entry");
+ MCESRV_DEBUG_EVENT("action", aAction );
+
+ __ASSERT_ALWAYS( iSession.iBody, User::Leave( KErrNotReady ) );
+
+ HBufC8* returnMessage = NULL;
+ CMceMediaManager& mediaManager = iSession.Manager().MediaManager();
+
+ TMceComEventHandler handler( mediaManager, returnMessage );
+ TMceComEvent event( aIds, NULL, aAction, handler );
+
+ ActiveBody().EventReceivedL( event );
+
+ MCESRV_DEBUG("TMceActionSet::ControlMediaL, Exit");
+
+ return returnMessage;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ControlMediaL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ControlMediaL( TMceIds& aIds, TMceItcFunctions aAction,
+ const TDesC8& aMessage )
+ {
+ MCESRV_DEBUG("TMceActionSet::ControlMediaL, Entry");
+ MCESRV_DEBUG_EVENT("action", aAction );
+
+ __ASSERT_ALWAYS( iSession.iBody, User::Leave( KErrNotReady ) );
+
+ CMceMediaManager& mediaManager = iSession.Manager().MediaManager();
+
+ TMceComEventHandler handler( mediaManager, aMessage );
+ TMceComEvent event( aIds, NULL, aAction, handler );
+
+ ActiveBody().EventReceivedL( event );
+
+ MCESRV_DEBUG("TMceActionSet::ControlMediaL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ControlMediaL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ControlMediaL( TMceIds& aIds, TMceItcFunctions aAction,
+ TPtr8& aMessage )
+ {
+ MCESRV_DEBUG("TMceActionSet::ControlMediaL, Entry");
+ MCESRV_DEBUG_EVENT("action", aAction );
+
+ __ASSERT_ALWAYS( iSession.iBody, User::Leave( KErrNotReady ) );
+
+ CMceMediaManager& mediaManager = iSession.Manager().MediaManager();
+
+ TMceComEventHandler handler( mediaManager, aMessage );
+ TMceComEvent event( aIds, NULL, aAction, handler );
+
+ ActiveBody().EventReceivedL( event );
+
+ MCESRV_DEBUG("TMceActionSet::ControlMediaL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::StopMedia
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::StopMedia()
+ {
+ MCESRV_DEBUG("TMceActionSet::StopMedia, Entry");
+
+ CMceMediaManager& mediaManager = iSession.Manager().MediaManager();
+
+ if ( iSession.BodyCandidate() )
+ {
+ mediaManager.CloseSession( *iSession.BodyCandidate() );
+ }
+ if ( iSession.Body() )
+ {
+ iSession.CloseMedia();
+ }
+
+ MCESRV_DEBUG("TMceActionSet::StopMedia, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::StopUpdatingMedia
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::StopUpdatingMedia()
+ {
+ MCESRV_DEBUG("TMceActionSet::StopUpdatingMedia, Entry");
+
+ CMceMediaManager& mediaManager = iSession.Manager().MediaManager();
+
+ if ( iSession.BodyCandidate() &&
+ iSession.SubState() == CMceSipSession::EUpdating)
+ {
+ mediaManager.CloseSession( *iSession.BodyCandidate() );
+ }
+
+ MCESRV_DEBUG("TMceActionSet::StopUpdatingMedia, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ClientMediaStateChanged
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ClientMediaStateChangedL( TMceMccComEvent* aMccEvent,
+ TMceMediaEventCode aEvent )
+ {
+ MCESRV_DEBUG("TMceActionSet::ClientMediaStateChanged, Entry");
+
+ if ( aMccEvent &&
+ aMccEvent->iItcEvent != EMceItcNotAssigned &&
+ aMccEvent->iStream )
+ {
+
+ if ( aEvent == EMceMediaError && aMccEvent->iError == KErrHostUnreach )
+ {
+ // If there have been too many ICMP errors, pause the stream.
+ const RPointerArray< CMceComMediaSink >& sinks = aMccEvent->iStream->Sinks();
+
+ for ( TInt i=0 ; i<sinks.Count() ; ++i )
+ {
+ if ( sinks[i]->MccType() == KUidMccRtpSink )
+ {
+ iSession.Manager().MediaManager().PauseL( *sinks[i] );
+ }
+ }
+
+ }
+
+ TMceIds ids;
+ ids.iCallbackID = aMccEvent->iItcEvent;
+ ids.iMediaID = aMccEvent->iStream->Id();
+ ids.iSinkID = aMccEvent->iSink ? aMccEvent->iSink->Id() : KMceMediaIdNotAssigned;
+ ids.iSourceID = aMccEvent->iSource ? aMccEvent->iSource->Id() : KMceMediaIdNotAssigned;
+ ids.iState = aMccEvent->iItcData;
+ ids.iStatus = aMccEvent->iError;
+
+ iSession.SendToClient( ids );
+ }
+ else
+ {
+ MCESRV_DEBUG("ClientMediaStateChanged: No target");
+ }
+
+ MCESRV_DEBUG("TMceActionSet::ClientMediaStateChanged, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ClientErrorOccured
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ClientErrorOccured( TInt aError )
+ {
+ MCESRV_DEBUG("TMceActionSet::ClientErrorOccured, Entry");
+ MCESRV_DEBUG_DVALUE("error", aError );
+
+ TMceIds ids;
+
+ ids.iCallbackID = EMceItcStateChanged;
+ ids.iState = CMceSession::ETerminated;
+
+ iSession.SendErrorToClient( ids, aError );
+
+ MCESRV_DEBUG("TMceActionSet::ClientErrorOccured, Exit");
+ }
+
+
+//
+// SDP manipulation
+//
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::CreateMultipartContentL
+// -----------------------------------------------------------------------------
+//
+HBufC8* TMceActionSet::CreateMultipartContentLC( CSdpDocument& aDocument,
+ const TDesC8& aMixedContentType,
+ const TDesC8& aMixedContent )
+ {
+ MCESRV_DEBUG("TMceActionSet::CreateMultipartContentL, Entry");
+ HBufC8* sdpOffer = CreateSDPContentLC( aDocument );
+
+ const TDesC8& sdp = *sdpOffer;
+ TInt length = KMceSipMPartMessagePattern().Length() + sdp.Length() +
+ aMixedContentType.Length() + aMixedContent.Length();
+ HBufC8* content = HBufC8::NewL( length );
+
+ content->Des().AppendFormat( KMceSipMPartMessagePattern,
+ &sdp,
+ &aMixedContentType,
+ &aMixedContent );
+
+ CleanupStack::PopAndDestroy( sdpOffer );
+ CleanupStack::PushL( content );
+
+ MCESRV_DEBUG("TMceActionSet::CreateMultipartContentL, Exit");
+
+ return content;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::CreateSDPContentLC
+// -----------------------------------------------------------------------------
+//
+HBufC8* TMceActionSet::CreateSDPContentLC( CSdpDocument& aDocument )
+ {
+ MCESRV_DEBUG("TMceActionSet::CreateSDPContentLC, Entry");
+
+ CBufFlat* encBuf = CBufFlat::NewL( KMaxLengthOfSDPMessage );
+ CleanupStack::PushL( encBuf );
+ RBufWriteStream writeStream;
+ writeStream.Open( *encBuf );
+ aDocument.EncodeL( writeStream );
+ writeStream.Close();
+ TPtr8 encBufPtr = encBuf->Ptr(0);
+ HBufC8* sdpBuf = sdpBuf = encBufPtr.AllocL();
+ CleanupStack::PopAndDestroy( encBuf );
+ CleanupStack::PushL( sdpBuf );
+
+ MCESRV_DEBUG("TMceActionSet::CreateSDPContentLC, Exit");
+
+ return sdpBuf;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::AddHeadersL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::AddHeadersL( CSIPMessageElements& aMessageElements,
+ CDesC8Array* aPrimaryHeaders,
+ TInt aMethodInd )
+ {
+ RPointerArray<CSIPHeaderBase> headers;
+ CSIPHeaderBase::PushLC( &headers );
+ TInt allowInd = SipStrConsts::EAllowHeader;
+ AddHeadersL( headers, aPrimaryHeaders, aMethodInd );
+
+ //if allow header is there add all UA supported headers
+
+ CSIPHeaderBase* allowHeader = MceSip::FindHeader( headers,
+ SIPStrings::StringF( SipStrConsts::EAllowHeader ));
+ if ( allowHeader )
+ {
+ RArray<TInt> allowMethods;
+ CleanupClosePushL(allowMethods);
+ TInt index =0;
+ MceSip::BasicAllowMethodsL( allowMethods );
+
+ for ( index =0; index < allowMethods.Count(); index ++)
+ {
+ if ( !MceSip::HasHeaderValueL( aMessageElements, allowInd,
+ SIPStrings::StringF( allowMethods[ index ]).DesC() ))
+ {
+ MceSip::AddAllowHeaderL( headers, allowMethods[ index ]);
+ }
+
+ }
+ CleanupStack::PopAndDestroy(&allowMethods);
+ }
+ aMessageElements.SetUserHeadersL( headers );
+ CleanupStack::Pop( &headers );
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::AddHeadersL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::AddHeadersL( RPointerArray<CSIPHeaderBase>& aHeaders,
+ CDesC8Array* aPrimaryHeaders,
+ TInt aMethodInd )
+ {
+
+ TInt allowInd = SipStrConsts::EAllowHeader;
+ RArray< TInt > allowMethods;
+ CleanupClosePushL(allowMethods);
+ TInt index =0;
+
+ CDesC8Array& txtHeaders = aPrimaryHeaders && aPrimaryHeaders->Count() > 0 ?
+ *aPrimaryHeaders : iSession.DefaultHeaders( aMethodInd );
+ if ( txtHeaders.Count() )
+ {
+ MCESRV_DEBUG("AddHeadersL: creating extension headers");
+ MceSip::ToSIPExtensionHeadersL( aHeaders, txtHeaders );
+ }
+ //An Allow header field (Section 20.5) SHOULD be present in the INVITE.
+ //It indicates what methods can be invoked within a dialog
+ MceSip::BasicAllowMethodsL( allowMethods );
+ for ( index =0; index < allowMethods.Count(); index ++)
+ {
+ if ( !MceSip::HasHeaderValueL( aHeaders, allowInd,
+ SIPStrings::StringF( allowMethods[ index ]).DesC() ))
+ {
+ MceSip::AddAllowHeaderL( aHeaders, allowMethods[ index ]);
+ }
+
+ }
+ CleanupStack::PopAndDestroy(&allowMethods);
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::AddExtensionHeadersL
+// -----------------------------------------------------------------------------
+//
+TBool TMceActionSet::AddExtensionHeadersL(
+ RPointerArray<CSIPHeaderBase>& aHeaders,
+ TInt aTransactionType,
+ TBool aIsBody,
+ TBool aIsResponse,
+ TUint aResponseCode )
+ {
+ CMceSipExtensions& ext = iSession.Extensions();
+ TMceSipResponseType type = MceSip::ResponseType( aResponseCode );
+
+ TInt reliable = EFalse;
+ if ( aTransactionType == SipStrConsts::EInvite )
+ {
+ // Allow update, subscribe, prack, refer, notify
+ // extension methods for allow header
+ RArray<TInt> allowExts;
+ CleanupClosePushL(allowExts);
+ RArray< CMceSipExtensions::TExtension > localExts;
+ CleanupClosePushL(localExts);
+ TInt allowInd = SipStrConsts::EAllowHeader;
+ TInt index =0;
+
+ ext.ExtensionAllowMethodsL( allowExts );
+ ext.LocalSipExtensionsL( localExts );
+ //Adding headers only if the headers does not contains the methods
+ for( index = 0; index < allowExts.Count(); index++ )
+ {
+ TInt localExt = ext.Local( localExts[ index ] );
+ if ( localExt != CMceSipExtensions::ENotSupported &&
+ ( !aIsResponse || ( type == E1XX && aIsBody ) ) &&
+ !MceSip::HasHeaderValueL( aHeaders, allowInd,
+ SIPStrings::StringF( allowExts[ index ]).DesC() ))
+ {
+ // INVITE or 1XX to INVITE with SDP
+ MceSip::AddAllowHeaderL( aHeaders, allowExts[ index ] );
+ }
+ }
+ CleanupStack::PopAndDestroy(&localExts);
+ CleanupStack::PopAndDestroy(&allowExts);
+ //clean arrays
+
+ // Supported: secprecondition
+ TInt localSecPreconds = ext.Local( CMceSipExtensions::ESecPreconds );
+
+ TBool supportedPreconds = MceSip::HasHeaderValueL(
+ aHeaders,
+ SipStrConsts::ESupportedHeader,
+ KMceSipPrecondition );
+
+ TBool reqPreconds = MceSip::HasHeaderValueL(
+ aHeaders,
+ SipStrConsts::ERequireHeader,
+ KMceSipPrecondition );
+
+ if ( localSecPreconds != CMceSipExtensions::ENotSupported &&
+ ( !aIsResponse || type == E1XX || type == E2XX ) &&
+ ActiveBody().Modifier( KMceSecPreconditions ) == KMcePreconditionsE2ESupported &&
+ !supportedPreconds )
+ {
+ MceSip::AddSupportedHeaderL( aHeaders, KMceSipPrecondition );
+ supportedPreconds = ETrue;
+ }
+
+ // Supported: 100rel
+ TInt local100rel = ext.Local( CMceSipExtensions::E100rel );
+ if ( local100rel != CMceSipExtensions::ENotSupported &&
+ ( !aIsResponse || type == E1XX ) )
+ {
+ // INVITE or 1XX to INVITE
+ MceSip::AddSupportedHeaderL( aHeaders, KMceSip100Rel );
+ }
+
+ // Supported: precondition
+ TInt localQosPreconds = ext.Local( CMceSipExtensions::EQosPreconds );
+ if ( localQosPreconds != CMceSipExtensions::ENotSupported &&
+ ( !aIsResponse || type == E1XX || type == E2XX ) &&
+ !supportedPreconds )
+ {
+ // INVITE or 1XX or 2XX to INVITE
+ MceSip::AddSupportedHeaderL( aHeaders, KMceSipPrecondition );
+ }
+
+ // Require: 100rel
+ if ( !aIsResponse && local100rel == CMceSipExtensions::ERequired )
+ {
+ MceSip::AddRequireHeaderL( aHeaders, KMceSip100Rel );
+ }
+
+ // Require: precondition
+ if ( !aIsResponse && localQosPreconds == CMceSipExtensions::ERequired &&
+ !reqPreconds )
+ {
+ MceSip::AddRequireHeaderL( aHeaders, KMceSipPrecondition );
+ reqPreconds = ETrue;
+ }
+
+ // Require: precondition
+ if ( !aIsResponse && localSecPreconds == CMceSipExtensions::ERequired &&
+ !reqPreconds )
+ {
+ MceSip::AddRequireHeaderL( aHeaders, KMceSipPrecondition );
+ }
+
+ if ( aIsResponse && type == E1XX )
+ {
+ // Find out are we sending a 1XX reliably
+ TInt remote100rel = ext.Remote( CMceSipExtensions::E100rel );
+ if ( local100rel == CMceSipExtensions::ERequired ||
+ remote100rel == CMceSipExtensions::ERequired ||
+ aIsBody )
+ {
+ reliable = ETrue;
+ // Add headers for reliable provisional response
+ // Require: 100rel
+ MceSip::AddRequireHeaderL( aHeaders, KMceSip100Rel );
+
+ // RSeq
+ TUint rseqValue;
+ CMceReliableSender& reliableSend = iSession.ReliableSender();
+ CSIPServerTransaction& serverTrans = iSession.Request();
+ rseqValue = reliableSend.Rseq( serverTrans );
+ CSIPRSeqHeader* rseq = new( ELeave ) CSIPRSeqHeader( rseqValue );
+ CleanupStack::PushL( rseq );
+ aHeaders.AppendL( rseq );
+ CleanupStack::Pop( rseq );
+
+ }
+ if ( aIsBody && !reqPreconds &&
+ ActiveBody().Modifier( KMceSecPreconditions ) == KMcePreconditionsE2ESupported )
+ {
+ // Require: precondition
+ MceSip::AddRequireHeaderL( aHeaders, KMceSipPrecondition );
+ ActiveBody().iRemoteSecPreconditionsRequired = ETrue;
+ reqPreconds = ETrue;
+ }
+ }
+ }
+ else if ( !aIsResponse && aTransactionType == SipStrConsts::EPrack )
+ {
+ // RAck header in PRACK request
+ MceSip::AddRAckHeaderL( aHeaders,
+ *iSession.Response().ResponseElements() );
+
+ TBool supportedPreconds = MceSip::HasHeaderValueL(
+ aHeaders,
+ SipStrConsts::ESupportedHeader,
+ KMceSipPrecondition );
+ TBool reqPreconds = MceSip::HasHeaderValueL(
+ aHeaders,
+ SipStrConsts::ERequireHeader,
+ KMceSipPrecondition );
+ TInt localSecPreconds = ext.Local( CMceSipExtensions::ESecPreconds );
+ if ( localSecPreconds != CMceSipExtensions::ENotSupported &&
+ !aIsResponse && !supportedPreconds &&
+ ActiveBody().Modifier( KMceSecPreconditions ) == KMcePreconditionsE2ESupported )
+ {
+ MceSip::AddSupportedHeaderL( aHeaders, KMceSipPrecondition );
+ }
+ if ( localSecPreconds != CMceSipExtensions::ENotSupported &&
+ !aIsResponse && !reqPreconds &&
+ ActiveBody().Modifier( KMceSecPreconditions ) == KMcePreconditionsE2ESupported &&
+ ActiveBody().iRemoteSecPreconditionsRequired )
+ {
+ MceSip::AddRequireHeaderL( aHeaders, KMceSipPrecondition );
+ }
+ }
+ else
+ {
+ //NOP
+ }
+ return reliable;
+ }
+
+//
+// Session timers
+//
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ProcessSessionTimerClientL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ProcessSessionTimerClientL(
+ CSIPClientTransaction& aResponse )
+ {
+ MCESRV_DEBUG("TMceActionSet::ProcessSessionTimerClientL, Entry");
+
+ const TInt KPopCount = 4;
+
+ const CSIPMessageElements& msgElements = aResponse.
+ ResponseElements()->MessageElements();
+ const RPointerArray<CSIPHeaderBase>& sipHeaders = msgElements.UserHeaders();
+
+ RStringF expiresKey =
+ SIPStrings::Pool().OpenFStringL( KMceSipHeaderSessionExpires() );
+ CleanupClosePushL( expiresKey );
+
+ RStringF expiresKey2 =
+ SIPStrings::Pool().OpenFStringL( KMceSipHeaderCompactFormOfSessionExpires() );
+ CleanupClosePushL( expiresKey2 );
+
+ RStringF timerKey = SIPStrings::Pool().OpenFStringL( KMceSipTimer() );
+ CleanupClosePushL( timerKey );
+
+ RStringF minSeKey = SIPStrings::Pool().OpenFStringL( KMceSipHeaderMinSE() );
+ CleanupClosePushL( minSeKey );
+
+ TBool require( EFalse );
+
+ // Require: timer
+ for (int i = 0; i < sipHeaders.Count(); i++)
+ {
+ CSIPHeaderBase* anotherhead = sipHeaders[i];
+ HBufC8* value = anotherhead->ToTextValueLC();
+ if( anotherhead->Name() ==
+ SIPStrings::StringF(SipStrConsts::ERequireHeader )
+ && value
+ && value->Find( KMceSipTimer() ) != KErrNotFound )
+ {
+ require = ETrue;
+ }
+ else if( minSeKey == anotherhead->Name() &&
+ MceSip::ResponseCode ( aResponse ) ==
+ KMceSipSessionIntervalTooSmall )
+ {
+ // 422 Response received including Min-SE field
+ TUint uintValue = MceSip::HeaderValueL( value->Des() );
+ ActiveBody().iMinSE = uintValue;
+ ActiveBody().iTimeout = ActiveBody().iMinSE;
+ CleanupStack::PopAndDestroy( value );
+ break;
+ }
+ CleanupStack::PopAndDestroy( value );
+ }
+ if( require )
+ {
+ // look for Session-Expires field
+ for (int i = 0; i < sipHeaders.Count(); i++)
+ {
+ CSIPHeaderBase* anotherhead = sipHeaders[i];
+ if( ( expiresKey == anotherhead->Name() ||
+ expiresKey2 == anotherhead->Name() ) &&
+ MceSip::ResponseCode ( aResponse ) == KMceSipOK )
+ {
+ // Session-Expires: value;refresher=uac/uas
+ HBufC8* value = anotherhead->ToTextValueLC();
+
+ //Need to have ; i.e. must contain refresher=uac/uas
+ User::LeaveIfError( value->Locate( KMceSipHeaderSeparator ) );
+
+ TUint uintValue = MceSip::HeaderValueL( value->Des() );
+ ActiveBody().iTimeout = uintValue;
+ // find out who will perform the refresh requests
+ if( value->FindF( KMceSipRefresher ) != KErrNotFound &&
+ value->FindF( KMceSipRefresherUAS ) == KErrNotFound )
+ {
+ ActiveBody().iRefresh = ETrue;
+ }
+ else
+ {
+ ActiveBody().iRefresh = EFalse;
+ }
+ CleanupStack::PopAndDestroy( value );
+ iSession.StartSessionTimerL();
+ break;
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy( KPopCount ); // expiresKey, expiresKey2, timerKey, minSeKey
+
+ MCESRV_DEBUG("TMceActionSet::ProcessSessionTimerClientL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ProcessSessionTimerServerL
+// -----------------------------------------------------------------------------
+//
+void
+TMceActionSet::ProcessSessionTimerServerL( CSIPServerTransaction& aRequest )
+ {
+ const CSIPRequestElements* reqElements = aRequest.RequestElements();
+ const CSIPMessageElements* elements = reqElements ?
+ &reqElements->MessageElements() :
+ NULL;
+ if ( elements )
+ {
+ ProcessSessionTimerServerL( *elements );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ProcessSessionTimerServerL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ProcessSessionTimerServerL(
+ const CSIPMessageElements& aElements )
+ {
+ MCESRV_DEBUG("TMceActionSet::ProcessSessionTimerServerL, Entry");
+
+ const TInt KPopCount = 3;
+
+ RStringF expiresKey = SIPStrings::Pool().
+ OpenFStringL( KMceSipHeaderSessionExpires() );
+ CleanupClosePushL( expiresKey );
+
+ RStringF expiresKey2 = SIPStrings::Pool().
+ OpenFStringL( KMceSipHeaderCompactFormOfSessionExpires() );
+ CleanupClosePushL( expiresKey2 );
+
+ RStringF minseKey = SIPStrings::Pool().
+ OpenFStringL( KMceSipHeaderMinSE() );
+ CleanupClosePushL( minseKey );
+
+ CSIPHeaderBase* header = NULL;
+ HBufC8* sessionExpires = NULL;
+
+ // look for Session-Expires: field, if not present then no session timer
+ ActiveBody().iTimeout = 0;
+
+ header = MceSip::FindHeader( aElements, expiresKey );
+ header = header ? header : ( MceSip::FindHeader( aElements, expiresKey2 ) );
+ sessionExpires = header ? header->ToTextValueLC() : NULL;
+
+ if ( sessionExpires )
+ {
+ TUint timeout = MceSip::HeaderValueL( sessionExpires->Des() );
+ ActiveBody().iTimeout = timeout;
+
+ // Find out who will perform the refresh requests. Refresher role is
+ // only updated when UAC has provided refresher-parameter or incoming
+ // request is not a session refresh.
+ if ( iSession.SubState() != CMceSipSession::ERefreshing ||
+ sessionExpires->Find( KMceSipRefresherUAC ) != KErrNotFound ||
+ sessionExpires->Find( KMceSipRefresherUAS ) != KErrNotFound )
+ {
+ if ( sessionExpires->Find( KMceSipRefresherUAC ) != KErrNotFound )
+ {
+ ActiveBody().iRefresh = EFalse;
+ }
+ else
+ {
+ ActiveBody().iRefresh = ETrue;
+ }
+ }
+
+ CleanupStack::PopAndDestroy( sessionExpires );
+ }
+
+ CleanupStack::PopAndDestroy( KPopCount ); // expiresKey, expiresKey2, minseKey
+
+ MCESRV_DEBUG("TMceActionSet::ProcessSessionTimerServerL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ProcessReliableResponseL
+// -----------------------------------------------------------------------------
+//
+TBool TMceActionSet::ProcessReliableResponse(
+ const CSIPResponseElements& aResponseElements )
+ {
+ TUint value = MceSip::RSeq( aResponseElements );
+
+ if ( ( iSession.RSeq() == KErrNone ) ||
+ ( iSession.RSeq() == value - 1 ) )
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::NeedToProcess
+// -----------------------------------------------------------------------------
+//
+TBool TMceActionSet::NeedToProcessL( TMceStateTransitionEvent& aEvent )
+ {
+
+ TBool needToProcess = ETrue;
+
+ CMceSipSession& session = aEvent.Session();
+ CSIPClientTransaction& response = session.Response();
+
+
+ if ( MceSip::ResponseCode( response ) == KMceSipTrying )
+ {
+ needToProcess = EFalse;
+ }
+ else if ( (session.Extensions().LevelL( response, CMceSipExtensions::E100rel )
+ == CMceSipExtensions::ERequired ) )
+ {
+ const CSIPResponseElements& responseElements = *response.ResponseElements();
+
+ TInt rseq = MceSip::RSeq( responseElements );
+
+ if (rseq == KErrNotFound )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ if ( session.RSeq() == KErrNone ||
+ rseq > session.RSeq() )
+
+ {
+ needToProcess = session.Actions().ProcessReliableResponse(
+ *response.ResponseElements());
+ }
+ else
+ {
+ needToProcess = EFalse;
+ }
+ }
+
+ return needToProcess;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::CheckContactIsSecureL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::CheckContactIsSecureL( CSIPTransactionBase& aTransaction )
+ {
+ MCESRV_DEBUG("TMceActionSet::CheckResponseContactIsSecureL, Entry");
+
+ const CSIPMessageElements* msg = MceSip::ToMessageElements( aTransaction );
+ User::LeaveIfError( msg ? KErrNone : KErrArgument );
+
+ TBool contactSec = MceSip::HasSipsUriInContactL( *msg ) ||
+ MceSip::HasTlsInContactL( *msg );
+
+ CMceComSession& body = ActiveBody();
+ body.iSipContactAddrSecure = CMceSession::EControlPathUnsecure;
+
+ if ( iSession.IsProfileContactSecureL( ) &&
+ contactSec )
+ {
+ MCESRV_DEBUG("profile contact and session contact header is secure");
+ body.iSipContactAddrSecure = CMceSession::EControlPathSecure;
+ }
+ MCESRV_DEBUG("TMceActionSet::CheckResponseContactIsSecureL, Exit");
+ }
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::IsExtensionRequest
+// -----------------------------------------------------------------------------
+
+TBool TMceActionSet::IsExtensionRequest ( RStringF method )
+ {
+
+ TBool extensionRequest = ETrue;
+
+ if ( ( method == SIPStrings::StringF( SipStrConsts::ERegister )) ||
+ ( method == SIPStrings::StringF( SipStrConsts::EInvite )) ||
+ ( method == SIPStrings::StringF( SipStrConsts::ECancel)) ||
+ ( method == SIPStrings::StringF( SipStrConsts::EPrack )) ||
+ ( method == SIPStrings::StringF( SipStrConsts::EUpdate )) ||
+ ( method == SIPStrings::StringF( SipStrConsts::EAck )) ||
+ ( method == SIPStrings::StringF( SipStrConsts::EBye )) ||
+ ( method == SIPStrings::StringF( SipStrConsts::ESubscribe )) ||
+ ( method == SIPStrings::StringF( SipStrConsts::ERefer )) ||
+ ( method == SIPStrings::StringF( SipStrConsts::ENotify )))
+
+
+ {
+ extensionRequest = EFalse;
+ }
+
+ return extensionRequest;
+ }
+
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ResetSessionTimerL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::ResetSessionTimerL()
+ {
+ MCESRV_DEBUG("TMceActionSet::ResetSessionTimerL, Entry");
+
+ if ( !ActiveBody().iRefresh )
+ {
+ iSession.StartSessionTimerL();
+ }
+
+ MCESRV_DEBUG("TMceActionSet::ResetSessionTimerL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::StopPendingTimer
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::StopPendingTimer()
+ {
+ MCESRV_DEBUG("TMceActionSet::StopPendingTimer, Entry");
+ CMceTimerManager& timerManager = iSession.Manager().TimerManager();
+ if ( timerManager.IsRunning( iSession.iPendingTimer ) )
+ {
+ timerManager.Stop( iSession.iPendingTimer );
+ }
+ iSession.iPendingTimer = CMceTimerManager::KNoSuchTimer;
+ MCESRV_DEBUG("TMceActionSet::StopPendingTimer, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::AddSessionTimerFieldsServerL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::AddSessionTimerFieldsServerL(
+ RPointerArray<CSIPHeaderBase>& aHeaders )
+ {
+ MCESRV_DEBUG("TMceActionSet::AddSessionTimerFieldsServerL, Entry");
+
+ RStringF timerKey = SIPStrings::Pool().OpenFStringL( KMceSipTimer() );
+ CleanupClosePushL( timerKey );
+ // Supported: timer
+ MCESRV_DEBUG_SVALUE("AddSessionTimerFieldsServerL: adding Supported header",
+ timerKey.DesC() );
+
+ CSIPSupportedHeader* supportedHeader =
+ CSIPSupportedHeader::NewLC( timerKey );
+
+ User::LeaveIfError( aHeaders.Append( supportedHeader ) );
+ CleanupStack::Pop( supportedHeader );
+
+ if( ActiveBody().iTimeout > 0)
+ {
+ // Require: timer
+ MCESRV_DEBUG_SVALUE(
+ "AddSessionTimerFieldsServerL: adding Require header",
+ timerKey.DesC() );
+
+ CSIPRequireHeader* requireHeader =
+ CSIPRequireHeader::NewLC( timerKey );
+
+ User::LeaveIfError( aHeaders.Append( requireHeader ) );
+ CleanupStack::Pop( requireHeader );
+
+ // Session-Expires: XX
+ TUint timeoutInSec = ActiveBody().iTimeout;
+
+ HBufC8* expiresValue = HBufC8::NewLC( KMaxLengthOfSessionExpires );
+ expiresValue->Des().Num( timeoutInSec, EDecimal );
+ expiresValue->Des().Append( KMceSipHeaderSeparator );
+ expiresValue->Des().Append( KMceSipRefresher );
+ expiresValue->Des().Append( KMceSipEqualsTo );
+ if( ActiveBody().iRefresh )
+ {
+ expiresValue->Des().Append( KMceSipRefresherUAS );
+ }
+ else
+ {
+ expiresValue->Des().Append( KMceSipRefresherUAC );
+ }
+
+ MCESRV_DEBUG_SVALUE(
+ "AddSessionTimerFieldsServerL: adding Session-Expires header",
+ *expiresValue );
+
+ CSIPExtensionHeader* sessionExpiresHeader =
+ CSIPExtensionHeader::NewLC( KMceSipHeaderSessionExpires(),
+ *expiresValue );
+
+ User::LeaveIfError( aHeaders.Append( sessionExpiresHeader ) );
+ CleanupStack::Pop( sessionExpiresHeader );
+ CleanupStack::PopAndDestroy( expiresValue );
+ }
+
+ CleanupStack::PopAndDestroy(); // timerKey
+
+ MCESRV_DEBUG("TMceActionSet::AddSessionTimerFieldsServerL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::AddSessionTimerFieldsL
+// -----------------------------------------------------------------------------
+//
+void TMceActionSet::AddSessionTimerFieldsClientL(
+ RPointerArray<CSIPHeaderBase>& aSipHeaders )
+ {
+ MCESRV_DEBUG("TMceActionSet::AddSessionTimerFieldsClientL, Entry");
+
+ // Supported: timer
+ RStringF timerKey = SIPStrings::Pool().OpenFStringL( KMceSipTimer() );
+ CleanupClosePushL( timerKey );
+
+ MCESRV_DEBUG_SVALUE("AddSessionTimerFieldsClientL: adding Supported header",
+ timerKey.DesC() );
+
+ CSIPSupportedHeader* supportedHeader =
+ CSIPSupportedHeader::NewLC( timerKey );
+
+ User::LeaveIfError( aSipHeaders.Append( supportedHeader ) );
+ CleanupStack::Pop( supportedHeader );
+ CleanupStack::PopAndDestroy( &timerKey );
+ if ( ActiveBody().iTimeout > 0 )
+ {
+ // Session-Expires: XX
+ TUint timeoutInSec = ActiveBody().iTimeout;
+ HBufC8* timeout = HBufC8::NewLC( KMaxLengthOfSessionExpires );
+ timeout->Des().Num( timeoutInSec, EDecimal );
+
+ // Add refresher parameter if request is not the initial one.
+ // RFC4028, 7.4.
+ if ( iSession.SubState() == CMceSipSession::ERefreshing )
+ {
+ timeout->Des().Append( KMceSipHeaderSeparator );
+ timeout->Des().Append( KMceSipRefresher );
+ timeout->Des().Append( KMceSipEqualsTo );
+
+ if ( ActiveBody().iRefresh )
+ {
+ timeout->Des().Append( KMceSipRefresherUAC );
+ }
+ else
+ {
+ timeout->Des().Append( KMceSipRefresherUAS );
+ }
+ }
+
+ CSIPExtensionHeader* sessionExpiresHeader =
+ CSIPExtensionHeader::NewLC( KMceSipHeaderSessionExpires(),
+ *timeout );
+ User::LeaveIfError( aSipHeaders.Append( sessionExpiresHeader ) );
+ CleanupStack::Pop( sessionExpiresHeader );
+
+ if ( ActiveBody().iMinSE > 0 )
+ {
+ // if we have received 422, then include this field
+ MCESRV_DEBUG_SVALUE(
+ "AddSessionTimerFieldsClientL: adding Min-SE header",
+ *timeout );
+
+ CSIPExtensionHeader* minSEHeader = CSIPExtensionHeader::NewLC(
+ KMceSipHeaderMinSE(),
+ *timeout );
+
+ User::LeaveIfError( aSipHeaders.Append( minSEHeader ) );
+ CleanupStack::Pop( minSEHeader );
+ }
+
+ CleanupStack::PopAndDestroy( timeout );
+ }
+
+ MCESRV_DEBUG("TMceActionSet::AddSessionTimerFieldsClientL, Exit");
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ReservationNeeded
+// -----------------------------------------------------------------------------
+//
+TBool TMceActionSet::ReservationNeeded()
+ {
+ MCESRV_DEBUG("TMceActionSet::ReservationNeeded, Entry");
+
+ CMceMediaManager& mediaManager = iSession.Manager().MediaManager();
+ TBool reservationNeeded = mediaManager.ReservationNeeded( ActiveBody() );
+
+ MCESRV_DEBUG("TMceActionSet::ReservationNeeded, Exit");
+
+ return reservationNeeded;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceActionSet::ActiveBody
+// -----------------------------------------------------------------------------
+//
+CMceComSession& TMceActionSet::ActiveBody()
+ {
+ return iSession.ActiveBody();
+ }
+
+
+
+
+
+//
+// Event handler
+//
+
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::TMceComEventHandler
+// -----------------------------------------------------------------------------
+//
+TMceComEventHandler::TMceComEventHandler( CMceMediaManager& aMediaManager )
+ : iMediaManager( aMediaManager ),
+ iWriteData( NULL ),
+ iReadData( NULL ),
+ iReturnData( NULL )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::TMceComEventHandler
+// -----------------------------------------------------------------------------
+//
+TMceComEventHandler::TMceComEventHandler( CMceMediaManager& aMediaManager,
+ TPtr8& aWriteData )
+ : iMediaManager( aMediaManager ),
+ iWriteData( &aWriteData ),
+ iReadData( NULL ),
+ iReturnData( NULL )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::TMceComEventHandler
+// -----------------------------------------------------------------------------
+//
+TMceComEventHandler::TMceComEventHandler( CMceMediaManager& aMediaManager,
+ const TDesC8& aReadData )
+ : iMediaManager( aMediaManager ),
+ iWriteData( NULL ),
+ iReadData( &aReadData ),
+ iReturnData( NULL )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::TMceComEventHandler
+// -----------------------------------------------------------------------------
+//
+TMceComEventHandler::TMceComEventHandler( CMceMediaManager& aMediaManager,
+ HBufC8*& aWriteData )
+ : iMediaManager( aMediaManager ),
+ iWriteData( NULL ),
+ iReadData( NULL ),
+ iReturnData( &aWriteData )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::HandleL
+// -----------------------------------------------------------------------------
+//
+TInt TMceComEventHandler::HandleL( CMceComMediaSink& aTarget,
+ TMceComEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( sink ), Entry");
+
+
+ TInt status = KMceEventConsumed;
+ switch( aEvent.Action() )
+ {
+ case EMceItcEnable:
+ {
+ MCESRV_DEBUG("resuming paused sink");
+ iMediaManager.ResumeL( aTarget );
+ aEvent.Id().iState = aTarget.IsEnabled();
+ break;
+ }
+ case EMceItcDisable:
+ {
+ MCESRV_DEBUG("pausing sink");
+ iMediaManager.PauseL( aTarget );
+ aEvent.Id().iState = aTarget.IsEnabled();
+ break;
+ }
+ default:
+ {
+ status = KMceEventNotConsumed;
+ }
+ }
+
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( sink ), Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::HandleL
+// -----------------------------------------------------------------------------
+//
+ TInt TMceComEventHandler::HandleL( CMceComMediaSource& aTarget,
+ TMceComEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( source ), Entry");
+
+ TInt status = KMceEventConsumed;
+ switch( aEvent.Action() )
+ {
+ case EMceItcEnable:
+ {
+ MCESRV_DEBUG("resuming paused source");
+ iMediaManager.ResumeL( aTarget );
+ aEvent.Id().iState = aTarget.IsEnabled();
+ break;
+ }
+ case EMceItcDisable:
+ {
+ MCESRV_DEBUG("pausing source");
+ iMediaManager.PauseL( aTarget );
+ aEvent.Id().iState = aTarget.IsEnabled();
+ break;
+ }
+ case EMceItcIsDtmfActive:
+ case EMceItcStartDtmfTone:
+ case EMceItcStopDtmfTone:
+ case EMceItcSendDtmfTone:
+ case EMceItcCancelSendDtmfToneSequence:
+ {
+ MCESRV_DEBUG("dtmf handling");
+ iMediaManager.DtmfL( aTarget, aEvent );
+ break;
+ }
+ case EMceItcSendDtmfToneSequence:
+ {
+ MCESRV_DEBUG("dtmf handling, sequence");
+ __ASSERT_ALWAYS( MCE_NOT_NULL_PTR( iReadData ) , User::Leave( KErrNotFound ) );
+ iMediaManager.DtmfL( aTarget, aEvent, *iReadData );
+ break;
+ }
+ default:
+ {
+ status = KMceEventNotConsumed;
+ break;
+ }
+ }
+
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( source ), Exit");
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::HandleL
+// -----------------------------------------------------------------------------
+//
+TInt TMceComEventHandler::HandleL( CMceComRtpSink& aTarget,
+ TMceComEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( rtp sink ), Entry");
+
+ TInt status = KMceEventConsumed;
+ switch( aEvent.Action() )
+ {
+ case EMceItcSendSR:
+ {
+ MCESRV_DEBUG("sending SR");
+ iMediaManager.SendRTCPSenderReportL( aTarget );
+ break;
+ }
+ default:
+ {
+ status = KMceEventNotConsumed;
+ }
+ }
+
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( rtp sink ), Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::HandleL
+// -----------------------------------------------------------------------------
+//
+TInt TMceComEventHandler::HandleL( CMceComRtpSource& aTarget,
+ TMceComEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( rtp source ), Entry");
+
+ TInt status = KMceEventConsumed;
+ switch( aEvent.Action() )
+ {
+ case EMceItcEnableInactivityTimer:
+ {
+ MCESRV_DEBUG("enabling inactivity timer");
+ MCE_HANDLER_READ( TMceItcArgTUint32, TUint32, inactivityTimeout );
+ MCESRV_DEBUG_DVALUE("enabling inactivity timer. timeout", inactivityTimeout );
+
+ iMediaManager.StartInactivityTimerL( aTarget, inactivityTimeout );
+ break;
+ }
+ case EMceItcDisableInactivityTimer:
+ {
+ MCESRV_DEBUG("disabling inactivity timer");
+ iMediaManager.StopInactivityTimerL( aTarget );
+ break;
+ }
+ case EMceItcSendRR:
+ {
+ MCESRV_DEBUG("sending RR");
+ iMediaManager.SendRTCPReceiverReportL( aTarget );
+ break;
+ }
+ default:
+ {
+ status = KMceEventNotConsumed;
+ }
+ }
+
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( rtp source ), Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::HandleL
+// -----------------------------------------------------------------------------
+//
+TInt TMceComEventHandler::HandleL( CMceComSpeakerSink& aTarget,
+ TMceComEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( speaker ), Entry");
+
+ TInt status = KMceEventConsumed;
+ switch( aEvent.Action() )
+ {
+ case EMceItcVolume:
+ {
+ TInt volume = KErrNotFound;
+ iMediaManager.GetVolumeL( aTarget, volume );
+ MCESRV_DEBUG_DVALUE("getting volume. volume", volume );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, volume );
+ break;
+ }
+ case EMceItcAudioRouting:
+ {
+ TInt routing = KErrNotFound;
+ iMediaManager.GetAudioRoutingL( aTarget, routing );
+ MCESRV_DEBUG_DVALUE("getting routing. value", routing );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, routing );
+ break;
+ }
+ case EMceItcSetVolume:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, volume );
+ MCESRV_DEBUG_DVALUE("setting volume. new volume", volume );
+ iMediaManager.SetVolumeL( aTarget, volume );
+ break;
+ }
+ case EMceItcSetAudioRouting:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, routing );
+ MCESRV_DEBUG_DVALUE("setting routing. new value", routing );
+ iMediaManager.SetAudioRoutingL( aTarget, routing );
+ break;
+ }
+ default:
+ {
+ status = KMceEventNotConsumed;
+ }
+ }
+
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( speaker ), Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::HandleL
+// -----------------------------------------------------------------------------
+//
+TInt TMceComEventHandler::HandleL( CMceComDisplaySink& aTarget,
+ TMceComEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( display ), Entry");
+
+ TInt status = KMceEventConsumed;
+ switch( aEvent.Action() )
+ {
+ case EMceItcDisplayRect:
+ {
+ TRect displayRect;
+ iMediaManager.GetDisplayRectL( aTarget, displayRect );
+ MCESRV_DEBUG("getting display rect");
+ MCE_HANDLER_WRITE( TMceItcArgTRect, displayRect );
+ break;
+ }
+ case EMceItcDisplayPriority:
+ {
+ TInt displayPriority = KErrNotFound;
+ iMediaManager.GetDisplayPriorityL( aTarget, displayPriority );
+ MCESRV_DEBUG_DVALUE("getting display priority. value", displayPriority );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, displayPriority );
+ break;
+ }
+ case EMceItcDisplayRotation:
+ {
+ TInt displayRotation = KErrNotFound;
+ iMediaManager.GetDisplayRotationL( aTarget, displayRotation );
+ MCESRV_DEBUG_DVALUE("getting display rotation. value", displayRotation );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, displayRotation );
+ break;
+ }
+ case EMceItcSetDisplayRect:
+ {
+ MCE_HANDLER_READ( TMceItcArgTRect, TRect, rect );
+ iMediaManager.SetDisplayRectL( aTarget, rect );
+ MCESRV_DEBUG("setting display rect");
+ break;
+ }
+ case EMceItcSetDisplayRotation:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, displayRotation );
+ iMediaManager.SetDisplayRotationL( aTarget, displayRotation );
+ MCESRV_DEBUG("setting display rotation");
+ break;
+ }
+ case EMceItcSetDisplayPriority:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, displayPriority );
+ MCESRV_DEBUG_DVALUE("setting display priority. new value", displayPriority );
+ iMediaManager.SetDisplayPriorityL( aTarget, displayPriority );
+ break;
+ }
+ case EMceItcSetDisplayIndex:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, displayIndex );
+ MCESRV_DEBUG_DVALUE("setting display index. new value", displayIndex );
+ iMediaManager.SetDisplayIndexL( aTarget, displayIndex );
+ break;
+ }
+ default:
+ {
+ status = KMceEventNotConsumed;
+ }
+ }
+
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( display ), Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::HandleL
+// -----------------------------------------------------------------------------
+//
+TInt TMceComEventHandler::HandleL( CMceComMicSource& aTarget,
+ TMceComEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( mic ), Entry");
+
+ TInt status = KMceEventConsumed;
+ switch( aEvent.Action() )
+ {
+ case EMceItcGain:
+ {
+ TInt gain = KErrNotFound;
+ iMediaManager.GetGainL( aTarget, gain );
+ MCESRV_DEBUG_DVALUE("getting gain. gain", gain );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, gain );
+ break;
+ }
+ case EMceItcSetGain:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, gain );
+ iMediaManager.SetGainL( aTarget, gain );
+ break;
+ }
+ default:
+ {
+ status = KMceEventNotConsumed;
+ }
+ }
+
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( mic ), Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::HandleL
+// -----------------------------------------------------------------------------
+//
+TInt TMceComEventHandler::HandleL( CMceComCameraSource& aTarget,
+ TMceComEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( camera ), Entry");
+
+ TInt status = KMceEventConsumed;
+ switch( aEvent.Action() )
+ {
+ case EMceItcZoomFactor:
+ {
+ TInt zoomFactor = KErrNotFound;
+ iMediaManager.GetZoomFactorL( aTarget, zoomFactor );
+ MCESRV_DEBUG_DVALUE("getting zoom factor. value", zoomFactor );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, zoomFactor );
+ break;
+ }
+ case EMceItcDigitalZoomFactor:
+ {
+ TInt digitalZoomFactor = KErrNotFound;
+ iMediaManager.GetDigitalZoomFactorL( aTarget, digitalZoomFactor );
+ MCESRV_DEBUG_DVALUE("getting digital zoom factor. value", digitalZoomFactor );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, digitalZoomFactor );
+ break;
+ }
+ case EMceItcContrast:
+ {
+ TInt contrast = KErrNotFound;
+ iMediaManager.GetContrastL( aTarget, contrast );
+ MCESRV_DEBUG_DVALUE("getting contrast. value", contrast );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, contrast );
+ break;
+ }
+ case EMceItcBrightness:
+ {
+ TInt brightness = KErrNotFound;
+ iMediaManager.GetBrightnessL( aTarget, brightness );
+ MCESRV_DEBUG_DVALUE("getting brightness. value", brightness );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, brightness );
+ break;
+ }
+ case EMceItcExposure:
+ {
+ TInt exposure = KErrNotFound;
+ iMediaManager.GetExposureL( aTarget, exposure );
+ MCESRV_DEBUG_DVALUE("getting exposure. value", exposure );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, exposure );
+ break;
+ }
+ case EMceItcWhiteBalance:
+ {
+ TInt whiteBalance = KErrNotFound;
+ iMediaManager.GetWhiteBalanceL( aTarget, whiteBalance );
+ MCESRV_DEBUG_DVALUE("getting whiteBalance. value", whiteBalance );
+ MCE_HANDLER_WRITE( TMceItcArgTInt, whiteBalance );
+ break;
+ }
+ case EMceItcSetCameraIndex:
+ {
+ MCE_HANDLER_READ_DATA( TMceItcArgTCameraInfo, TMceCameraInfo, cameraInfo, iWriteData );
+ MCESRV_DEBUG_DVALUE("setting camera index. new camera index", cameraInfo.iIndex );
+ iMediaManager.SetCameraIndexL( aTarget, cameraInfo.iIndex, cameraInfo.iInfo );
+ MCE_HANDLER_WRITE( TMceItcArgTCameraInfo, cameraInfo );
+ break;
+ }
+ case EMceItcSetZoomFactor:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, zoomFactor );
+ MCESRV_DEBUG_DVALUE("setting zoom factor. new zoom factor", zoomFactor );
+ iMediaManager.SetZoomFactorL( aTarget, zoomFactor );
+ break;
+ }
+ case EMceItcSetDigitalZoomFactor:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, digitalZoomFactor );
+ MCESRV_DEBUG_DVALUE("setting digital zoom factor. new digital zoom factor", digitalZoomFactor );
+ iMediaManager.SetDigitalZoomFactorL( aTarget, digitalZoomFactor );
+ break;
+ }
+ case EMceItcSetContrast:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, contrast );
+ MCESRV_DEBUG_DVALUE("setting contrast. new contrast", contrast );
+ iMediaManager.SetContrastL( aTarget, contrast );
+ break;
+ }
+ case EMceItcSetBrightness:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, brightness );
+ MCESRV_DEBUG_DVALUE("setting brightness. new brightness", brightness );
+ iMediaManager.SetBrightnessL( aTarget, brightness );
+ break;
+ }
+ case EMceItcSetExposure:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, exposure );
+ MCESRV_DEBUG_DVALUE("setting exposure. new exposure", exposure );
+ iMediaManager.SetExposureL( aTarget, exposure );
+ break;
+ }
+ case EMceItcSetWhiteBalance:
+ {
+ MCE_HANDLER_READ( TMceItcArgTInt, TInt, whiteBalance );
+ MCESRV_DEBUG_DVALUE("setting white balance. new white balance", whiteBalance );
+ iMediaManager.SetWhiteBalanceL( aTarget, whiteBalance );
+ break;
+ }
+ default:
+ {
+ status = KMceEventNotConsumed;
+ break;
+ }
+ }
+
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( camera ), Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::HandleL
+// -----------------------------------------------------------------------------
+//
+TInt TMceComEventHandler::HandleL( CMceComFileSource& aTarget,
+ TMceComEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( file source ), Entry");
+
+ TInt status = KMceEventConsumed;
+ switch( aEvent.Action() )
+ {
+ case EMceItcFileInfo:
+ {
+ TMceFileInfo fileInfo;
+ iMediaManager.GetFileInfoL( aTarget, fileInfo );
+ MCE_HANDLER_WRITE( TMceItcArgTFileInfo, fileInfo );
+ break;
+ }
+ case EMceItcFilePosition:
+ {
+ TTimeIntervalMicroSeconds filePosition;
+ iMediaManager.GetFilePositionL( aTarget, filePosition );
+ MCE_HANDLER_WRITE( TMceItcArgTime, filePosition );
+ break;
+ }
+ case EMceItcSetFilePosition:
+ {
+ MCE_HANDLER_READ( TMceItcArgTime, TTimeIntervalMicroSeconds, filePosition );
+ iMediaManager.SetFilePositionL( aTarget, filePosition );
+ break;
+ }
+ case EMceItcSetFileInfo:
+ {
+ MCE_HANDLER_READ( TMceItcArgTFileInfo, TMceFileInfo, fileInfo );
+ iMediaManager.SetFileInfoL( aTarget, fileInfo );
+ break;
+ }
+ case EMceItcSetFastForward:
+ {
+ TBool onoff = static_cast<TBool>( aEvent.Id().iState );
+ iMediaManager.FastForwardL( aTarget, onoff );
+ aEvent.Id().iState = onoff;
+ break;
+ }
+ case EMceItcSetFastRewind:
+ {
+ TBool onoff = static_cast<TBool>( aEvent.Id().iState );
+ iMediaManager.FastRewindL( aTarget, onoff );
+ aEvent.Id().iState = onoff;
+ break;
+ }
+ default:
+ {
+ status = KMceEventNotConsumed;
+ }
+ }
+
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( file source ), Exit");
+
+ return status;
+ }
+
+// -----------------------------------------------------------------------------
+// TMceComEventHandler::HandleL
+// -----------------------------------------------------------------------------
+//
+TInt TMceComEventHandler::HandleL( CMceComFileSink& /*aTarget*/,
+ TMceComEvent& aEvent )
+ {
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( file sink ), Entry");
+
+ TInt status = KMceEventConsumed;
+ switch( aEvent.Action() )
+ {
+ default:
+ {
+ status = KMceEventNotConsumed;
+ }
+ }
+
+ MCESRV_DEBUG("TMceComEventHandler::HandleL( file sink ), Exit");
+
+ return status;
+ }
+
+
+
+
+
+
+// End of File