diff -r 000000000000 -r 1bce908db942 multimediacommsengine/mmceshared/src/mcecomsession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommsengine/mmceshared/src/mcecomsession.cpp Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,1315 @@ +/* +* Copyright (c) 2007 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 "mcecomsession.h" +#include "mceserial.h" +#include "mceevents.h" +#include "cleanupresetanddestroy.h" + +#ifdef MCE_COMMON_SERVER_SIDE + +#include "mcesrvstream.h" +#include "mcemediaidle.h" +#include "mcemedianegotiated.h" +#include "mcemediamanager.h" +#include "mcesrvstreamiterator.h" +#include "mceadoptedsrvstream.h" +#include "mcesdpsession.h" + +#else + +#define KMceNegotiationAnswerTypeNotDefined 0 +#define KMceCodecSelectionOff 0 + +#endif//MCE_COMMON_SERVER_SIDE + + + +// ============================ MEMBER FUNCTIONS =============================== + + +// ----------------------------------------------------------------------------- +// CMceComSession::NewL +// ----------------------------------------------------------------------------- +// +CMceComSession* CMceComSession::NewL() + { + return NewL( EInSession ); + } + +// ----------------------------------------------------------------------------- +// CMceComSession::NewL +// ----------------------------------------------------------------------------- +// +CMceComSession* CMceComSession::NewL( CMceComSession::TType aType ) + { + CMceComSession* self = NewLC( aType ); + CleanupStack::Pop( self ); + return self; + } + +// ----------------------------------------------------------------------------- +// CMceComSession::NewLC +// ----------------------------------------------------------------------------- +// +CMceComSession* CMceComSession::NewLC( CMceComSession::TType aType ) + { + CMceComSession* self = new (ELeave) CMceComSession( aType ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// ----------------------------------------------------------------------------- +// CMceComSession::NewL +// ----------------------------------------------------------------------------- +// +CMceComSession* CMceComSession::NewL( MMceComSerializationContext& aSerCtx ) + { + CMceComSession* self = NewLC( aSerCtx ); + CleanupStack::Pop( self ); + return self; + } + +// ----------------------------------------------------------------------------- +// CMceComSession::NewLC +// ----------------------------------------------------------------------------- +// +CMceComSession* CMceComSession::NewLC( MMceComSerializationContext& aSerCtx ) + { + CMceComSession* self = new (ELeave) CMceComSession(); + CleanupStack::PushL( self ); + self->InternalizeL( aSerCtx ); + self->InitializeL(); + return self; + } + +// ----------------------------------------------------------------------------- +// CMceComSession::~CMceComSession +// ----------------------------------------------------------------------------- +// +CMceComSession::~CMceComSession() + { + delete iRecipient; + delete iOriginator; + delete iSIPHeaders; + delete iSIPContentType; + delete iSIPContentHeaders; + delete iLocalSessionSDPLines; + delete iRemoteSessionSDPLines; + delete iSIPContent; + iMediaStreams.ResetAndDestroy(); + iBundles.ResetAndDestroy(); + iClientCryptoSuites.Close(); + +#ifdef MCE_COMMON_SERVER_SIDE + + DeleteSecureSession(); + if ( iSdpSession ) + { + if( iSdpSession->DetachMedia( *this ) ) + { + iSdpSession = NULL; + } + } + + iMccStreams.ResetAndDestroy(); + iMccAdoptedStreams.ResetAndDestroy(); + delete iNegotiationState; +#endif // MCE_COMMON_SERVER_SIDE + } + +// ----------------------------------------------------------------------------- +// CMceComSession::BaseFactory +// ----------------------------------------------------------------------------- +// +TMceComFactory CMceComSession::BaseFactory() + { + return TMceComFactory(); + } + +// ----------------------------------------------------------------------------- +// CMceComSession::Factory +// ----------------------------------------------------------------------------- +// +TMceComFactory CMceComSession::Factory() + { + return TMceComFactory(); + } + +// ----------------------------------------------------------------------------- +// CMceComSession::ConstructL +// ----------------------------------------------------------------------------- +// +void CMceComSession::ConstructL() + { + + iRecipient = KNullDesC8().AllocL(); + iOriginator = KNullDesC8().AllocL(); + iSIPHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); + iSIPContentType = KNullDesC8().AllocL(); + iSIPContentHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); + iLocalSessionSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); + iRemoteSessionSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); + iIsSecureSession = EFalse; + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::ConstructL +// ----------------------------------------------------------------------------- +// +void CMceComSession::ConstructL( CMceComSession& aSession, TBool aPullModeUpdate ) + { + + + iID = aSession.iID; + iRecipient = aSession.iRecipient ? + aSession.iRecipient->AllocL() : KNullDesC8().AllocL(); + iOriginator = aSession.iOriginator ? + aSession.iOriginator->AllocL() : KNullDesC8().AllocL(); + iSIPContentType = aSession.iSIPContentType ? + aSession.iSIPContentType->AllocL() : KNullDesC8().AllocL(); + iState = aSession.iState; + iIsConnectionActive = aSession.iIsConnectionActive; + iDialogId = aSession.iDialogId; + iIapId = aSession.iIapId; + iLocalIpAddress = aSession.iLocalIpAddress; + iRemoteIpAddress = aSession.iRemoteIpAddress; + iMediaObserver = aSession.iMediaObserver; + iTimeout = aSession.iTimeout; + iMinSE = aSession.iMinSE; + iRefresh = aSession.iRefresh; + iIsSecureSession = aSession.iIsSecureSession; + iAnswerType = aSession.iAnswerType; + + iPullModeUpdate = aPullModeUpdate; + + iClientCryptoSuites.Reset(); + for (TInt i=0; iMdcaCount();i++ ) + { + iSIPHeaders->AppendL( aSession.iSIPHeaders->MdcaPoint( i ) ); + } + + iSIPContentHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); + for( TInt i = 0;iMdcaCount();i++ ) + { + iSIPContentHeaders->AppendL( aSession.iSIPContentHeaders->MdcaPoint( i ) ); + } + + iLocalSessionSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); + for( TInt i = 0; i < aSession.iLocalSessionSDPLines->MdcaCount(); i++ ) + { + iLocalSessionSDPLines->AppendL( aSession.iLocalSessionSDPLines->MdcaPoint( i ) ); + } + + iRemoteSessionSDPLines = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity ); + for( TInt i = 0; i < aSession.iRemoteSessionSDPLines->MdcaCount(); i++ ) + { + iRemoteSessionSDPLines->AppendL( aSession.iRemoteSessionSDPLines->MdcaPoint( i ) ); + } + + for( TInt i = 0; i < KMceMaxSessionModifiers; i++ ) + { + iSessionModifiers[ i ] = aSession.iSessionModifiers[ i ]; + } + + if ( !aPullModeUpdate ) + { + CloneStreamsL( aSession ); + CloneBudlesL( aSession ); + } + + iServiceType = aSession.iServiceType; + iSipContactAddrSecure = aSession.iSipContactAddrSecure; + +#ifdef MCE_COMMON_SERVER_SIDE + iSdpSession = aSession.iSdpSession; + if (iClientCryptoSuites.Count()) + { + CloneSecureSessionL(aSession); + } + +#endif//MCE_COMMON_SERVER_SIDE + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::CloneStreamsL +// ----------------------------------------------------------------------------- +// +void CMceComSession::CloneStreamsL( CMceComSession& aSession ) + { + for( TInt i = 0; iCloneL(); + CleanupStack::PushL( stream ); + AddStreamL( stream ); + CleanupStack::Pop( stream ); + } + } + +// ----------------------------------------------------------------------------- +// CMceComSession::CloneBudlesL +// ----------------------------------------------------------------------------- +// +void CMceComSession::CloneBudlesL( CMceComSession& aSession ) + { + for( TInt i = 0; iCloneL( Streams() ); + CleanupStack::PushL( bundle ); + AddBundleL( bundle ); + CleanupStack::Pop( bundle ); + } + } + +// ----------------------------------------------------------------------------- +// CMceComSession::CloneL +// ----------------------------------------------------------------------------- +// +CMceComSession* CMceComSession::CloneL( TBool aPullModeUpdate ) + { + CMceComSession* copy = new (ELeave) CMceComSession( iType ); + CleanupStack::PushL( copy ); + copy->ConstructL( *this, aPullModeUpdate ); + copy->InitializeL(); + CleanupStack::Pop( copy ); + copy->iCloneOrigin = this; + + return copy; + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::AddStreamL +// ----------------------------------------------------------------------------- +// +void CMceComSession::AddStreamL( CMceComMediaStream* aMediaStream ) + { + iMediaStreams.AppendL( aMediaStream ); + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::Streams +// ----------------------------------------------------------------------------- +// +RPointerArray& CMceComSession::Streams() + { + return iMediaStreams; + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::AddBundleL +// ----------------------------------------------------------------------------- +// +void CMceComSession::AddBundleL( CMceComStreamBundle* aBundle ) + { + aBundle->AddedL(); + iBundles.AppendL( aBundle ); + } + +// ----------------------------------------------------------------------------- +// CMceComSession::RemoveBundleL +// ----------------------------------------------------------------------------- +// +void CMceComSession::RemoveBundleL( CMceComStreamBundle& aBundle ) + { + TInt index = iBundles.Find( &aBundle ); + User::LeaveIfError( index ); + iBundles.Remove( index ); + } + +// ----------------------------------------------------------------------------- +// CMceComSession::Bundles +// ----------------------------------------------------------------------------- +// +const RPointerArray< CMceComStreamBundle >& CMceComSession::Bundles() const + { + return iBundles; + } + +// ----------------------------------------------------------------------------- +// CMceComSession::SetObserver +// ----------------------------------------------------------------------------- +// +void CMceComSession::SetObserver( MMceMediaSessionObserver& aMediaObserver ) + { + iMediaObserver = &aMediaObserver; + } + +// ----------------------------------------------------------------------------- +// CMceComSession::SetObserver +// ----------------------------------------------------------------------------- +// +MMceMediaSessionObserver& CMceComSession::MediaObserver() + { + return *iMediaObserver; + } +// ----------------------------------------------------------------------------- +// CMceComSession::SetOriginatorL +// ----------------------------------------------------------------------------- +// +void CMceComSession::SetOriginatorL( const TDesC8& aOriginator ) + { + delete iOriginator; + iOriginator = NULL; + iOriginator = aOriginator.AllocL(); + } +// ----------------------------------------------------------------------------- +// CMceComSession::SetRecipientL +// ----------------------------------------------------------------------------- +// +void CMceComSession::SetRecipientL( const TDesC8& aRecipient ) + { + delete iRecipient; + iRecipient = NULL; + iRecipient = aRecipient.AllocL(); + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::SerializationId +// ----------------------------------------------------------------------------- +// +TUint64 CMceComSession::SerializationId() const + { + return _MAKE_TUINT64_ZX( iID ); + } + +// ----------------------------------------------------------------------------- +// CMceComSession::InternalizeFlatL +// ----------------------------------------------------------------------------- +// +void CMceComSession::InternalizeFlatL( RReadStream& aReadStream ) + { + + + //iType + iType = static_cast( aReadStream.ReadUint8L() ); + + //iID + iID = aReadStream.ReadUint32L(); + + //iState + iState = static_cast( aReadStream.ReadUint8L() ); + + //iRecipient + MceSerial::DecodeL( iRecipient, aReadStream ); + + //iOriginator + MceSerial::DecodeL( iOriginator, aReadStream ); + + //iIsConnectionActive + iIsConnectionActive = static_cast( aReadStream.ReadUint8L() ); + + //iDialogId + iDialogId = aReadStream.ReadUint32L(); + + //iTimeout + iTimeout = aReadStream.ReadUint32L(); + + // iMinSE + iMinSE = aReadStream.ReadUint32L(); + + //iSIPHeaders + MceSerial::DecodeL( iSIPHeaders, aReadStream ); + + //iSIPContentType + MceSerial::DecodeL( iSIPContentType, aReadStream ); + + //iSIPContentHeaders + MceSerial::DecodeL( iSIPContentHeaders, aReadStream ); + + //iLocalSessionSDPLines + MceSerial::DecodeL( iLocalSessionSDPLines, aReadStream ); + + //iRemoteSessionSDPLines + MceSerial::DecodeL( iRemoteSessionSDPLines, aReadStream ); + + //iSessionModifiers + TPckgBuf modifiers; + MceSerial::DecodeL( modifiers, aReadStream ); + iSessionModifiers = modifiers(); + + //check RArray + + MceSerial::DecodeL(iClientCryptoSuites, aReadStream); + + iServiceType = aReadStream.ReadUint32L(); + iSipContactAddrSecure = + static_cast( aReadStream.ReadUint8L() ); + } + + + +// ----------------------------------------------------------------------------- +// CMceComSession::ExternalizeFlatL +// ----------------------------------------------------------------------------- +// +void CMceComSession::ExternalizeFlatL( RWriteStream& aWriteStream ) + { + aWriteStream.WriteUint8L( iType ); + aWriteStream.WriteUint32L( iID ); + aWriteStream.WriteUint8L( iState ); + MceSerial::EncodeL( iRecipient, aWriteStream ); + MceSerial::EncodeL( iOriginator, aWriteStream ); + aWriteStream.WriteUint8L( iIsConnectionActive ); + aWriteStream.WriteUint32L( iDialogId ); + aWriteStream.WriteUint32L( iTimeout ); + aWriteStream.WriteUint32L( iMinSE ); + MceSerial::EncodeL( iSIPHeaders, aWriteStream ); + MceSerial::EncodeL( iSIPContentType, aWriteStream ); + MceSerial::EncodeL( iSIPContentHeaders, aWriteStream ); + MceSerial::EncodeL( iLocalSessionSDPLines, aWriteStream ); + MceSerial::EncodeL( iRemoteSessionSDPLines, aWriteStream ); + TPckgBuf modifiers( iSessionModifiers ); + MceSerial::EncodeL( modifiers, aWriteStream ); + MceSerial::EncodeL(iClientCryptoSuites, aWriteStream); + aWriteStream.WriteUint32L( iServiceType ); + aWriteStream.WriteUint8L( iSipContactAddrSecure ); + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::InternalizeL +// ----------------------------------------------------------------------------- +// +void CMceComSession::InternalizeL( MMceComSerializationContext& aSerCtx ) + { + TMceSessionSerializer serial( *this ); + serial.InternalizeL( aSerCtx ); + } + +// ----------------------------------------------------------------------------- +// CMceComSession::InternalizeL +// ----------------------------------------------------------------------------- +// +void CMceComSession::ExternalizeL( MMceComSerializationContext& aSerCtx ) + { + TMceSessionSerializer serial( *this ); + serial.ExternalizeL( aSerCtx ); + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::CMceComSession +// ----------------------------------------------------------------------------- +// +CMceComSession::CMceComSession() + : iID( KMceNotAssigned ), + iType( EInSession ), + iState( CMceSession::EIncoming ), + iRecipient( NULL ), + iOriginator( NULL ), + iIsConnectionActive( ETrue ), + iMccID( KMceNotAssigned ), + iStructureChanged( EFalse ), + iUseLocalPreconditions( EFalse ), + iUseRemotePreconditions( EFalse ), + iFcSignallingRequired( EFalse ), + iRequireSignalling( EFalse ), + iServiceType( KMceDefaultTypeOfServiceValue ), + iAnswerType( KMceNegotiationAnswerTypeNotDefined ), + iCodecSelection( KMceCodecSelectionOff ), + iRemoteSecPreconditionsRequired( EFalse ), + iTimeout( 0 ), + iMinSE( 0 ) + { + for( TInt i = 0;i( aEvent.Message() ); + UpdateL( *updateSession ); + } + else + { + User::Leave( KErrGeneral ); + } + } + else + { + TInt j = 0; + TInt status = KMceEventNotConsumed; + while ( status != KMceEventConsumed && j < iMediaStreams.Count() ) + { + CMceComMediaStream* stream = iMediaStreams[j]; + status = stream->EventReceivedL( aEvent ); + j++; + } + + } + + + } + + + +// ----------------------------------------------------------------------------- +// CMceComSession::InitializeL +// ----------------------------------------------------------------------------- +// + +void CMceComSession::InitializeL() + { + for( int i = 0; i < Streams().Count(); i++ ) + { + Streams()[i]->InitializeL( *this ); + } + for( int i = 0; i < Bundles().Count(); i++ ) + { + Bundles()[i]->InitializeL( *this ); + } + + } + +// ----------------------------------------------------------------------------- +// CMceComSession::UpdateL +// ----------------------------------------------------------------------------- +// +void CMceComSession::UpdateL( CMceComSession& aSession ) + { + + IsStructureChanged() = EFalse; + + UpdateFlatL( aSession ); + + delete iSIPHeaders; + iSIPHeaders = aSession.iSIPHeaders; + aSession.iSIPHeaders = NULL; + + delete iSIPContentType; + iSIPContentType = aSession.iSIPContentType; + aSession.iSIPContentType = NULL; + + delete iSIPContentHeaders; + iSIPContentHeaders = aSession.iSIPContentHeaders; + aSession.iSIPContentHeaders = NULL; + + delete iLocalSessionSDPLines; + iLocalSessionSDPLines = aSession.iLocalSessionSDPLines; + aSession.iLocalSessionSDPLines = NULL; + + UpdateStreamsL( aSession ); + InitializeL(); + + } + + +// --------------------------------------------------------- +// CMceComSession::UpdateFlatL +// --------------------------------------------------------- +void CMceComSession::UpdateFlatL( CMceComSession& aSession ) + { + + iType = aSession.iType; + iID = aSession.iID; + iState = aSession.iState; + + delete iRecipient; + iRecipient = aSession.iRecipient; + aSession.iRecipient = NULL; + + delete iOriginator; + iOriginator = aSession.iOriginator; + aSession.iOriginator = NULL; + + iIsConnectionActive = aSession.iIsConnectionActive; + iTimeout = aSession.iTimeout; + iMinSE = aSession.iMinSE; + + delete iRemoteSessionSDPLines; + iRemoteSessionSDPLines = aSession.iRemoteSessionSDPLines; + aSession.iRemoteSessionSDPLines = NULL; + + iSessionModifiers = aSession.iSessionModifiers; + + iIsSecureSession=aSession.iIsSecureSession; + iClientCryptoSuites.Reset(); + for (TInt i=0; i updated; + MceCleanupResetAndDestroyPushL( updated ); + TInt push = 0; + + TInt i = 0; + for( i = 0; i < aSession.Streams().Count(); i++ ) + { + CMceComMediaStream* update = aSession.Streams()[i]; + + TBool isUpdated = EFalse; + TInt j = 0; + while( !isUpdated && j < Streams().Count() ) + { + CMceComMediaStream* stream = Streams()[j]; + + if ( stream->Id() == update->Id() ) + { + stream->UpdateL( *update ); + aSession.Streams().Remove( i ); + CleanupStack::PushL( update ); + push++; + updated.AppendL( stream ); + Streams().Remove( j ); + i--; + isUpdated = ETrue; + } + j++; + } + } + + if ( Streams().Count() > 0 )//streams have been removed + { + IsStructureChanged() = ETrue; + } + + UpdateBundlesL( aSession, updated ); + + if ( push ) + { + CleanupStack::PopAndDestroy( push ); + } + + iMediaStreams.ResetAndDestroy(); + while( updated.Count() > 0 ) + { + AddStreamL( updated[0] ); + updated.Remove( 0 ); + } + + CleanupStack::PopAndDestroy();//updated + + if ( aSession.Streams().Count() > 0 )//streams have been added + { + IsStructureChanged() = ETrue; + + while( aSession.Streams().Count() > 0 ) + { + IsStructureChanged() = ETrue; + CMceComMediaStream* add = aSession.Streams()[0]; + AddStreamL( add ); + aSession.Streams().Remove( 0 ); + } + } + + } + +// --------------------------------------------------------- +// CMceComSession::UpdateBundlesL +// --------------------------------------------------------- +void CMceComSession::UpdateBundlesL( CMceComSession& aSession, + const RPointerArray& aStreams ) + { + + iBundles.ResetAndDestroy(); + + TInt i = 0; + for( i = 0; i < aSession.Bundles().Count(); i++ ) + { + CMceComStreamBundle* update = aSession.Bundles()[i]; + CMceComStreamBundle* bundle = update->CloneL( aStreams ); + CleanupStack::PushL( bundle ); + bundle->UpdateL( *update ); + AddBundleL( bundle ); + CleanupStack::Pop( bundle ); + } + } + + +// --------------------------------------------------------- +// CMceComSession::Modifier +// --------------------------------------------------------- +// +TUint& CMceComSession::Modifier( TMceSessionModifier aModifier ) + { + return iSessionModifiers[ (TInt) aModifier ]; + } + +// --------------------------------------------------------- +// CMceComSession::UseRtcp +// --------------------------------------------------------- +// +TBool CMceComSession::UseRtcp() const + { + TBool useRtcp( ETrue ); + for( TInt i=0; i < iMediaStreams.Count() && useRtcp; i++ ) + { + useRtcp = iMediaStreams[i]->UseRtcp(); + } + return useRtcp; + } + +#ifdef MCE_COMMON_SERVER_SIDE + +// --------------------------------------------------------- +// CMceComSession::Delete +// --------------------------------------------------------- +// +void CMceComSession::Delete( CMceComSession*& aThis, + CMceMediaManager& aManager ) + { + if( aThis ) + { + aManager.CloseSession( *aThis ); + + aThis->iMccStreams.ResetAndDestroy(); + aThis->iMccAdoptedStreams.ResetAndDestroy(); + delete aThis->iNegotiationState; + aThis->iNegotiationState = NULL; + + delete aThis; + aThis = NULL; + } + } + + +// --------------------------------------------------------- +// CMceComSession::SdpSession +// --------------------------------------------------------- +CMceSdpSession& CMceComSession::SdpSession() const + { + return *iSdpSession; + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::Backup +// ----------------------------------------------------------------------------- +// +CMceComSession* CMceComSession::Backup() + { + CMceComSession* backup = NULL; + + if ( iSdpSession ) + { + backup = SdpSession().Backup(); + } + + return backup; + + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::IsBackup +// ----------------------------------------------------------------------------- +// +TBool CMceComSession::IsBackup() + { + CMceComSession* backup = Backup(); + + return this == backup; + + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::IsMerged +// ----------------------------------------------------------------------------- +// +TBool CMceComSession::IsMerged() + { + TBool isMerged = EFalse; + + if ( Backup() ) + { + isMerged = SdpSession().MediaSession()->iMccID == + SdpSession().Backup()->iMccID; + } + + return isMerged; + + } + + + +// --------------------------------------------------------- +// CMceComSession::AnswerType +// --------------------------------------------------------- +TMceNegotiationAnswerType& CMceComSession::AnswerType() + { + return iAnswerType; + } + + + +// --------------------------------------------------------- +// CMceComSession::AttachSDPSessionL +// --------------------------------------------------------- +void CMceComSession::AttachSDPSessionL( CMceSdpSession& aSdpSession ) + { + TMceMediaState* state = NULL; + + iSdpSession = &aSdpSession; + + if ( iCloneOrigin && !iNegotiationState ) + { + __ASSERT_ALWAYS( + iCloneOrigin->NegotiationState().Id() == KMceMediaNegotiated, + User::Leave( KErrArgument ) ); + + __ASSERT_ALWAYS( iCloneOrigin == aSdpSession.MediaSession(), + User::Leave( KErrArgument ) ); + + //set negotiated state + state = new (ELeave) TMceMediaNegotiated( *this ); + SetNegotiationState( state ); + + aSdpSession.SetBackup( iCloneOrigin ); + iCloneOrigin = NULL; + + } + else if ( !iNegotiationState ) + { + //set idle state + state = new (ELeave) TMceMediaIdle( *this ); + SetNegotiationState( state ); + } + else + { + //NOP + } + + aSdpSession.SetMediaSession( this ); + + } + +// --------------------------------------------------------- +// CMceComSession::DetachSDPSession +// --------------------------------------------------------- +void CMceComSession::DetachSDPSession() + { + iSdpSession = NULL; + } + + +// --------------------------------------------------------- +// CMceComSession::NegotiationState +// --------------------------------------------------------- +TMceMediaState& CMceComSession::NegotiationState() const + { + return *iNegotiationState; + } + + +// --------------------------------------------------------- +// CMceComSession::SetNegotiationStateL +// --------------------------------------------------------- +TMceMMState CMceComSession::SetNegotiationStateL( TMceMediaState* aNewState ) + { + + __ASSERT_ALWAYS( aNewState != NULL, User::Leave( KErrArgument ) ); + __ASSERT_ALWAYS( aNewState != iNegotiationState, User::Leave( KErrArgument ) ); + + TBool callbackAllowed = EFalse; + if ( iNegotiationState ) + { + iNegotiationState->Pushed(); + TInt oldIndex = iNegotiationState->StackIndex(); + callbackAllowed = aNewState->CallbackAllowed(); + aNewState->EntryL(); + TInt newIndex = iNegotiationState->StackIndex(); + if ( oldIndex == newIndex ) //EntryL didn't push + { + SetNegotiationState( aNewState ); + } + else if ( iNegotiationState->StackIndex() == 0 ) //new state is transitional + { + delete aNewState; + aNewState = NULL; + } + + if ( callbackAllowed && iNegotiationState == aNewState ) + { + iNegotiationState->Callback(); + } + + } + else + { + SetNegotiationState( aNewState ); + } + + + return iNegotiationState->Id(); + + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::SetNegotiationState +// ----------------------------------------------------------------------------- +// +void CMceComSession::SetNegotiationState( TMceMediaState* aNewState ) + { + delete iNegotiationState; + iNegotiationState = aNewState; + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::CloneAndMergeL +// ----------------------------------------------------------------------------- +// +CMceComSession* CMceComSession::CloneAndMergeLC( CMceComSession& aSession ) + { + + CMceComSession* copy = new (ELeave) CMceComSession( iType ); + CleanupStack::PushL( copy ); + copy->ConstructL( *this ); + copy->InitializeL(); + + TMceMediaState* state = + aSession.NegotiationState().CloneL( *copy ); + copy->SetNegotiationState( state ); + + copy->iUseLocalPreconditions = aSession.iUseLocalPreconditions; + copy->iUseRemotePreconditions = aSession.iUseRemotePreconditions; + copy->iFcSignallingRequired = aSession.iFcSignallingRequired; + copy->iRequireSignalling = aSession.iRequireSignalling; + copy->iServiceType = aSession.iServiceType; + copy->iAnswerType = aSession.iAnswerType; + copy->iRemoteSecPreconditionsRequired = aSession.iRemoteSecPreconditionsRequired; + + TInt index = 0; + for( index = 0; index < copy->Streams().Count(); index++ ) + { + TBool dges = aSession.Streams()[ index ]->DowngradedEndpoints(); + copy->Streams()[ index ]->DowngradedEndpoints() = dges; + } + + copy->PrepareL( aSession.SdpSession().Manager() ); + + + + return copy; + + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::PrepareL +// ----------------------------------------------------------------------------- +// +void CMceComSession::PrepareL( CMceMediaManager& aManager ) + + { + TInt i = 0; + MccStreams().ResetAndDestroy(); + for ( i = 0; i < iMediaStreams.Count(); i++) + { + CMceSrvStream::DecodeL( MccStreams(), *iMediaStreams[i], aManager ); + } + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::AdoptStreamL +// ----------------------------------------------------------------------------- +// +void CMceComSession::AdoptStreamL( CMceSrvStream& aStream ) + { + + CMceSrvStream* adopted = CMceAdoptedSrvStream::NewL( aStream ); + CleanupStack::PushL( adopted ); + iMccAdoptedStreams.AppendL( adopted ); + CleanupStack::Pop( adopted ); + + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::RemoveAdoptedStream +// ----------------------------------------------------------------------------- +// +CMceSrvStream* CMceComSession::RemoveAdoptedStream( CMceSrvStream& aStream ) + { + + TMceSrvStreamIterator adopts( AdoptedMccStreams() ); + CMceSrvStream* adopted = NULL; + + if ( adopts.Next( adopted, aStream ) ) + { + AdoptedMccStreams().Remove( adopts.Current() ); + } + return adopted; + + } + + + +// ----------------------------------------------------------------------------- +// CMceComSession::Merge +// ----------------------------------------------------------------------------- +// +void CMceComSession::Merge( CMceComSession& aSession, TBool aDeepMerge ) + { + + iMccID = aSession.iMccID; + + TMceSrvStreamIterator mergeStreams( MccStreams() ); + TMceSrvStreamIterator mergeWithStreams( aSession.MccStreams() ); + + CMceSrvStream* merge = NULL; + CMceSrvStream* mergeWith = NULL; + + while( mergeStreams.NextIntersect( merge, mergeWithStreams, mergeWith ) ) + { + merge->Merge( *mergeWith, aDeepMerge ); + } + + TInt index = 0; + for( index = 0; index < Streams().Count(); index++ ) + { + Streams()[ index ]->DowngradedEndpoints() = EFalse; + } + for( index = 0; index < aSession.Streams().Count(); index++ ) + { + aSession.Streams()[ index ]->DowngradedEndpoints() = EFalse; + } + + } + +// ----------------------------------------------------------------------------- +// CMceComSession::UnMerge +// ----------------------------------------------------------------------------- +// +void CMceComSession::UnMerge() + { + + TMceSrvStreamIterator streams( MccStreams() ); + CMceSrvStream* stream = NULL; + + while( streams.Next( stream ) ) + { + stream->UnMerge(); + } + + } + +// ----------------------------------------------------------------------------- +// CMceComSession::UnMergeL +// ----------------------------------------------------------------------------- +// +void CMceComSession::UnMergeL( CMceComSession& aSession ) + { + TMceSrvStreamIterator unmergeStreams( MccStreams() ); + TMceSrvStreamIterator unmergeFromStreams( aSession.MccStreams() ); + + CMceSrvStream* stream = NULL; + CMceSrvStream* unmergeFrom = NULL; + + while( unmergeStreams.NextIntersect( stream, unmergeFromStreams, unmergeFrom ) ) + { + stream->UnMergeL( *unmergeFrom ); + } + + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::PrepareL +// ----------------------------------------------------------------------------- +// +void CMceComSession::PrepareL() + { + TInt i = 0; + for ( i = 0; i < iMediaStreams.Count(); i++) + { + iMediaStreams[i]->PrepareL(); + } + } + + +// ----------------------------------------------------------------------------- +// CMceComSession::MccStreams +// ----------------------------------------------------------------------------- +// +RPointerArray& CMceComSession::MccStreams() + { + return iMccStreams; + } + +// ----------------------------------------------------------------------------- +// CMceComSession::AdoptedMccStreams +// ----------------------------------------------------------------------------- +// +RPointerArray& CMceComSession::AdoptedMccStreams() + { + return iMccAdoptedStreams; + } + + +// ------------------------------------------------------------------------------ +// CMceComSession::SecureSessionL +// ------------------------------------------------------------------------------ +CMceSecureMediaSession& CMceComSession::SecureSessionL() + { + if ( !SecureSession() ) + { + iSecureMediaSession = CMceSecureMediaSession::NewL( *this, + SdpSession().iManager, + *(SdpSession().iManager.iMccSecureInterface ) ); + } + return *SecureSession(); + } + + +// ------------------------------------------------------------------------------ +// CMceComSession::SecureSession() +// ------------------------------------------------------------------------------ +CMceSecureMediaSession* CMceComSession::SecureSession() + { + return iSecureMediaSession; + } + +// -------------------------------------------------------------------------------------- +// CMceComSession::CloneSecureSessionL() +// -------------------------------------------------------------------------------------- +void CMceComSession::CloneSecureSessionL(CMceComSession& aSession) + { + CMceSecureMediaSession* secureMediaSession = CMceSecureMediaSession::NewL(*this, + aSession.SdpSession().iManager, + *(aSession.SdpSession().iManager.iMccSecureInterface)); + CleanupStack::PushL(secureMediaSession); + + secureMediaSession->CopyStreamsL( *aSession.SecureSession()); + CleanupStack::Pop(secureMediaSession); + + delete iSecureMediaSession; + + iSecureMediaSession = secureMediaSession; + } + +// -------------------------------------------------------------------------------------- +// CMceComSession::DeleteSecureSession() +// -------------------------------------------------------------------------------------- +void CMceComSession::DeleteSecureSession() + { + delete iSecureMediaSession; + iSecureMediaSession = NULL; + } + +// -------------------------------------------------------------------------------------- +// CMceComSession::SdpCleanup() +// -------------------------------------------------------------------------------------- +void CMceComSession::SdpCleanup( CSdpDocument* aPrevious, CSdpDocument* aReplacement ) + { + if ( iSdpSession ) + { + iSdpSession->SdpCleanup( aPrevious, aReplacement ); + } + + if ( Backup() && &Backup()->SdpSession() ) + { + Backup()->SdpSession().SdpCleanup( aPrevious, aReplacement ); + } + } + + +#endif//MCE_COMMON_SERVER_SIDE