diff -r 000000000000 -r 1bce908db942 multimediacommsengine/tsrc/ututils/src/MCETestHelper.cpp --- /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 +#include +#include + +_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(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( 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* clientSessionMsg = + new (ELeave) CMceMsgObject( *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 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(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* message = static_cast*> + (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 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(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* clientSessionMsg = + new (ELeave) CMceMsgObject( 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* clientSessionMsg = + new (ELeave) CMceMsgObject(); + 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 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 ")); + 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 ")); + 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 ")); + 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& 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 ")); + 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& 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 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 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 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& 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 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 ) ); + }