--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommsengine/tsrc/ututils/src/MCETestHelper.cpp Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,1757 @@
+/*
+* 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 "MCETestHelper.h"
+#include "mcesipsession.h"
+#include "mcesipevent.h"
+#include "mcecssession.h"
+#include "mcecssessionimplementation.h"
+#include "mceservercore.h"
+#include "SIPExpiresHeader.h"
+#include "SIPEventHeader.h"
+#include "mcereliablesender.h"
+#include "sipsupportedheader.h"
+#include "siprackheader.h"
+#include <siprequireheader.h>
+#include <siprseqheader.h>
+#include <sipcontactheader.h>
+
+_LIT8(KFmtAttribute,"a=fmtp:TBCP format parameters\r\n");
+_LIT8(KFmtAttribute2,"a=fmtp:TestPlugIn format parameters\r\n");
+
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientCreateSessionL()
+// -----------------------------------------------------------------------------
+//
+CMceSipSession* MCETestHelper::ClientCreateSessionL( CMceCsSession* aClient,
+ const TDesC8& aParam1,
+ const TDesC8& aParam2 )
+ {
+
+ TMceIds& ids = CMCETls::Storage()->iIds;
+
+ CDesC8ArrayFlat* params = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( params );
+ params->AppendL( aParam1 );
+ params->AppendL( aParam2 );
+
+ CMceMsgTextArray* msgParams = new (ELeave) CMceMsgTextArray( *params );
+ CleanupStack::PushL( msgParams );
+ CMCETls::Storage()->StoreL( ids, *msgParams );
+ CleanupStack::PopAndDestroy( msgParams );
+ CleanupStack::PopAndDestroy( params );
+
+ TInt count = aClient->Implementation().SubSessions().Count();
+
+ aClient->CreateSubSessionL(ids, RMessage2() );
+
+ return static_cast<CMceSipSession*>(aClient->Implementation().SubSessions()[ count ]);
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ManagerReadyToReceiveL()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::ManagerReadyToReceiveL( CMceCsSession* aClient )
+ {
+ TMceIds& ids = CMCETls::Storage()->iManagerIds;
+
+ CMCETls::Storage()->iIdsIndex = 1;
+ aClient->ClientReadyToReceiveL( ids, RMessage2() );
+ CMCETls::Storage()->iIdsIndex = 0;
+ }
+
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientReadyToReceiveL()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::ClientReadyToReceiveL( CMceSipSession* aSession )
+ {
+ TMceIds& ids = CMCETls::Storage()->iIds;
+
+ delete CMCETls::Storage()->iContextServer;
+ delete CMCETls::Storage()->iContentServer;
+ CMCETls::Storage()->iContextServer = NULL;
+ CMCETls::Storage()->iContentServer = NULL;
+ CMCETls::Storage()->iMessageSizes = TMceMessageBufSizes();
+
+ //client ready to receive
+ ids.iSessionID = reinterpret_cast<TUint32>( aSession );
+ aSession->ServiceL( ids, EMceItcClientReadyToReceive, RMessage2() );
+
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientReceiveLC()
+// -----------------------------------------------------------------------------
+//
+CMceMsgBase* MCETestHelper::ClientReceiveLC( CMceSipSession* aSession, TMceIds& aIds )
+ {
+ CMceMsgBase* message = NULL;
+ TMceIds& ids = CMCETls::Storage()->iIds;
+ aIds = ids;
+
+ if ( CMCETls::Storage()->iMessageSizes.iContextBufSize > 0 )
+ {
+
+ //client receive
+ aSession->ServiceL( ids, EMceItcReceive, RMessage2() );
+
+ //client code
+ RDesReadStream readStream( *CMCETls::Storage()->iContextServer );
+ CleanupClosePushL( readStream );
+
+ message = TMceComFactory().CreateL( (TMceItcDataType)ids.iMsgType,
+ readStream );
+ CleanupStack::PopAndDestroy(); // readStream
+
+ }
+
+ ClientReadyToReceiveL( aSession );
+
+ if ( message )
+ {
+ CleanupStack::PushL( message );
+
+ message->PushL();
+ }
+
+ return message;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientEstablishL()
+// -----------------------------------------------------------------------------
+//
+CMceComSession* MCETestHelper::ClientEstablishL( CMceSipSession* aSession,
+ const TDesC8& aHeader,
+ const TDesC8& aContentType,
+ const TDesC8& aContent,
+ TBool aRequire100rel )
+ {
+ TMceIds& ids = CMCETls::Storage()->iIds;
+
+ CMceComSession* clientSession = ComSessionL( ids.iSessionID, aRequire100rel );
+ CleanupStack::PushL( clientSession );
+
+ if ( clientSession->iSIPHeaders->MdcaCount() > 0 && aHeader.Length() == 0 )
+ {
+ clientSession->iSIPHeaders->Delete( 0, clientSession->iSIPHeaders->MdcaCount() );
+ }
+
+ if ( aHeader.Length() > 0 )
+ {
+ clientSession->iSIPHeaders->AppendL( aHeader );
+ }
+
+ MCE_TH_SET( clientSession->iSIPContentType, NULL );
+ clientSession->iSIPContentType = aContentType.AllocL();
+
+ CMceMsgObject<CMceComSession>* clientSessionMsg =
+ new (ELeave) CMceMsgObject<CMceComSession>( *clientSession, EMceItcMsgTypeSession );
+ CleanupStack::PushL( clientSessionMsg );
+
+ HBufC8* content = aContent.AllocLC();
+
+ CMCETls::Storage()->StoreL( ids, *clientSessionMsg, content );
+ CleanupStack::Pop( content );
+
+
+ CleanupStack::PopAndDestroy( clientSessionMsg );
+
+ //establish
+ aSession->ServiceL( ids, EMceItcEstablishSession, RMessage2() );
+ CMCETls* storage = CMCETls::Storage();
+ MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+
+ CleanupStack::Pop( clientSession );
+
+ return clientSession;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientTerminateL()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::ClientTerminateL( CMceSipSession* aSession,
+ const TDesC8& aHeader,
+ const TDesC8& aContentType,
+ const TDesC8& aContent )
+ {
+ TMceIds& ids = CMCETls::Storage()->iIds;
+ ids.iSessionID = aSession->Body()->Id();
+
+
+ if ( aHeader.Length() == 0 && aContentType.Length() == 0 && aContent.Length() == 0 )
+ {
+ ids.iMsgType = KMceNotAssigned;
+ aSession->ServiceL( ids, EMceItcTerminateSession, RMessage2() );
+ return;
+ }
+
+ HBufC8* content = aContent.AllocLC();
+ HBufC8* contentType = aContentType.AllocLC();
+ CDesC8Array* headers = NULL;
+ if ( aHeader.Length() > 0 )
+ {
+ headers = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( headers );
+ headers->AppendL( aHeader );
+ }
+
+ CMceMsgSIPData* sipData = new (ELeave) CMceMsgSIPData( SipStrConsts::EBye,
+ *headers, *contentType );
+
+ CleanupStack::PushL( sipData );
+
+ CMCETls::Storage()->StoreL( ids, *sipData, content );
+ CleanupStack::PopAndDestroy( sipData );
+
+ if ( headers )
+ CleanupStack::PopAndDestroy( headers );
+
+ CleanupStack::PopAndDestroy( contentType );
+ CleanupStack::Pop( content );
+
+ //reject session
+ aSession->ServiceL( ids, EMceItcTerminateSession, RMessage2() );
+ CMCETls* storage = CMCETls::Storage();
+ MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientAcceptL()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::ClientAcceptL( CMceSipSession* aSession,
+ const TDesC8& aReason,
+ TInt aReasonCode )
+ {
+ TMceIds& ids = CMCETls::Storage()->iIds;
+ ids.iSessionID = aSession->Body()->Id();
+
+ CDesC8Array* headers = NULL;
+ HBufC8* reason = NULL;
+ HBufC8* ctype = NULL;
+
+ if ( aReasonCode == -1 )
+ {
+ ids.iMsgType = KMceNotAssigned;
+ aSession->ServiceL( ids, EMceItcAcceptSession, RMessage2() );
+ CMCETls* storage = CMCETls::Storage();
+ MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+ return;
+ }
+
+ if ( aReasonCode == 0 )
+ {
+ aReasonCode = KMceSipOK;
+ }
+
+ if ( aReason.Length() > 0 )
+ {
+ reason = aReason.AllocLC();
+ }
+ else
+ {
+ reason = SIPStrings::StringF( SipStrConsts::EPhraseOk ).DesC().AllocLC();
+ }
+
+ CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply( *reason, (TUint32)aReasonCode, *headers, *ctype );
+ CleanupStack::PushL( reply );
+
+ CMCETls::Storage()->StoreL( ids, *reply, NULL );
+ CleanupStack::PopAndDestroy( reply );
+ CleanupStack::PopAndDestroy( reason );
+
+ aSession->ServiceL( ids, EMceItcAcceptSession, RMessage2() );
+ CMCETls* storage = CMCETls::Storage();
+ MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientDeclineL()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::ClientDeclineL( CMceSipSession* aSession,
+ const TDesC8& aHeader,
+ const TDesC8& aContent,
+ const TDesC8& aContentType,
+ const TDesC8& aReason,
+ TInt aReasonCode )
+ {
+ TMceIds& ids = CMCETls::Storage()->iIds;
+ ids.iSessionID = aSession->Body()->Id();
+
+ if ( aReasonCode == -1 )
+ {
+ ids.iMsgType = KMceNotAssigned;
+ aSession->ServiceL( ids, EMceItcRejectSession, RMessage2() );
+ return;
+ }
+
+ if ( aReasonCode == 0 )
+ {
+ aReasonCode = KMceSipDecline;
+ }
+
+
+ HBufC8* content = NULL;
+ HBufC8* reason = NULL;
+ HBufC8* ctype = NULL;
+ CDesC8Array* headers = NULL;
+
+ if ( aContent.Length() > 0 )
+ {
+ content = aContent.AllocLC();
+ }
+ if ( aReason.Length() > 0 )
+ {
+ reason = aReason.AllocLC();
+ }
+ else
+ {
+ reason = SIPStrings::StringF( SipStrConsts::EPhraseDecline ).DesC().AllocLC();
+ }
+
+ if ( aHeader.Length() > 0 )
+ {
+ headers = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( headers );
+ headers->AppendL( aHeader );
+ }
+
+ if ( aContentType.Length() > 0 )
+ {
+ ctype = aContentType.AllocLC();
+ }
+
+ CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply( *reason, (TUint32)aReasonCode, *headers, *ctype );
+ CleanupStack::PushL( reply );
+
+ CMCETls::Storage()->StoreL( ids, *reply, content );
+ CleanupStack::PopAndDestroy( reply );
+ if ( ctype )
+ CleanupStack::PopAndDestroy( ctype );
+
+ if ( headers )
+ CleanupStack::PopAndDestroy( headers );
+
+ if ( reason )
+ CleanupStack::PopAndDestroy( reason );
+
+ if ( content )
+ CleanupStack::Pop( content );
+
+ //reject session
+ aSession->ServiceL( ids, EMceItcRejectSession, RMessage2() );
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientRingL()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::ClientRingL( CMceSipSession* aSession,
+ const TDesC8& aHeader,
+ const TDesC8& aContent,
+ const TDesC8& aContentType )
+ {
+ TMceIds& ids = CMCETls::Storage()->iIds;
+ ids.iSessionID = aSession->Body()->Id();
+
+
+ if ( aHeader.Length() == 0 && aContentType.Length() == 0 && aContent.Length() == 0 )
+ {
+ ids.iMsgType = KMceNotAssigned;
+ aSession->ServiceL( ids, EMceItcRing, RMessage2() );
+ CMCETls* storage = CMCETls::Storage();
+ MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+ return;
+ }
+
+ TUint32 reasonCode = KMceSipRinging;
+ HBufC8* content = NULL;
+ HBufC8* reason = NULL;
+ HBufC8* ctype = NULL;
+ CDesC8Array* headers = NULL;
+
+ content = aContent.AllocLC();
+ reason = SIPStrings::StringF( SipStrConsts::EPhraseRinging ).DesC().AllocLC();
+
+ if ( aHeader.Length() > 0 )
+ {
+ headers = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( headers );
+ headers->AppendL( aHeader );
+ }
+
+ ctype = aContentType.AllocLC();
+
+ CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply( *reason, reasonCode, *headers, *ctype );
+ CleanupStack::PushL( reply );
+
+ CMCETls::Storage()->StoreL( ids, *reply, content );
+ CleanupStack::PopAndDestroy( reply );
+ CleanupStack::PopAndDestroy( ctype );
+
+ if ( headers )
+ CleanupStack::PopAndDestroy( headers );
+
+ CleanupStack::PopAndDestroy( reason );
+ CleanupStack::Pop( content );
+
+ aSession->ServiceL( ids, EMceItcRing, RMessage2() );
+ CMCETls* storage = CMCETls::Storage();
+ MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientCancelL()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::ClientCancelL( CMceSipSession* aSession )
+ {
+ TMceIds& ids = CMCETls::Storage()->iIds;
+ ids.iSessionID = aSession->Body()->Id();
+ ids.iMsgType = KMceNotAssigned;
+ aSession->ServiceL( ids, EMceItcCancel, RMessage2() );
+ CMCETls* storage = CMCETls::Storage();
+ MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientIncomingSessionL()
+// -----------------------------------------------------------------------------
+//
+CMceSipSession* MCETestHelper::ClientIncomingSessionL( CMceCsSession* aClient,
+ TBool aInvalid,
+ TBool aSupported100rel )
+ {
+ CMceSipSession* session = NULL;
+ TUint32 iapId = 1;
+
+ //invite
+ CSIPServerTransaction* invite = NULL;
+
+ if ( !aInvalid )
+ {
+ RPointerArray<CSIPHeaderBase> hdrs;
+ CSIPHeaderBase::PushLC( &hdrs );
+
+ if ( aSupported100rel )
+ {
+ RStringF supp100rel = SIPStrings::Pool().OpenFStringL( KMceSip100Rel );
+ CleanupClosePushL( supp100rel );
+ CSIPSupportedHeader* supported =
+ CSIPSupportedHeader::NewLC( supp100rel );
+ hdrs.AppendL( supported );
+ CleanupStack::Pop( supported );
+ CleanupStack::PopAndDestroy(); // supp100rel
+ }
+ invite = ServerTransactionL( SipStrConsts::EInvite, hdrs, ETrue );
+ CleanupStack::Pop( &hdrs );
+ }
+ else
+ {
+ invite = ServerTransactionBadSDPL( SipStrConsts::EInvite );
+ }
+
+ aClient->ServerCore().Manager().IncomingRequest( iapId, invite );
+ CMCETls* storage = CMCETls::Storage();
+ MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+ storage->ExecuteCallback();
+ MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+
+ TInt count = aClient->Implementation().SubSessions().Count();
+ if ( count > 0 )
+ {
+ session = static_cast<CMceSipSession*>(aClient->Implementation().SubSessions()[ count - 1 ]);
+ }
+ if ( session )
+ {
+
+ TMceIds ids = CMCETls::Storage()->iManagerIds;
+ //receive
+ aClient->ReceiveL( ids , RMessage2() );
+ //client code
+ RDesReadStream readStream( *CMCETls::Storage()->iContextServer );
+ CleanupClosePushL( readStream );
+
+ CMceMsgObject<CMceComSession>* message = static_cast<CMceMsgObject<CMceComSession>*>
+ (TMceComFactory().CreateL( (TMceItcDataType)ids.iMsgType,
+ readStream ) );
+ CleanupStack::PopAndDestroy(); // readStream
+
+ CleanupStack::PushL( message );
+ message->PushL();
+ CleanupStack::PopAndDestroy( message );
+
+ CMCETls::Storage()->iIds = TMceIds();
+ CMCETls::Storage()->iIds.iAppUID = CMCETls::Storage()->iManagerIds.iAppUID;
+ CMCETls::Storage()->iIds.iManagerType = CMCETls::Storage()->iManagerIds.iManagerType;
+ CMCETls::Storage()->iIds.iDialogType = CMCETls::Storage()->iManagerIds.iDialogType;
+ CMCETls::Storage()->iIds.iDialogID = CMCETls::Storage()->iManagerIds.iDialogID;
+ CMCETls::Storage()->iIds.iProfileID = CMCETls::Storage()->iManagerIds.iProfileID;
+
+ ManagerReadyToReceiveL( aClient );
+ }
+
+ return session;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientIncomingEventL()
+// -----------------------------------------------------------------------------
+//
+CMceSipEvent* MCETestHelper::ClientIncomingEventL( CMceCsSession* aClient,
+ TInt aMethod )
+ {
+ CMceSipEvent* event = NULL;
+ TUint32 iapId = 1;
+ TUint32 profileId = 1;
+
+ RPointerArray<CSIPHeaderBase> sipHdrs;
+ CSIPHeaderBase::PushLC( &sipHdrs );
+
+ if ( aMethod == SipStrConsts::ESubscribe )
+ {
+ CSIPExpiresHeader* ex = new( ELeave ) CSIPExpiresHeader( 180 );
+ CleanupStack::PushL( ex );
+ sipHdrs.AppendL( ex );
+ CleanupStack::Pop( ex );
+
+ CSIPEventHeader* eve = CSIPEventHeader::DecodeL( KEvent );
+ CleanupStack::PushL( eve );
+ sipHdrs.AppendL( eve );
+ CleanupStack::Pop( eve );
+ }
+
+ CSIPServerTransaction* sta = NULL;
+
+
+ sta = ServerTransactionL( aMethod, sipHdrs, ETrue );
+ CleanupStack::Pop( &sipHdrs );
+ CMceSipManager& manager = aClient->ServerCore().Manager();
+ CSIPProfile& profile = manager.ProfileL( profileId );
+
+ CMceSipConnection& connection = manager.ConnectionL( profile );
+
+ manager.CreateSubSessionL( sta, *aClient, connection );
+
+ TInt count = aClient->Implementation().SubSessions().Count();
+ if ( count > 0 )
+ {
+ event = static_cast<CMceSipEvent*>(aClient->Implementation().SubSessions()[ count - 1 ]);
+ }
+
+ return event;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientUpdateSessionL()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::ClientUpdateSessionL( CMceSipSession* aSession,
+ CMceComSession& aUpdate,
+ TUint32 aTimeout,
+ const TDesC8& aHeader,
+ const TDesC8& aContentType,
+ const TDesC8& aContent,
+ const TDesC8& aContentHeader )
+ {
+ TMceIds& ids = CMCETls::Storage()->iIds;
+
+ aUpdate.iTimeout = aTimeout;
+ MCE_DELETE( aUpdate.iSIPHeaders );
+ MCE_DELETE( aUpdate.iSIPContentType );
+ MCE_DELETE( aUpdate.iSIPContentHeaders );
+
+ if ( aHeader.Length() > 0 )
+ {
+ aUpdate.iSIPHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
+ aUpdate.iSIPHeaders->AppendL( aHeader );
+ }
+ if ( aContentHeader.Length() > 0 )
+ {
+ aUpdate.iSIPContentHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
+ aUpdate.iSIPContentHeaders->AppendL( aContentHeader );
+ }
+ aUpdate.iSIPContentType = aContentType.AllocL();
+
+
+ CMceMsgObject<CMceComSession>* clientSessionMsg =
+ new (ELeave) CMceMsgObject<CMceComSession>( aUpdate, EMceItcMsgTypeSession );
+ CleanupStack::PushL( clientSessionMsg );
+
+ HBufC8* content = aContent.AllocLC();
+
+ ids.iSessionID = aSession->Body()->Id();
+ CMCETls::Storage()->StoreL( ids, *clientSessionMsg, content );
+
+ CleanupStack::Pop( content );
+ CleanupStack::PopAndDestroy( clientSessionMsg );
+
+ //update
+ aSession->ServiceL( ids, EMceItcUpdate, RMessage2() );
+
+ CMCETls* storage = CMCETls::Storage();
+ MCE_CHECK_MEMORY_LEAVE( storage->iMediaManagerUpdateStatus >= KErrNone &&
+ storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientGetSessionL()
+// -----------------------------------------------------------------------------
+//
+CMceComSession* MCETestHelper::ClientGetSessionL( CMceSipSession* aSession )
+ {
+ TMceIds& ids = CMCETls::Storage()->iIds;
+ ids.iSessionID = aSession->Body()->Id();
+ ids.iMsgType = KMceNotAssigned;
+ aSession->ServiceL( ids, EMceItcGetSession, RMessage2() );
+
+ CMceComSession* session = NULL;
+ CMceMsgObject<CMceComSession>* clientSessionMsg =
+ new (ELeave) CMceMsgObject<CMceComSession>();
+ CleanupStack::PushL( clientSessionMsg );
+
+ clientSessionMsg->DecodeL( *CMCETls::Storage()->iContextServer );
+ session = clientSessionMsg->Object();
+
+ CleanupStack::PopAndDestroy( clientSessionMsg );
+
+ return session;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::MediaManagerCallBack()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::MediaManagerCallBack( CMceSipSession* aSession,
+ TMceMediaEventCode aEvent,
+ TInt aError )
+ {
+ switch ( aEvent )
+ {
+ case EMceMediaUpdated:
+ {
+ aSession->Updated( *aSession->Body() );
+ MCE_CHECK_MEMORY_LEAVE( CMCETls::Storage()->iCompletionCode == KErrNoMemory )
+ break;
+ }
+ case EMceMediaSessionStopped:
+ {
+ aSession->SessionClosed( *aSession->Body() );
+ MCE_CHECK_MEMORY_LEAVE( CMCETls::Storage()->iCompletionCode == KErrNoMemory )
+ break;
+ }
+ case EMceMediaError:
+ {
+ TMceMccComEvent event( KMccStreamError );
+ event.iError = aError;
+ aSession->MediaError( event );
+ MCE_CHECK_MEMORY_LEAVE( CMCETls::Storage()->iCompletionCode == KErrNoMemory )
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::MediaManagerSinkCallBack()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::MediaManagerSinkCallBack( CMceSipSession* aSession,
+ TMceItcFunctions aEventTo,
+ TInt aStream,
+ TInt aSink )
+ {
+ switch( aEventTo )
+ {
+ case EMceItcDisable:
+ {
+ TMceMccComEvent event( KMccStreamPaused );
+ SinkEvent( event, aSession, aStream, aSink );
+ aSession->EventReceived( event );
+ break;
+ }
+ case EMceItcEnable:
+ {
+ TMceMccComEvent event( KMccStreamResumed );
+ SinkEvent( event, aSession, aStream, aSink );
+ aSession->EventReceived( event );
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::MediaManagerSourceCallBack()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::MediaManagerSourceCallBack( CMceSipSession* aSession,
+ TMceItcFunctions aEventTo,
+ TInt aStream )
+ {
+ switch( aEventTo )
+ {
+ case EMceItcDisable:
+ {
+ TMceMccComEvent event( KMccStreamPaused );
+ SourceEvent( event, aSession, aStream );
+ aSession->EventReceived( event );
+ break;
+ }
+ case EMceItcEnable:
+ {
+ TMceMccComEvent event( KMccStreamResumed );
+ SourceEvent( event, aSession, aStream );
+ aSession->EventReceived( event );
+ break;
+ }
+ case EMceItcEnableInactivityTimer:
+ {
+ TMceMccComEvent event( KMccInactivityEvent );
+ SourceEvent( event, aSession, aStream );
+ aSession->EventReceived( event );
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::Sink()
+// -----------------------------------------------------------------------------
+//
+CMceComMediaSink*
+MCETestHelper::Sink( CMceSipSession* aSession, TInt aStream, TInt aSink )
+ {
+
+ CMceComMediaSink* sink = NULL;
+
+ if ( aStream >= 0 )
+ {
+ sink = aSession->Body()->Streams()[ aStream ]->Sinks()[ aSink ];
+ }
+ else
+ {
+ sink = aSession->Body()->Streams()[ 0 ]->BoundStreamL().Sinks()[ aSink ];
+ }
+
+ return sink;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::Source()
+// -----------------------------------------------------------------------------
+//
+CMceComMediaSource*
+MCETestHelper::Source( CMceSipSession* aSession, TInt aStream )
+ {
+ CMceComMediaSource* source = NULL;
+
+ if ( aStream >= 0 )
+ {
+ source = aSession->Body()->Streams()[ aStream ]->Source();
+ }
+ else
+ {
+ source = aSession->Body()->Streams()[ 0 ]->BoundStreamL().Source();
+ }
+
+ return source;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::SinkEvent()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::SinkEvent( TMceMccComEvent& aEvent,
+ CMceSipSession* aSession,
+ TInt aStream,
+ TInt aSink )
+ {
+ CMceComMediaSink* sink = Sink( aSession, aStream, aSink );
+
+ aEvent.iStream = sink->MediaStream();
+ aEvent.iSink = sink;
+ switch( aEvent.iEvent )
+ {
+ case KMccStreamPaused:
+ {
+ aEvent.iItcEvent = EMceItcStateChanged;
+ aEvent.iItcData = 0;
+ break;
+ }
+ case KMccStreamResumed:
+ {
+ aEvent.iItcEvent = EMceItcStateChanged;
+ aEvent.iItcData = 1;
+ break;
+ }
+ case KMccInactivityEvent:
+ {
+ aEvent.iItcEvent = EMceItcInactivityTimeout;
+ break;
+ }
+ case KMccRtcpReceived:
+ {
+ if ( aEvent.iEventSubType == KRtcpRrPacket )
+ {
+ aEvent.iItcEvent = EMceItcRRReceived;
+ }
+ else if ( aEvent.iEventSubType == KRtcpSrPacket )
+ {
+ aEvent.iItcEvent = EMceItcSRReceived;
+ }
+ else if ( aEvent.iEventSubType == KRtcpPacketUndefined )
+ {
+ aEvent.iItcEvent = EMceItcFCMsgReceived;
+ }
+ break;
+ }
+ default:
+ {
+ aEvent.iItcEvent = EMceItcInProgress;
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::SourceEvent()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::SourceEvent( TMceMccComEvent& aEvent,
+ CMceSipSession* aSession,
+ TInt aStream )
+ {
+ CMceComMediaSource* source = Source( aSession, aStream );
+
+ aEvent.iStream = source->MediaStream();
+ aEvent.iSource = source;
+ switch( aEvent.iEvent )
+ {
+ case KMccStreamPaused:
+ {
+ aEvent.iItcEvent = EMceItcStateChanged;
+ aEvent.iItcData = 0;
+ break;
+ }
+ case KMccStreamResumed:
+ {
+ aEvent.iItcEvent = EMceItcStateChanged;
+ aEvent.iItcData = 1;
+ break;
+ }
+ case KMccInactivityEvent:
+ {
+ aEvent.iItcEvent = EMceItcInactivityTimeout;
+ break;
+ }
+ case KMccRtcpReceived:
+ {
+ if ( aEvent.iEventSubType == KRtcpRrPacket )
+ {
+ aEvent.iItcEvent = EMceItcRRReceived;
+ }
+ else if ( aEvent.iEventSubType == KRtcpSrPacket )
+ {
+ aEvent.iItcEvent = EMceItcSRReceived;
+ }
+ else if ( aEvent.iEventSubType == KRtcpPacketUndefined )
+ {
+ aEvent.iItcEvent = EMceItcFCMsgReceived;
+ }
+ break;
+ }
+ default:
+ {
+ aEvent.iItcEvent = EMceItcInProgress;
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ResponseL()
+// -----------------------------------------------------------------------------
+//
+CSIPClientTransaction& MCETestHelper::ResponseL( CMceSipSession* aSession,
+ TUint aReasonCode,
+ TInt aReasonPhrase,
+ TInt aTrx,
+ TBool aSDPContent,
+ TBool aRequire100rel,
+ TUint aRSeqV,
+ TBool aExpectOkStateChange )
+ {
+ CSIPClientTransaction* trx = aSession->PendingTransactions()[ aTrx ];
+
+ SetResponseL( *trx, aReasonCode, aReasonPhrase, aSDPContent, aRequire100rel, aRSeqV );
+
+ if ( MceSip::ResponseType( *trx ) == E1XX )
+ {
+ trx->iState = CSIPTransactionBase::EProceeding;
+ }
+ else
+ {
+ if ( MceSip::ResponseType( *trx ) == E2XX )
+ {
+ aSession->Dialog()->Dialog().iState = CSIPDialog::EConfirmed;
+ }
+ else
+ {
+ aSession->Dialog()->Dialog().iState = CSIPDialog::ETerminated;
+ }
+ trx->iState = CSIPTransactionBase::ETerminated;
+ }
+
+ aSession->DialogResponseReceived( *trx );
+
+ CMCETls* storage = CMCETls::Storage();
+ if ( aExpectOkStateChange &&
+ ( aReasonCode == KMceSipOK ||
+ aReasonCode == KMceSipRinging ||
+ aReasonCode == KMceSipTrying ) )
+ {
+ MCE_CHECK_MEMORY_LEAVE( storage->iMediaManagerUpdateStatus >= KErrNone &&
+ storage->iMediaManagerAction == CMCETls::ECloseSession )
+ }
+
+ return *trx;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ForkedResponseL()
+// -----------------------------------------------------------------------------
+//
+CSIPClientTransaction& MCETestHelper::ForkedResponseL(
+ CMceSipSession* aSession,
+ CSIPInviteDialogAssoc* dialog,
+ TUint aReasonCode,
+ TInt aReasonPhrase,
+ TInt aTrx,
+ TBool aSDPContent )
+ {
+ CleanupStack::PushL( dialog );
+ CSIPClientTransaction* trx = aSession->PendingTransactions()[ aTrx ];
+
+ SetResponseL( *trx, aReasonCode, aReasonPhrase, aSDPContent );
+
+ if ( MceSip::ResponseType( *trx ) == E1XX )
+ {
+ trx->iState = CSIPTransactionBase::EProceeding;
+ }
+ else
+ {
+ if ( MceSip::ResponseType( *trx ) == E2XX )
+ {
+ aSession->Dialog()->Dialog().iState = CSIPDialog::EConfirmed;
+ }
+ else
+ {
+ aSession->Dialog()->Dialog().iState = CSIPDialog::ETerminated;
+ }
+ trx->iState = CSIPTransactionBase::ETerminated;
+ }
+
+ aSession->InviteForkedL( *trx, dialog );
+ CleanupStack::Pop( dialog );
+
+ CMCETls* storage = CMCETls::Storage();
+ if ( aReasonCode == KMceSipOK || aReasonCode == KMceSipRinging || aReasonCode == KMceSipTrying )
+ {
+ MCE_CHECK_MEMORY_LEAVE( storage->iMediaManagerUpdateStatus >= KErrNone &&
+ storage->iMediaManagerAction == CMCETls::ECloseSession )
+ }
+ return *trx;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::RequestL()
+// -----------------------------------------------------------------------------
+//
+CSIPServerTransaction& MCETestHelper::RequestL( CMceSipSession* aSession,
+ TInt aRequest,
+ TInt aSDPContent,
+ TBool aExpectOkStateChange )
+ {
+ CSIPServerTransaction* trx = NULL;
+ RPointerArray<CSIPHeaderBase> hdrs;
+ CSIPHeaderBase::PushLC( &hdrs );
+ if ( aRequest == SipStrConsts::EPrack )
+ {
+ CSIPRAckHeader* rack = CSIPRAckHeader::NewLC( aSession->ReliableSender().iSequenceNumber,
+ KInviteCSeq,
+ SIPStrings::StringF( SipStrConsts::EInvite ) );
+ hdrs.AppendL( rack );
+ CleanupStack::Pop( rack );
+ }
+
+ if ( aSDPContent == 0 )
+ {
+ trx = MCETestHelper::ServerTransactionL( aRequest, hdrs );
+ }
+ else if ( aSDPContent == 1 )
+ {
+ trx = MCETestHelper::ServerTransactionL( aRequest, hdrs, ETrue );
+ }
+ else
+ {
+ trx = MCETestHelper::ServerTransaction2L( aRequest );
+ }
+
+ if ( aRequest == SipStrConsts::EAck )
+ {
+ trx->iState = CSIPTransactionBase::ETerminated;
+ }
+ CleanupStack::Pop( &hdrs );
+
+ TBool consumed = aSession->DialogRequestReceived( trx, aSession->Dialog()->Dialog() );
+ CleanupStack::PushL( trx );
+ User::LeaveIfError( consumed ? KErrNone : KErrNoMemory );
+ CleanupStack::Pop( trx );
+
+ if ( aExpectOkStateChange )
+ {
+ CMCETls* storage = CMCETls::Storage();
+ MCE_CHECK_MEMORY_LEAVE( storage->iSipSentResponse &&
+ ( storage->iSipSentResponse->StatusCode() == KMceSipServerInternalError ||
+ storage->iSipSentResponse->StatusCode() == KMceSipDecline ) )
+ }
+
+ return *trx;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ServerTransactionL()
+// -----------------------------------------------------------------------------
+//
+CSIPServerTransaction* MCETestHelper::ServerTransactionL( TInt aMethod,
+ TBool aContent,
+ TBool aToAndFromHeaders )
+ {
+ CSIPServerTransaction* srvtransaction =
+ CSIPServerTransaction::NewL( SIPStrings::StringF( aMethod ));
+ CleanupStack::PushL( srvtransaction );
+
+ CUri8* uri = CUri8::NewLC(); //OK
+ MCE_SET_URIL( uri );
+
+ CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri );
+ CleanupStack::Pop( uri );
+ CleanupStack::PushL( requestelements );
+
+ if ( aToAndFromHeaders )
+ {
+ CSIPToHeader* toheader = CSIPToHeader::DecodeL( KSIPProfileDefAOR );
+ CleanupStack::PushL( toheader );
+ CSIPFromHeader* fromheader = CSIPFromHeader::DecodeL(_L8("User <user2@host>"));
+ CleanupStack::PushL( fromheader );
+
+ requestelements->SetFromHeaderL(fromheader);
+ CleanupStack::Pop( fromheader );
+ requestelements->SetToHeaderL(toheader);
+ CleanupStack::Pop( toheader );
+ }
+
+ CSIPMessageElements& msgelements = requestelements->MessageElements();
+
+ if ( aContent )
+ {
+ SetMessageElementsL( msgelements );
+ }
+
+ requestelements->SetMethodL( SIPStrings::StringF( aMethod ));
+
+ srvtransaction->SetRequestElements( requestelements );
+ CleanupStack::Pop( requestelements );
+ CleanupStack::Pop( srvtransaction );
+
+ return srvtransaction;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ServerTransaction2L()
+// -----------------------------------------------------------------------------
+//
+CSIPServerTransaction* MCETestHelper::ServerTransaction2L( TInt aMethod )
+ {
+ CSIPServerTransaction* srvtransaction =
+ CSIPServerTransaction::NewL( SIPStrings::StringF( aMethod ));
+ CleanupStack::PushL( srvtransaction );
+
+ CUri8* uri = CUri8::NewLC(); //OK
+ MCE_SET_URIL( uri );
+
+ CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri );
+ CleanupStack::Pop( uri );
+ CleanupStack::PushL( requestelements );
+
+ CSIPToHeader* toheader = CSIPToHeader::DecodeL( KSIPProfileDefAOR );
+ CleanupStack::PushL( toheader );
+ CSIPFromHeader* fromheader = CSIPFromHeader::DecodeL(_L8("User <user2@host>"));
+ CleanupStack::PushL( fromheader );
+
+ requestelements->SetFromHeaderL(fromheader);
+ CleanupStack::Pop( fromheader );
+ requestelements->SetToHeaderL(toheader);
+ CleanupStack::Pop( toheader );
+
+ CSIPMessageElements& msgelements = requestelements->MessageElements();
+
+ SetMessageElementsL( msgelements, 2 );
+
+ requestelements->SetMethodL( SIPStrings::StringF( aMethod ));
+
+ srvtransaction->SetRequestElements( requestelements );
+ CleanupStack::Pop( requestelements );
+ CleanupStack::Pop( srvtransaction );
+
+ return srvtransaction;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ServerTransactionBadSDPL()
+// -----------------------------------------------------------------------------
+//
+CSIPServerTransaction* MCETestHelper::ServerTransactionBadSDPL( TInt aMethod )
+ {
+ CSIPServerTransaction* srvtransaction =
+ CSIPServerTransaction::NewL( SIPStrings::StringF( aMethod ));
+ CleanupStack::PushL( srvtransaction );
+
+ CUri8* uri = CUri8::NewLC(); //OK
+ MCE_SET_URIL( uri );
+
+ CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri );
+ CleanupStack::Pop( uri );
+ CleanupStack::PushL( requestelements );
+
+ CSIPToHeader* toheader = CSIPToHeader::DecodeL( KSIPProfileDefAOR );
+ CleanupStack::PushL( toheader );
+ CSIPFromHeader* fromheader = CSIPFromHeader::DecodeL(_L8("User <user2@host>"));
+ CleanupStack::PushL( fromheader );
+
+ requestelements->SetFromHeaderL(fromheader);
+ CleanupStack::Pop( fromheader );
+ requestelements->SetToHeaderL(toheader);
+ CleanupStack::Pop( toheader );
+
+ CSIPMessageElements& msgelements = requestelements->MessageElements();
+
+ SetMessageElementsL( msgelements, 3 );
+
+ requestelements->SetMethodL( SIPStrings::StringF( aMethod ));
+
+ srvtransaction->SetRequestElements( requestelements );
+ CleanupStack::Pop( requestelements );
+ CleanupStack::Pop( srvtransaction );
+
+ return srvtransaction;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ServerTransactionL()
+// -----------------------------------------------------------------------------
+//
+CSIPServerTransaction* MCETestHelper::ServerTransactionL( TInt aMethod,
+ RPointerArray<CSIPHeaderBase>& aSipHeaders,
+ TBool aContent )
+ {
+ CSIPServerTransaction* srvtransaction =
+ CSIPServerTransaction::NewL( SIPStrings::StringF( aMethod ));
+ CleanupStack::PushL( srvtransaction );
+
+ CUri8* uri = CUri8::NewLC(); //OK
+ MCE_SET_URIL( uri );
+
+ CSIPRequestElements* requestelements = CSIPRequestElements::NewL( uri );
+ CleanupStack::Pop( uri );
+ CleanupStack::PushL( requestelements );
+
+ CSIPToHeader* toheader = CSIPToHeader::DecodeL( KSIPProfileDefAOR );
+ CleanupStack::PushL( toheader );
+ CSIPFromHeader* fromheader = CSIPFromHeader::DecodeL(_L8("User <user2@host>"));
+ CleanupStack::PushL( fromheader );
+
+ requestelements->SetFromHeaderL(fromheader);
+ CleanupStack::Pop( fromheader );
+ requestelements->SetToHeaderL(toheader);
+ CleanupStack::Pop( toheader );
+
+ CSIPMessageElements& msgelements = requestelements->MessageElements();
+
+ if ( aContent )
+ {
+ SetMessageElementsL( msgelements );
+ }
+
+ requestelements->SetMethodL( SIPStrings::StringF( aMethod ));
+ msgelements.SetUserHeadersL( aSipHeaders );
+
+ srvtransaction->SetRequestElements( requestelements );
+ CleanupStack::Pop( requestelements );
+ CleanupStack::Pop( srvtransaction );
+
+ return srvtransaction;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientTransactionLC()
+// -----------------------------------------------------------------------------
+//
+CSIPClientTransaction* MCETestHelper::ClientTransactionLC( TInt aToMethod,
+ TUint aResponse,
+ TInt aPhrase,
+ TBool aContent )
+ {
+ CSIPResponseElements* response = NULL;
+
+ CSIPClientTransaction* clitransaction =
+ CSIPClientTransaction::NewL( SIPStrings::StringF( aToMethod ));
+ CleanupStack::PushL( clitransaction );
+
+ if ( aResponse > 0 )
+ {
+ response = SetResponseL( *clitransaction, aResponse, aPhrase );
+
+ if ( aContent )
+ {
+ CSIPMessageElements& msgelements = response->MessageElements();
+ SetMessageElementsL( msgelements );
+ }
+ if ( aResponse >= KMceSipOK )
+ {
+ clitransaction->SetState( CSIPTransactionBase::ETerminated );
+ }
+ }
+
+ return clitransaction;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ClientTransactionLC()
+// -----------------------------------------------------------------------------
+//
+CSIPClientTransaction* MCETestHelper::ClientTransactionLC( TInt aToMethod,
+ RPointerArray<CSIPHeaderBase>& aSipHeaders,
+ TUint aResponse,
+ TInt aPhrase,
+ TBool aContent )
+ {
+ CSIPResponseElements* response = NULL;
+
+ CSIPClientTransaction* clitransaction =
+ CSIPClientTransaction::NewL( SIPStrings::StringF( aToMethod ));
+ CleanupStack::PushL( clitransaction );
+
+ if ( aResponse > 0 )
+ {
+ response = SetResponseL( *clitransaction, aResponse, aPhrase );
+ CSIPMessageElements& msgelements = response->MessageElements();
+
+ if ( aContent )
+ {
+ CSIPMessageElements& msgelements = response->MessageElements();
+ SetMessageElementsL( msgelements );
+ }
+
+ msgelements.SetUserHeadersL( aSipHeaders );
+ }
+
+ return clitransaction;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::SetResponseL()
+// -----------------------------------------------------------------------------
+//
+CSIPResponseElements* MCETestHelper::SetResponseL( CSIPClientTransaction& aTrx,
+ TUint aResponse,
+ TInt aPhrase,
+ TBool aContent,
+ TBool aRequire100rel,
+ TUint aRSeqValue )
+ {
+ CSIPResponseElements* response =
+ CSIPResponseElements::NewLC( aResponse,
+ SIPStrings::StringF( aPhrase ) );
+
+ CSIPMessageElements& msgelements = response->MessageElements();
+
+ CSIPFromHeader* from = CSIPFromHeader::DecodeL( KFrom );
+ CleanupStack::PushL( from );
+ msgelements.SetFromL( from );
+ CleanupStack::Pop( from );
+
+ CSIPToHeader* to = CSIPToHeader::DecodeL( KTo );
+ CleanupStack::PushL( to );
+ msgelements.SetToL( to );
+ CleanupStack::Pop( to );
+
+ RPointerArray<CSIPHeaderBase> usrhdrs;
+ CSIPHeaderBase::PushLC( &usrhdrs );
+ CSIPContactHeader* contact = MceSip::ToContactHeaderL( KContactValue );
+ CleanupStack::PushL( contact );
+ usrhdrs.AppendL( contact );
+ CleanupStack::Pop( contact );
+ msgelements.SetUserHeadersL( usrhdrs );
+ CleanupStack::Pop( &usrhdrs );
+
+ if ( aResponse == KMceSipSessionProgress || aRequire100rel )
+ {
+ // Require: 100rel
+ RPointerArray<CSIPHeaderBase> hdrs;
+ CSIPHeaderBase::PushLC( &hdrs );
+ RStringF require = SIPStrings::Pool().OpenFStringL( KMceSip100Rel );
+ CleanupClosePushL( require );
+ CSIPRequireHeader* require100rel = CSIPRequireHeader::NewLC( require );
+ hdrs.AppendL( require100rel );
+ CleanupStack::Pop( require100rel );
+ CleanupStack::PopAndDestroy(); // require
+
+ // RSeq
+ CSIPRSeqHeader* rseq = new( ELeave ) CSIPRSeqHeader( aRSeqValue );
+ CleanupStack::PushL( rseq );
+ hdrs.AppendL( rseq );
+ CleanupStack::Pop( rseq );
+
+ msgelements.SetUserHeadersL( hdrs );
+ CleanupStack::Pop( &hdrs );
+ }
+ else if ( aResponse == KMceSipExtensionRequired )
+ {
+ // This branch is special for UT_MCEUsesCases::UT_MCEUsesCases_TestIMSR6toR5IOPL()
+ //
+ // Require: precondition
+ // if response is the kind of KMceSipExtensionRequired, then, response must have
+ // "Require: precondition" field.
+ RPointerArray<CSIPHeaderBase> hdrs;
+ CSIPHeaderBase::PushLC( &hdrs );
+ RStringF require = SIPStrings::Pool().OpenFStringL( KMceSipPrecondition );
+ CleanupClosePushL( require );
+ CSIPRequireHeader* requireProcond = CSIPRequireHeader::NewLC( require );
+ hdrs.AppendL( requireProcond );
+ CleanupStack::Pop( requireProcond );
+ CleanupStack::PopAndDestroy(); // require
+
+ msgelements.SetUserHeadersL( hdrs );
+ CleanupStack::Pop( &hdrs );
+ }
+
+ if ( aContent )
+ {
+ SetMessageElementsL( msgelements );
+ }
+
+ aTrx.SetResponseElements( response );
+ CleanupStack::Pop( response );
+
+ return response;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::SetResponse2L()
+// -----------------------------------------------------------------------------
+//
+CSIPResponseElements* MCETestHelper::SetResponse2L( CSIPClientTransaction& aTrx,
+ TUint aResponse,
+ TInt aPhrase )
+ {
+ CSIPResponseElements* response =
+ CSIPResponseElements::NewLC( aResponse,
+ SIPStrings::StringF( aPhrase ) );
+
+ CSIPMessageElements& msgelements = response->MessageElements();
+
+ SetMessageElementsL( msgelements, 2 );
+
+ aTrx.SetResponseElements( response );
+ CleanupStack::Pop( response );
+
+ return response;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::SetResponseBADL()
+// -----------------------------------------------------------------------------
+//
+CSIPResponseElements*
+MCETestHelper::SetResponseBADL( CSIPClientTransaction& aTrx,
+ TUint aResponse,
+ TInt aPhrase )
+ {
+ CSIPResponseElements* response =
+ CSIPResponseElements::NewLC( aResponse,
+ SIPStrings::StringF( aPhrase ) );
+
+ CSIPMessageElements& msgelements = response->MessageElements();
+
+ SetMessageElementsL( msgelements, 3 );
+
+ aTrx.SetResponseElements( response );
+ CleanupStack::Pop( response );
+
+ return response;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::SetMessageElementsL()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::SetMessageElementsL( CSIPMessageElements& aElements,
+ TInt sdpId )
+ {
+ CSIPContentTypeHeader* contenttype =
+ CSIPContentTypeHeader::NewL( _L8("application"), _L8("sdp") ); //OK
+ CleanupStack::PushL( contenttype );
+
+ HBufC8* content = NULL;
+ if ( sdpId == 1 )
+ {
+ content = KSDPMessage_OK1().AllocLC();
+ }
+ else if ( sdpId == 2 )
+ {
+ content = KSDPMessage_OK2().AllocLC();
+ }
+ else
+ {
+ content = KSDPMessage_BAD().AllocLC();
+ }
+
+ aElements.SetContentL( content, contenttype );
+ CleanupStack::Pop( content );
+ CleanupStack::Pop( contenttype );
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::AppendContactToUserHeaders
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::AppendContactToUserHeaders(
+ RPointerArray<CSIPHeaderBase>& aSipHeaders, const TDesC8& aContact )
+ {
+ CSIPContactHeader* contact = MceSip::ToContactHeaderL( aContact );
+ CleanupStack::PushL( contact );
+ aSipHeaders.AppendL( contact );
+ CleanupStack::Pop( contact );
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::OfferL()
+// -----------------------------------------------------------------------------
+//
+CSdpDocument* MCETestHelper::OfferL()
+ {
+ return CSdpDocument::DecodeL( KSDPMessage_OK1 );
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ComSessionL()
+// -----------------------------------------------------------------------------
+//
+CMceComSession* MCETestHelper::ComSessionL( TUint32 aSessionId,
+ TBool aRequire100rel )
+ {
+ _LIT8( originator, "sip:originator@foo.bar" );
+ _LIT8( recipient, "sip:recipient@foo.bar" );
+ _LIT8( contentType, "contenttype" );
+ _LIT8( header, "header" );
+ _LIT8( amr, "AMR" );
+
+
+ TBuf8<KMceMaxSdpNameLength> amrName;
+ amrName.Append( amr );
+
+ CMceComSession* clientSession = CMceComSession::NewL( CMceComSession::EOutSession );
+ CleanupStack::PushL( clientSession );
+
+
+ CMceComAudioStream* inStream = CMceComAudioStream::NewLC();
+ CMceComAudioStream* outStream = CMceComAudioStream::NewLC();
+ inStream->BindL( outStream );
+ CleanupStack::Pop( outStream );
+
+ CMceComAMRCodec* codec1 = CMceComAMRCodec::NewLC( amrName );
+ inStream->AddCodecL( codec1 );
+ CleanupStack::Pop( codec1 );
+
+ CMceComAMRCodec* codec2 = CMceComAMRCodec::NewLC( amrName );
+ outStream->AddCodecL( codec2 );
+ CleanupStack::Pop( codec2 );
+
+ CMceComRtpSource* rtpSource = CMceComRtpSource::NewLC();
+ inStream->SetSourceL( rtpSource );
+ CleanupStack::Pop( rtpSource );
+
+ CMceComSpeakerSink* speaker = CMceComSpeakerSink::NewLC();
+ inStream->AddSinkL( speaker );
+ CleanupStack::Pop( speaker );
+
+
+ CMceComRtpSink* rtpSink = CMceComRtpSink::NewLC();
+ outStream->AddSinkL( rtpSink );
+ CleanupStack::Pop( rtpSink );
+
+ CMceComMicSource* mic = CMceComMicSource::NewLC();
+ outStream->SetSourceL( mic );
+ CleanupStack::Pop( mic );
+
+ clientSession->AddStreamL( inStream );
+ CleanupStack::Pop( inStream );
+ clientSession->InitializeL();
+
+ //set ids
+ TUid appUid = TUid::Uid( 10 );
+ clientSession->iID = aSessionId;
+ inStream->iID = TMceMediaId(appUid,1);
+ outStream->iID = TMceMediaId(appUid,2);
+ rtpSource->iID = TMceMediaId(appUid,3);
+ speaker->iID = TMceMediaId(appUid,4);
+ rtpSink->iID = TMceMediaId(appUid,5);
+ mic->iID = TMceMediaId(appUid,6);
+
+
+ //set session
+ clientSession->iIsConnectionActive = ETrue;
+ clientSession->iDialogId = 434;
+ clientSession->iIapId = 4;
+ clientSession->iMccID = 101;
+ clientSession->iMinSE = 200;
+ clientSession->iTimeout = 30;
+ clientSession->iLocalIpAddress = TInetAddr( 5005 );
+ clientSession->iRemoteIpAddress = TInetAddr( 5010 );
+ clientSession->SetOriginatorL( originator );
+ clientSession->SetRecipientL( recipient );
+ MCE_TH_SET( clientSession->iSIPContentType, contentType().AllocL() );
+ MCE_TH_SET( clientSession->iSIPHeaders, new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ) );
+ MCE_TH_SET( clientSession->iLocalSessionSDPLines, new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ) );
+ MCE_TH_SET( clientSession->iRemoteSessionSDPLines, new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ) );
+ clientSession->iSIPHeaders->AppendL( header );
+ if ( aRequire100rel )
+ {
+ clientSession->Modifier( KMce100Rel ) = KMce100RelRequired;
+ }
+
+ inStream->iLocalMediaPort = 5001;
+ inStream->iIsEnabled = ETrue;
+ inStream->iRemoteMediaPort = 5002;
+ inStream->iLinkId = 31;
+ inStream->iRemoteRtcpAddress = TInetAddr( 3004 );
+ MCE_TH_SET( inStream->iLocalMediaSDPLines, new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ) );
+ MCE_TH_SET( inStream->iRemoteMediaSDPLines, new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ) );
+ inStream->iLocalMediaSDPLines->AppendL( KFmtAttribute );
+
+ outStream->iLocalMediaPort = 521;
+ outStream->iRemoteMediaPort = 554;
+ outStream->iLinkId = 51;
+ outStream->iIsEnabled = EFalse;
+ outStream->iRemoteRtcpAddress = TInetAddr( 5004 );
+ MCE_TH_SET( outStream->iLocalMediaSDPLines, new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ) );
+ MCE_TH_SET( outStream->iRemoteMediaSDPLines, new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ) );
+ outStream->iRemoteMediaSDPLines->AppendL( KFmtAttribute );
+
+
+ codec1->iEnableVAD = ETrue;
+ codec1->iSamplingFreq = 111;
+ codec1->iPTime = 150;
+ codec1->iMaxPTime = 190;
+ codec1->iBitrate = 1122;
+ codec1->iAllowedBitrates = 11111;
+ codec1->iPayloadType = 197;
+ codec1->iCodecMode = 12;
+ codec1->iFourCC = 1567;
+ codec1->iFrameSize = 165;
+ MCE_TH_SET( codec1->iFmtpAttr, KFmtAttribute().AllocL() );
+
+ codec2->iEnableVAD = ETrue;
+ codec2->iSamplingFreq = 211;
+ codec2->iPTime = 250;
+ codec2->iMaxPTime = 290;
+ codec2->iBitrate = 2122;
+ codec2->iAllowedBitrates = 21111;
+ codec2->iPayloadType = 297;
+ codec2->iCodecMode = 22;
+ codec2->iFourCC = 2567;
+ codec2->iFrameSize = 265;
+ MCE_TH_SET( codec2->iFmtpAttr, KFmtAttribute().AllocL() );
+
+
+ mic->Enabled( ETrue );
+ rtpSource->Enabled( EFalse );
+ rtpSink->Enabled( ETrue );
+ speaker->Enabled( EFalse );
+
+ rtpSource->iInactivityTimer = 999;
+ rtpSource->iBufferLength = 999;
+ rtpSource->iBufferTreshold = 999;
+ MCE_TH_SET( rtpSource->iTalkBurstIndicator, KFmtAttribute().AllocL() );
+
+
+ rtpSink->iSuppressRTCP = ETrue;
+ rtpSink->iSSRC = 888;
+ rtpSink->iLastPacket = 8899;
+
+ CleanupStack::Pop( clientSession );
+
+ return clientSession;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::EventMsg()
+// -----------------------------------------------------------------------------
+//
+CMceMsgBase* MCETestHelper::EventMsg( TInt aEventType )
+ {
+ HBufC8* recipient = KRecipient().AllocLC();
+ HBufC8* originator = KFrom().AllocLC();
+ CDesC8Array* headers = new( ELeave ) CDesC8ArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( headers );
+ HBufC8* contentType = KContentType().AllocLC();
+ TInt interval = 0;
+ HBufC8* event = NULL;
+ HBufC8* referTo = NULL;
+
+ if ( aEventType == EMceItcEventTypeRefer )
+ {
+ event = KNullDesC8().AllocLC();
+ referTo = KReferTo().AllocLC();
+ }
+ else if ( aEventType == EMceItcEventTypeSubscribe )
+ {
+ event = KEvent().AllocLC();
+ referTo = KNullDesC8().AllocLC();
+ interval = 180;
+ }
+ else if ( EMceItcEventTypeEither )
+ {
+ event = KNullDesC8().AllocLC();
+ referTo = KNullDesC8().AllocLC();
+ }
+ CMceMsgSIPEvent* msg = new( ELeave ) CMceMsgSIPEvent( 1, // aId
+ 1, // aDialogId
+ (TMceItcEventType) aEventType,
+ recipient,
+ originator,
+ event,
+ referTo,
+ CMceRefer::ENoSuppression,
+ interval,
+ headers,
+ contentType );
+
+ CleanupStack::Pop( referTo );
+ CleanupStack::Pop( event );
+ CleanupStack::Pop( contentType );
+ CleanupStack::Pop( headers );
+ CleanupStack::Pop( originator );
+ CleanupStack::Pop( recipient );
+ return msg;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ReplyMsg()
+// -----------------------------------------------------------------------------
+//
+CMceMsgBase* MCETestHelper::ReplyMsg( TUint aReasonCode )
+ {
+ HBufC8* reason = KReason().AllocLC();
+ CDesC8Array* headers = new( ELeave ) CDesC8ArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( headers );
+ HBufC8* contentType = KContentType().AllocLC();
+
+ CMceMsgSIPReply* reply = new (ELeave) CMceMsgSIPReply( *reason,
+ aReasonCode,
+ *headers,
+ *contentType );
+ CleanupStack::Pop( contentType );
+ CleanupStack::Pop( headers );
+ CleanupStack::Pop( reason );
+
+ return reply;
+ }
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::RequestMsg()
+// -----------------------------------------------------------------------------
+//
+CMceMsgBase* MCETestHelper::RequestMsg( const TDesC8& aMethod )
+ {
+ HBufC8* method = aMethod.AllocLC();
+
+ CDesC8Array* hdrs = new( ELeave ) CDesC8ArrayFlat( KMceArrayGranularity );
+ CleanupStack::PushL( hdrs );
+
+ HBufC8* ct = KContentType().AllocLC();
+
+ CMceMsgSIPRequest* msg = new (ELeave) CMceMsgSIPRequest( *method, *hdrs,
+ *ct );
+ CleanupStack::Pop( ct );
+ CleanupStack::Pop( hdrs );
+ CleanupStack::Pop( method ) ;
+
+ return msg;
+ }
+
+
+// -----------------------------------------------------------------------------
+// MCETestHelper::ChangeResponseTypeL()
+// -----------------------------------------------------------------------------
+//
+void MCETestHelper::ChangeResponseTypeL( const CSIPResponseElements& aResponse,
+ TUint aResponseCode,
+ TInt aReasonPhrase )
+ {
+ CSIPResponseElements& response =
+ const_cast< CSIPResponseElements& >( aResponse );
+ response.SetStatusCodeL( aResponseCode );
+ response.SetReasonPhraseL( SIPStrings::StringF( aReasonPhrase ) );
+ }