/*

* 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 FILES

#include <AudioPreference.h>

#include <mmcccodecinformationfactory.h>

#include <mmcccodecinformation.h>

#include <mmccinterface.h>

#include <sdpdocument.h>

#include <sdpcodecstringpool.h>

#include "mcemediasource.h"

#include "mcemediastream.h"

#include "mceaudiostream.h"

#include "mcemicsource.h"

#include "mcertpsource.h"

#include "mcertpsink.h"

#include "mcecamerasource.h"

#include "mcefilesource.h"

#include "mcedisplaysink.h"

#include "mceaudiocodec.h"

#include "mceamrcodec.h"

#include "mcenatpluginmanager.h"

#include "mcecssessionimplementation.h"

#include "mcemediamanager.h"

#include "mcemediaobserver.h"

#include "mcesdpsession.h"

#include "mcemediadefs.h"

#include "mcecommediastream.h"

#include "mcecomaudiostream.h"

#include "mcecomsession.h"

#include "mcecomaudiocodec.h"

#include "mcecomvideocodec.h"

#include "mcecommediasource.h"

#include "mcecommediasink.h"

#include "mcecomrtpsource.h"

#include "mcecomdisplaysink.h"

#include "mcecomcamerasource.h"

#include "mcecomrtpsink.h"

#include "mcecomspeakersink.h"

#include "mcemmlogs.h"

#include "mcecomfactory.h"

#include "mcesrvstreamiterator.h"

#include "mcesrvsink.h"

#include "mcesrvsource.h"

#include "mceevents.h"

#include "mcemediastate.h"

#include "mceaudiosdpcodec.h"

#include "mcevideosdpcodec.h"

#include "cleanupresetanddestroy.h"

#include "mcedtmfhandler.h"

#include "mcecomendpointproxy.h"

#define MCE_HEAP_CONSTRUCT_LC( type, variable ) \

type* variable = new ( ELeave ) type; \

CleanupStack::PushL( variable );

#define MCE_HEAP_CONSTRUCT_WITH_PARAM_LC( type, variable, param ) \

type* variable = new ( ELeave ) type( param ); \

CleanupStack::PushL( variable );

const TInt KMceMaxFileName8 = KMceMaxFileNameLength * 4;

// ================ MEMBER FUNCTIONS =======================

// ---------------------------------------------------------

// CMceMediaManager::CMceMediaManager

// ---------------------------------------------------------

CMceMediaManager::CMceMediaManager() 

    {

    }

// ---------------------------------------------------------

// CMceMediaManager::ConstructL

// ---------------------------------------------------------

void CMceMediaManager::ConstructL( MMceMediaGeneralObserver& aObserver )

    {  

    iObserver = &aObserver;

    iMccInterface = CMccInterface::NewL( *this );

    iMccSecureInterface = CMccSecureInterface::NewL( *iMccInterface );

    SdpCodecStringPool::OpenL();

    iNatPluginManager = CMceNatPluginManager::NewL();

    CMceSdpCodec* sdpCodec = NULL;

    //audio SDP codec

    sdpCodec = CMceAudioSdpCodec::NewL();

    CleanupStack::PushL( sdpCodec );

    iSdpCodecs.AppendL( sdpCodec );

    CleanupStack::Pop( sdpCodec );

    //video SDP codec

    sdpCodec = CMceVideoSdpCodec::NewL();

    CleanupStack::PushL( sdpCodec );

    iSdpCodecs.AppendL( sdpCodec );

    CleanupStack::Pop( sdpCodec );

    }

// ---------------------------------------------------------

// CMceMediaManager::SdpCodec

// ---------------------------------------------------------

CMceSdpCodec* CMceMediaManager::SdpCodec( const CSdpMediaField& aMedia )

    {

    CMceSdpCodec* sdpCodec = NULL;

    TInt index = 0;

    while( !sdpCodec && index < iSdpCodecs.Count() )

        {

        sdpCodec = iSdpCodecs[ index++ ];

        sdpCodec = sdpCodec->Decodes( aMedia ) ? sdpCodec : NULL;

        }

    return sdpCodec;

    }

// ---------------------------------------------------------

// CMceMediaManager::SdpCodec

// ---------------------------------------------------------

CMceSdpCodec* CMceMediaManager::SdpCodec( CMceComMediaStream& aStream )

    {

    CMceSdpCodec* sdpCodec = NULL;

    TInt index = 0;

    while( !sdpCodec && index < iSdpCodecs.Count() )

        {

        sdpCodec = iSdpCodecs[ index++ ];

        sdpCodec = sdpCodec->Encodes( aStream ) ? sdpCodec : NULL;

        }

    return sdpCodec;

    }

// ---------------------------------------------------------

// CMceMediaManager::NewL

// ---------------------------------------------------------

 CMceMediaManager* CMceMediaManager::NewL( 

                                    MMceMediaGeneralObserver& aObserver )

    {

    CMceMediaManager* self = NewLC( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------

// CMceMediaManager::NewLC

// ---------------------------------------------------------

 CMceMediaManager* CMceMediaManager::NewLC( 

                                    MMceMediaGeneralObserver& aObserver )

    {

    CMceMediaManager* self = new ( ELeave ) CMceMediaManager;

    CleanupStack::PushL( self );

    self->ConstructL( aObserver );

    return self;

    }

// ---------------------------------------------------------

// CMceMediaManager::~CMceMediaManager

// ---------------------------------------------------------    

 CMceMediaManager::~CMceMediaManager()

    {

    MCEMM_DEBUG("CMceMediaManager::~CMceMediaManager(), Entry ");

    delete iMccSecureInterface;

    iMccSecureInterface=NULL;

    delete iNatPluginManager;

    iNatPluginManager = NULL;

    delete iMccInterface;

    iMccInterface = NULL;

    iMceSdpSessions.ResetAndDestroy();

    iSdpCodecs.ResetAndDestroy();

    iTranscodeSessions.ResetAndDestroy();

    SdpCodecStringPool::Close();

    MCEMM_DEBUG("CMceMediaManager::~CMceMediaManager(), Exit ");

    }   

// ---------------------------------------------------------

// CMceMediaManager::CreateSessionL

// ---------------------------------------------------------    

CMceSdpSession& CMceMediaManager::CreateSessionL( CMceComSession& aSession )

    {

    MCEMM_DEBUG("CMceMediaManager::CreateSessionL(), Entry ");

    CMceSdpSession* sdpSession = CMceSdpSession::NewL( aSession, *this );

    CleanupStack::PushL( sdpSession );

    aSession.AttachSDPSessionL( *sdpSession );

    User::LeaveIfError (iMceSdpSessions.Append( sdpSession ));

    CleanupStack::Pop( sdpSession ); 

    MCEMM_DEBUG("CMceMediaManager::CreateSessionL(), Exit ");

    return *sdpSession;

    }

// ---------------------------------------------------------

// CMceMediaManager::NatMediaManager

// ---------------------------------------------------------    

CMceNatPluginManager& CMceMediaManager::NatPluginManager()

    {

    return *iNatPluginManager;

    }

// ---------------------------------------------------------

// CMceMediaManager::EncodeL

// ---------------------------------------------------------    

CSdpDocument* CMceMediaManager::EncodeL( CMceComSession& aSession )

    {

    MCEMM_DEBUG("CMceMediaManager::EncodeL(), Entry ");

    if ( !SdpSession( aSession ) )

        {

        CreateSessionL( aSession );

        }

	TMceMMState negotationStateId = aSession.NegotiationState().Id();

    MCEMM_DEBUG_STATE( "current state", 

                        negotationStateId );

    CSdpDocument* sdp = aSession.NegotiationState().EncodeL();

    MCEMM_DEBUG("CMceMediaManager::EncodeL(), Exit ");

    return sdp;

    }

// ---------------------------------------------------------

// CMceMediaManager::DecodeL

// ---------------------------------------------------------    

TMceSipWarningCode CMceMediaManager::DecodeL( 

                            CMceComSession& aSession,

                            CSdpDocument& aSdpDocument )

    {

    MCEMM_DEBUG("CMceMediaManager::DecodeL(), Entry ");

    if ( !SdpSession( aSession ) )

        {

        CreateSessionL( aSession );

        }

	TMceMMState negotationStateId = aSession.NegotiationState().Id();

    MCEMM_DEBUG_STATE( "CMceMediaManager::DecodeL(): current state", 

                        negotationStateId );

    TMceSipWarningCode result = 

        aSession.NegotiationState().DecodeL( aSdpDocument );

    MCEMM_DEBUG("CMceMediaManager::DecodeL(), Exit ");

    return result; 

    }

// ---------------------------------------------------------

// CMceMediaManager::UpdateL

// ---------------------------------------------------------    

TMceReturnStatus CMceMediaManager::UpdateL( CMceComSession& aSession )

    {

    MCEMM_DEBUG("CMceMediaManager::UpdateL(), Entry ");

    TMceReturnStatus status = KMceAsync;

    if ( !SdpSession( aSession ) )

        {

        CreateSessionL( aSession );

        }

	TMceMMState negotationStateId = aSession.NegotiationState().Id();

    MCEMM_DEBUG_STATE( "CMceMediaManager::UpdateL(): current state", 

                       negotationStateId );

    aSession.NegotiationState().UpdateL();

    status = !aSession.NegotiationState().CallbackAllowed() ? 

             KMceReady : KMceAsync;

    MCEMM_DEBUG("CMceMediaManager::UpdateL(), Exit ");

    return status;

    }

// ---------------------------------------------------------

// CMceMediaManager::ReserveL

// ---------------------------------------------------------    

TMceReturnStatus CMceMediaManager::ReserveL( CMceComSession& aSession, 

                                             const TDesC8& /*aToken*/ )

    {

    MCEMM_DEBUG("CMceMediaManager::ReserveL(), Entry ");

    TMceReturnStatus status = KMceReady;

    CMceSdpSession* sdpSession = SdpSession( aSession );

    __ASSERT_ALWAYS( sdpSession, User::Leave( KErrNotFound ) );

    MCEMM_DEBUG_STATE_1( "CMceMediaManager::ReserveL(): current state", 

                        aSession );

    if ( sdpSession )

        {

        status = aSession.NegotiationState().ReserveL();

        }

    MCEMM_DEBUG("CMceMediaManager::ReserveL(), Exit ");

    return status;

    }

// ---------------------------------------------------------

// CMceMediaManager::ReservationNeeded

// ---------------------------------------------------------    

TBool CMceMediaManager::ReservationNeeded( CMceComSession& aSession )

    {

    MCEMM_DEBUG("CMceMediaManager::ReservationNeeded(), Entry ");

    TBool reservationNeeded = EFalse;

    CMceSdpSession* sdpSession = SdpSession( aSession );

    MCEMM_DEBUG_STATE_1( "CMceMediaManager::ReservationNeeded(): current state", 

                        aSession );

    if ( sdpSession )

        {

        reservationNeeded = aSession.NegotiationState().ReservationNeeded();

        }

    MCEMM_DEBUG("CMceMediaManager::ReservationNeeded(), Exit ");

    return reservationNeeded;

    }

// ---------------------------------------------------------

// CMceMediaManager::NeedToNegotiate

// ---------------------------------------------------------    

TBool CMceMediaManager::NeedToNegotiate( CMceComSession& aSession,

                                         CSdpDocument* aSdpDocument )

    {

    MCEMM_DEBUG("CMceMediaManager::NeedToNegotiate(), Entry ");

    TBool needToNegotiate = EFalse;

    CMceSdpSession* sdpSession = SdpSession( aSession );

    MCEMM_DEBUG_STATE_1( "CMceMediaManager::NeedToNegotiate(): current state", 

                       aSession );

    if ( sdpSession )

        {

        needToNegotiate = aSession.NegotiationState().NeedToNegotiate( aSdpDocument );

        }

    MCEMM_DEBUG("CMceMediaManager::NeedToNegotiate(), Exit ");

    return needToNegotiate;

    }

// ---------------------------------------------------------

// CMceMediaManager::ConfirmationNeeded

// --------------------------------------------------------- 

//   

TBool CMceMediaManager::ConfirmationNeeded( CMceComSession& aSession )

    {

    MCEMM_DEBUG("CMceMediaManager::ConfirmationNeeded(), Entry ");

    TBool needToNegotiate = EFalse;

    CMceSdpSession* sdpSession = SdpSession( aSession );

    MCEMM_DEBUG_STATE_1( "CMceMediaManager::ConfirmationNeeded(): current state", 

                        aSession);

    if ( sdpSession )

        {

        needToNegotiate = aSession.NegotiationState().ConfirmationNeeded();

        }

    MCEMM_DEBUG("CMceMediaManager::ConfirmationNeeded(), Exit ");

    return needToNegotiate;

    }

// ---------------------------------------------------------

// CMceMediaManager::GetRole

// --------------------------------------------------------- 

//   

TMceNegotiationRole CMceMediaManager::GetRole( CMceComSession& aSession )

	{

	MCEMM_DEBUG("CMceMediaManager::GetRole()");

	return aSession.NegotiationState().Role();

	}

// ---------------------------------------------------------

// CMceMediaManager::CreateRejectedAnswer

// --------------------------------------------------------- 

//   

 void CMceMediaManager::CreateRejectedAnswer( CMceComSession& aSession )

    { 

    MCEMM_DEBUG("CMceMediaManager::CreateRejectedAnswer(), Entry ");

    CMceSdpSession* sdpSession = SdpSession( aSession );

    if( !sdpSession )

        {

        return;

        }

    TRAPD( err, sdpSession->CreateAnswerL( aSession, ETrue ) );

    if( err != KErrNone )

        {

        MCEMM_DEBUG_DVALUE( "CMceMediaManager::CreateRejectedAnswer(): \

ERROR: Creating rejected answer", err );

        iObserver->MediaError( err );

        }

    MCEMM_DEBUG("CMceMediaManager::CreateRejectedAnswer(), Exit ");

    }

// ---------------------------------------------------------

// CMceMediaManager::PauseL 

// ---------------------------------------------------------   

// 

 void CMceMediaManager::PauseL( CMceComMediaSink& aSink )

    {

    MCEMM_DEBUG("CMceMediaManager::PauseL() - sink, Entry ");

    CMceComSession* session = aSink.MediaStream()->Session();

    TMceSrvStreamIterator streams( session->MccStreams(), aSink );

    CMceSrvStream* stream = NULL;

    while( streams.Next( stream ) )

        {

        if ( !stream->Sink().DisableL( *stream ) )

            {

            SynchronizeMccStreamL( *stream, 0, stream->Sink().Id() );

            }

        }

    MCEMM_DEBUG("CMceMediaManager::PauseL() - sink, Exit ");

    }

// ---------------------------------------------------------

// CMceMediaManager::PauseL

// ---------------------------------------------------------  

// 

 void CMceMediaManager::PauseL( CMceComMediaSource& aSource )

    { 

    MCEMM_DEBUG("CMceMediaManager::PauseL() - source, Entry ");

    CMceComSession* session = aSource.MediaStream()->Session();

    TMceSrvStreamIterator streams( session->MccStreams(), aSource );

    CMceSrvStream* stream = NULL;

    while( streams.Next( stream ) )

        {

        if ( !stream->Source().DisableL( *stream ) )

            {

            SynchronizeMccStreamL( *stream, 0, stream->Source().Id() );

            }

        }

    MCEMM_DEBUG("CMceMediaManager::PauseL() - source, Exit ");

    }

// ---------------------------------------------------------

// CMceMediaManager::ResumeL 

// ---------------------------------------------------------    

//

 void CMceMediaManager::ResumeL( CMceComMediaSink& aSink )

    { 

    MCEMM_DEBUG("CMceMediaManager::ResumeL() - sink, Entry ");

    CMceComSession* session = aSink.MediaStream()->Session();

    TMceSrvStreamIterator streams( session->MccStreams(), aSink );

    CMceSrvStream* stream = NULL;

    while( streams.Next( stream ) )

        {

        if ( !stream->Sink().EnableL( *stream ) )

            {

            MCEMM_DEBUG_STREAM( "CMceMediaManager::ResumeL() - sink: \

synchronize stream", *stream );

            SynchronizeMccStreamL( *stream, stream->Sink().Id(), 0 );

            }

        }

    MCEMM_DEBUG("CMceMediaManager::ResumeL() - sink, Exit ");

    }

// ---------------------------------------------------------