RCS feature support in MCE/MCC.
Provides APIs to do RCS chat and file transfer as per RCS specificaitons. For both os these MCE uses the MSRP protocol.
/*
* 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; i<aSession.iClientCryptoSuites.Count(); i++)
{
iClientCryptoSuites.InsertL( aSession.iClientCryptoSuites[i], i);
}
iSIPHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
for( TInt i = 0;i<aSession.iSIPHeaders->MdcaCount();i++ )
{
iSIPHeaders->AppendL( aSession.iSIPHeaders->MdcaPoint( i ) );
}
iSIPContentHeaders = new (ELeave) CDesC8ArrayFlat( KMceArrayGranularity );
for( TInt i = 0;i<aSession.iSIPContentHeaders->MdcaCount();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; i<aSession.Streams().Count(); i++ )
{
CMceComMediaStream* stream = aSession.Streams()[i]->CloneL();
CleanupStack::PushL( stream );
AddStreamL( stream );
CleanupStack::Pop( stream );
}
}
// -----------------------------------------------------------------------------
// CMceComSession::CloneBudlesL
// -----------------------------------------------------------------------------
//
void CMceComSession::CloneBudlesL( CMceComSession& aSession )
{
for( TInt i = 0; i<aSession.Bundles().Count(); i++ )
{
CMceComStreamBundle* bundle = aSession.Bundles()[i]->CloneL( 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<CMceComMediaStream>& 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<TType>( aReadStream.ReadUint8L() );
//iID
iID = aReadStream.ReadUint32L();
//iState
iState = static_cast<CMceSession::TState>( aReadStream.ReadUint8L() );
//iRecipient
MceSerial::DecodeL( iRecipient, aReadStream );
//iOriginator
MceSerial::DecodeL( iOriginator, aReadStream );
//iIsConnectionActive
iIsConnectionActive = static_cast<TBool>( 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<TMceComSessionModifiers> modifiers;
MceSerial::DecodeL( modifiers, aReadStream );
iSessionModifiers = modifiers();
//check RArray
MceSerial::DecodeL(iClientCryptoSuites, aReadStream);
iServiceType = aReadStream.ReadUint32L();
iSipContactAddrSecure =
static_cast<CMceSession::TControlPathSecurityLevel>( aReadStream.ReadUint8L() );
MceSerial::DecodeL(iLocalIpAddress, aReadStream);
MceSerial::DecodeL(iRemoteIpAddress, aReadStream);
}
// -----------------------------------------------------------------------------
// 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<TMceComSessionModifiers> modifiers( iSessionModifiers );
MceSerial::EncodeL( modifiers, aWriteStream );
MceSerial::EncodeL(iClientCryptoSuites, aWriteStream);
aWriteStream.WriteUint32L( iServiceType );
aWriteStream.WriteUint8L( iSipContactAddrSecure );
MceSerial::EncodeL(iLocalIpAddress, aWriteStream);
MceSerial::EncodeL(iRemoteIpAddress, aWriteStream);
}
// -----------------------------------------------------------------------------
// CMceComSession::InternalizeL
// -----------------------------------------------------------------------------
//
void CMceComSession::InternalizeL( MMceComSerializationContext& aSerCtx )
{
TMceSessionSerializer<CMceComSession> serial( *this );
serial.InternalizeL( aSerCtx );
}
// -----------------------------------------------------------------------------
// CMceComSession::InternalizeL
// -----------------------------------------------------------------------------
//
void CMceComSession::ExternalizeL( MMceComSerializationContext& aSerCtx )
{
TMceSessionSerializer<CMceComSession> 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<KMceMaxSessionModifiers;i++ )
{
iSessionModifiers[ i ] = KMaxTUint16;
}
Modifier( KMcePreconditions ) = KMcePreconditionsSupported;
Modifier( KMce100Rel ) = KMce100RelSupported;
Modifier( KMceMediaDirection ) = KMceMediaDirectionOnly;
}
// -----------------------------------------------------------------------------
// CMceComSession::CMceComSession
// -----------------------------------------------------------------------------
//
CMceComSession::CMceComSession( CMceComSession::TType aType )
: iID( KMceNotAssigned ),
iType( aType ),
iState( CMceSession::EIdle ),
iRecipient( NULL ),
iOriginator( NULL ),
iIsConnectionActive( ETrue ),
iMccID( KMceNotAssigned ),
iServiceType( KMceDefaultTypeOfServiceValue ),
iTimeout( 0 ),
iMinSE( 0 )
{
if ( iType == EInSession )
{
iState = CMceSession::EIncoming;
}
for( TInt i = 0;i<KMceMaxSessionModifiers;i++ )
{
iSessionModifiers[ i ] = KMaxTUint16;
}
Modifier( KMcePreconditions ) = KMcePreconditionsSupported;
Modifier( KMce100Rel ) = KMce100RelSupported;
Modifier( KMceMediaDirection ) = KMceMediaDirectionOnly;
}
// -----------------------------------------------------------------------------
// CMceComSession::Id
// -----------------------------------------------------------------------------
//
TUint32 CMceComSession::Id() const
{
return iID;
}
// -----------------------------------------------------------------------------
// CMceComSession::IsStructureChanged
// -----------------------------------------------------------------------------
//
TBool& CMceComSession::IsStructureChanged()
{
return iStructureChanged;
}
// -----------------------------------------------------------------------------
// CMceComSession::EventReceivedL
// -----------------------------------------------------------------------------
//
void CMceComSession::EventReceivedL( TMceComEvent& aEvent )
{
__ASSERT_ALWAYS( aEvent.Id().iSessionID == iID, User::Leave( KErrGeneral ) );
if ( aEvent.Id().IsSessionId() )
{
if ( aEvent.Action() == EMceItcUpdate )
{
CMceComSession* updateSession = static_cast<CMceComSession*>( 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<aSession.iClientCryptoSuites.Count(); i++)
{
iClientCryptoSuites.InsertL( aSession.iClientCryptoSuites[i], i);
}
iServiceType = aSession.iServiceType;
iSipContactAddrSecure = aSession.iSipContactAddrSecure;
iRemoteIpAddress = aSession.iRemoteIpAddress;
iLocalIpAddress = aSession.iLocalIpAddress;
}
// ---------------------------------------------------------
// CMceComSession::UpdateStreamsL
// ---------------------------------------------------------
void CMceComSession::UpdateStreamsL( CMceComSession& aSession )
{
RPointerArray<CMceComMediaStream> 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<CMceComMediaStream>& 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;
if( copy->iSecureMediaSession )
{
copy->iSecureMediaSession->iLSReadyToBind = EFalse;
}
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<CMceSrvStream>& CMceComSession::MccStreams()
{
return iMccStreams;
}
// -----------------------------------------------------------------------------
// CMceComSession::AdoptedMccStreams
// -----------------------------------------------------------------------------
//
RPointerArray<CMceSrvStream>& 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