/*

* 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 <sdpdocument.h>

#include <MmccInterfacedef.h>

#include "mcemediamanager.h"

#include "mcemediaobserver.h"

#include "mceamrcodec.h"

#include "mcesdpsession.h"

#include "mcemediadefs.h"

#include "mcecommediastream.h"

#include "mcecomaudiostream.h"

#include "mcecomsession.h"

#include "mcecomaudiocodec.h"

#include "mcecomamrcodec.h"

#include "mcecomamrcodec.h"

#include "mcecomh263codec.h"

#include "mcecommediasource.h"

#include "mcecommediasink.h"

#include "mcecomrtpsource.h"

#include "mcecomrtpsink.h"

#include "mcemediasource.h"

#include "mcemediastream.h"

#include "mceaudiostream.h"

#include "mcemicsource.h"

#include "mcertpsource.h"

#include "mcertpsink.h"

#include "mceaudiocodec.h"

#include "mcelogs.h"

#include "cmcetls.h"

#include "mcenatpluginmanager.h"

#include "MCETestHelper.h"

#include "SdpCodecStringPool.h"

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

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

// CMceMediaManager::CMceMediaManager

// C++ default constructor can NOT contain any code, that

// might leave.

// Status : Draft

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

CMceMediaManager::CMceMediaManager()

    {

    }

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

// CMceMediaManager::ConstructL

// Symbian 2nd phase constructor can leave.

// Status : Draft

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

void CMceMediaManager::ConstructL( MMceMediaGeneralObserver& aObserver )

    {  

    iObserver = &aObserver;

    iNatPluginManager = CMceNatPluginManager::NewL();

    }

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

// CMceMediaManager::NewL

// Static constructor.

// Status : Draft

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

CMceMediaManager* CMceMediaManager::NewL( MMceMediaGeneralObserver& aObserver )

    {

    CMceMediaManager* self = NewLC( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMceMediaManager::NewLC

// Static constructor.

// Status : Draft

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

CMceMediaManager* CMceMediaManager::NewLC( MMceMediaGeneralObserver& aObserver )

    {

    CMceMediaManager* self = new ( ELeave ) CMceMediaManager;

    CleanupStack::PushL( self );

    self->ConstructL( aObserver );

    return self;

    }

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

// CMceMediaManager::~CMceMediaManager

// Destructor

// Status : Draft

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

CMceMediaManager::~CMceMediaManager()

    {

    delete iNatPluginManager;

    }   

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

// CMceMediaManager::NatPluginManager

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

CMceNatPluginManager& CMceMediaManager::NatPluginManager()

    {

    return (*iNatPluginManager);    

    }

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

// CMceMediaManager::SendRTCPAnyDataL 

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

// 

void CMceMediaManager::SendRTCPAnyDataL( const CMceComMediaStream& aMediaStream, 

                                         const TDesC8& aData )

    {

    MCE_DEBUG1("CMceMediaManager::SendRTCPAnyDataL");

    MCE_DEBUG6("DATA", aData );

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::ESendRTCPAnyData, &aMediaStream );

        }

    if ( tls )

        {

        User::LeaveIfError( tls->iMediaManagerDecodeStatus );

        }

    }

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

// CMceMediaManager::PauseL 

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

// 

void CMceMediaManager::PauseL( CMceComMediaSink& aSink )

    {

    MCE_DEBUG1("CMceMediaManager::PauseL( sink )");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::EPauseSink, &aSink );

        User::LeaveIfError( tls->LeaveError() );

        }

    }

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

// CMceMediaManager::PauseL

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

// 

void CMceMediaManager::PauseL( CMceComMediaSource& aSource )

    { 

    MCE_DEBUG1("CMceMediaManager::PauseL( source )");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::EPauseSource, &aSource );

        User::LeaveIfError( tls->LeaveError() );      

        }

    }

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

// CMceMediaManager::ResumeL 

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

//

void CMceMediaManager::ResumeL( CMceComMediaSink& aSink )

    { 

    MCE_DEBUG1("CMceMediaManager::ResumeL( sink )");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::EResumeSink, &aSink );

        User::LeaveIfError( tls->LeaveError() );      

        }

    }

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

// CMceMediaManager::ResumeL 

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

//  

void CMceMediaManager::ResumeL( CMceComMediaSource& aSource )

    { 

    MCE_DEBUG1("CMceMediaManager::ResumeL( source )");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::EResumeSource, &aSource );

        User::LeaveIfError( tls->LeaveError() );      

        }

    }

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

// CMceMediaManager::CloseSession

// Closes MCC session and removes the internal sdp session

// Status : Draft

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

TInt CMceMediaManager::CloseSession( CMceComSession& aSession )

    { 

    MCE_DEBUG1("CMceMediaManager::CloseSession");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::ECloseSession, &aSession );

        }

    return KErrNone;

    }

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

// CMceMediaManager::StartInactivityTimerL 

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

//

void CMceMediaManager::StartInactivityTimerL( 

                        const CMceComRtpSource& aRtpSource,

                        TUint32 /*aInactivityTimeout*/ )

    { 

    MCE_DEBUG1("CMceMediaManager::StartInactivityTimerL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::EStartInactivityTimer, &aRtpSource );

        }

    }

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

// CMceMediaManager::StopInactivityTimerL 

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

//

void CMceMediaManager::StopInactivityTimerL( const CMceComRtpSource& aRtpSource )

    { 

    MCE_DEBUG1("CMceMediaManager::StopInactivityTimerL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::EStopInactivityTimer, &aRtpSource );

        }

    }

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

// CMceMediaManager::SendRTCPReceiverReportL 

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

//

void CMceMediaManager::SendRTCPReceiverReportL( const CMceComRtpSource& aRtpSource )

    {

    MCE_DEBUG1("CMceMediaManager::SendRTCPReceiverReportL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::ESendRR, &aRtpSource );

        }

    }

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

// CMceMediaManager::SendRTCPSenderReportL 

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

// 

void CMceMediaManager::SendRTCPSenderReportL( const CMceComRtpSink& aRtpSink )

    { 

    MCE_DEBUG1("CMceMediaManager::SendRTCPSenderReportL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::ESendSR, &aRtpSink );

        }

    }   

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

// CMceMediaManager::SetBalanceL 

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

//

void CMceMediaManager::SetBalanceL( const CMceComMediaSink& aSink, 

                                    TInt /*aBalance*/ )

    { 

    MCE_DEBUG1("CMceMediaManager::SetBalanceL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::ESetBalance, &aSink );

        }

    }  

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

// CMceMediaManager::SetBalanceL 

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

//

void CMceMediaManager::SetBalanceL( const CMceComMediaSource& aSource,

                                    TInt /*aBalance*/ )

    { 

    MCE_DEBUG1("CMceMediaManager::SetBalanceL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::ESetBalance, &aSource );

        }

    }  

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

// CMceMediaManager::GetGainL 

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

//

void CMceMediaManager::GetGainL( const CMceComMediaSource& aSource,

                                 TInt& aGain )

    {

    MCE_DEBUG1("CMceMediaManager::GetGainL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        aGain = 1;

        tls->MediaManagerAction( CMCETls::EGetGain, &aSource );

        }

    }  

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

// CMceMediaManager::SetGainL 

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

//   

void CMceMediaManager::SetGainL( const CMceComMediaSource& aSource,

                                 TInt /*aGain*/ )

    { 

    MCE_DEBUG1("CMceMediaManager::SetGainL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::ESetGain, &aSource );

        }

    }   

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

// CMceMediaManager::SetVolumeL 

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

//   

void CMceMediaManager::SetVolumeL( const CMceComMediaSink& aSink, 

                                  TInt /*aVolume*/ )

    {

    MCE_DEBUG1("CMceMediaManager::SetVolumeL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::ESetVolume, &aSink );

        }

    }

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

// CMceMediaManager::GetVolumeL 

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

//   

void CMceMediaManager::GetVolumeL( const CMceComMediaSink& aSink, 

                                  TInt& aVolume )

    {

    MCE_DEBUG1("CMceMediaManager::GetVolumeL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        aVolume = 1;

        tls->MediaManagerAction( CMCETls::EGetVolume, &aSink );

        }

    }

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

// CMceMediaManager::GetMaxVolumeL 

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

//   

void CMceMediaManager::GetMaxVolumeL( TInt& aMaxVolume )

    {

    MCE_DEBUG1("CMceMediaManager::GetMaxVolumeL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        aMaxVolume = 10;

        tls->MediaManagerAction( CMCETls::EGetMaxVolume, NULL );

        }

    }

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

// CMceMediaManager::SetAudioRoutingL 

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

//           

void CMceMediaManager::SetAudioRoutingL( const CMceComSpeakerSink& aSpeaker, 

                                        TInt /*aRoutingDestination*/ )

    {

    MCE_DEBUG1("CMceMediaManager::SetAudioRoutingL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerAction( CMCETls::ESetAudioRouting, &aSpeaker );

        }

    }

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

// CMceMediaManager::GetAudioRoutingL 

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

//           

void CMceMediaManager::GetAudioRoutingL( const CMceComSpeakerSink& aSpeaker,

                                        TInt& aRoutingDestination )

    {

    MCE_DEBUG1("CMceMediaManager::GetAudioRoutingL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        aRoutingDestination = 1;

        tls->MediaManagerAction( CMCETls::EGetAudioRouting, &aSpeaker );

        }

    }

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

// CMceMediaManager::GetMaxGainL 

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

//           

void CMceMediaManager::GetMaxGainL( TInt& aMaxGain )

    {

    MCE_DEBUG1("CMceMediaManager::GetMaxGainL");

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        aMaxGain = 10;

        tls->MediaManagerAction( CMCETls::EGetMaxGain, NULL );

        }

    }

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

// CMceMediaManager::GetSupportedCodecs 

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

//

TInt CMceMediaManager::GetSupportedCodecs( RArray<TFourCC>& /*aCodecs*/  )

    { 

    TInt err = KErrNone;

    return err;

    }     

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

// CMceMediaManager::GetCapabilities 

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

//  

void CMceMediaManager::GetCapabilitiesL( 

 						RPointerArray<CMceComAudioCodec>& aCapabilities  )

    { 

	CMceComAMRCodec* comcodec = CMceComAMRCodec::NewL( _L8("AMR") );

	CleanupStack::PushL( comcodec );

	aCapabilities.AppendL( static_cast<CMceComAudioCodec*> ( comcodec ) );

	CleanupStack::Pop( comcodec ); 

	comcodec->iSamplingFreq = 100;

	comcodec->iPayloadType = 97;

	comcodec->iBitrate = 3600;

	comcodec->iMaxPTime = 400;

	comcodec->iPTime = 300;

	comcodec->iEnableVAD = EFalse;

    }

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

// CMceMediaManager::GetCapabilities 

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

//  

void CMceMediaManager::GetCapabilitiesL( 

 						RPointerArray<CMceComVideoCodec>& aCapabilities  )

    { 

	CMceComH263Codec* comcodec = CMceComH263Codec::NewL( _L8("H263-2000") );

	CleanupStack::PushL( comcodec );

	aCapabilities.AppendL( static_cast<CMceComVideoCodec*> ( comcodec ) );

	CleanupStack::Pop( comcodec ); 

	comcodec->iPayloadType = 96;

    }

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

// CMceMediaManager::EncodeL

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

CSdpDocument* CMceMediaManager::EncodeL( CMceComSession& aSession )

    {

    MCE_DEBUG1("MediaManager: CMceMediaManager::CreateOfferL() ")

    CSdpDocument* offer = NULL;

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerSdpAction( CMCETls::EEncode, &aSession );

        User::LeaveIfError( tls->LeaveError() );

        offer = MCETestHelper::OfferL();

        }

    return offer;

    }

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

// CMceMediaManager::DecodeL

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

TMceSipWarningCode CMceMediaManager::DecodeL( 

                            CMceComSession& aSession,

                            CSdpDocument& /*aSdpDocument*/ )

    {

    TMceSipWarningCode result = KErrNone;

    CMCETls* tls = CMCETls::Storage();

    if ( tls )

        {

        tls->MediaManagerSdpAction( CMCETls::EDecode, &aSession );

        User::LeaveIfError( tls->LeaveError() );

        result = tls->iMediaManagerDecodeStatus;

        }

    return result;

    }

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