/*

* 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 "mcemanager.h"

#include "mceinsessionobserver.h"

#include "mcesessionobserver.h"

#include "mcesession.h"

#include "mcetransactiondatacontainer.h"

#include "mceamrcodec.h"

#include "mceh263codec.h"

#include "mceavccodec.h"

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

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

// CMceManager::NewL

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

//

EXPORT_C CMceManager* CMceManager::NewL(

                        const TUid& aAppUid, 

						TMceTransactionDataContainer* aContainer )

    {

    CMceManager* self = 

        new (ELeave) CMceManager( aAppUid, aContainer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMceManager::~CMceManager

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

//

EXPORT_C CMceManager::~CMceManager()

    {

    if (iContainer)

    	{

    	iContainer->Clear();

    	iContainer = 0;

    	}			

    iSessions.Reset();

    iSessions.Close();

    iSupportedAudioCodecs.ResetAndDestroy();

    iSupportedVideoCodecs.ResetAndDestroy();

    }

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

// CMceManager::SetInSessionObserver

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

//

EXPORT_C void CMceManager::SetInSessionObserver( 

                        MMceInSessionObserver* aInSessionObserver )

    {

    iInSessionObserver = aInSessionObserver;

    }

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

// CMceManager::SetInEventObserver

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

//

EXPORT_C void CMceManager::SetInEventObserver( 

                        MMceInEventObserver* /*aInEventObserver*/ )

    {

    // NOP

    }

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

// CMceManager::SetInReferObserver

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

//

EXPORT_C void CMceManager::SetInReferObserver( 

                        MMceInReferObserver* /*aInReferObserver*/ )

    {

    // NOP

    }

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

// CMceManager::SetSessionObserver

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

//

EXPORT_C void CMceManager::SetSessionObserver( 

                        MMceSessionObserver* aSessionObserver )

    {

    iSessionObserver = aSessionObserver;

    }

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

// CMceManager::SetEventObserver

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

//

EXPORT_C void CMceManager::SetEventObserver( 

                        MMceEventObserver* /*aEventObserver*/ )

    {

    // NOP

    }

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

// CMceManager::SetReferObserver

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

//

EXPORT_C void CMceManager::SetReferObserver( 

                        MMceReferObserver* /*aReferObserver*/ )

    {

    // NOP

    }

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

// CMceManager::SetMediaObserver

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

//

EXPORT_C void CMceManager::SetMediaObserver( 

                        MMceStreamObserver* aMediaObserver )

    {

    iMediaObserver = aMediaObserver;

    }

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

// CMceManager::SetRtpObserver

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

//

EXPORT_C void CMceManager::SetRtpObserver( 

                        MMceRtpObserver* aRtpObserver )

    {

    iRtpObserver = aRtpObserver;

    }

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

// CMceManager::SupportedAudioCodecs

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

//

EXPORT_C const RPointerArray<const CMceAudioCodec>&

                                    CMceManager::SupportedAudioCodecs() const

    {

    return iSupportedAudioCodecs;

    }

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

// 

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

//

EXPORT_C const RPointerArray<const CMceVideoCodec>& 

                                    CMceManager::SupportedVideoCodecs() const

    {

    return iSupportedVideoCodecs;

    }

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

// CMceManager::Sessions

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

//

EXPORT_C const RPointerArray<CMceSession>& CMceManager::Sessions() const

    {

    return iSessions;

    }

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

// CMceManager::SetDefaultHeadersL

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

//

EXPORT_C void CMceManager::SetDefaultHeadersL( CDesC8Array* aMethods, 

                                               CDesC8Array* aHeaders )

    {

    delete aMethods;

    delete aHeaders;

    }

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

// CMceManager::DefaultHeadersL

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

//

EXPORT_C CDesC8Array* CMceManager::DefaultHeadersL( const TDesC8& /*aMethod*/ ) const

    {

    return NULL;

    }

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

// CMceManager::InSessionObserver

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

//

MMceInSessionObserver* CMceManager::InSessionObserver() const

    {

    return iInSessionObserver;

    }

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

// CMceManager::SessionObserver

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

//

MMceSessionObserver* CMceManager::SessionObserver() const

    {

    return iSessionObserver;

    }

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

// CMceManager::MediaObserver

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

//

MMceStreamObserver* CMceManager::MediaObserver() const

    {

    return iMediaObserver;

    }

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

// CMceManager::RtpObserver

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

//

MMceRtpObserver* CMceManager::RtpObserver() const

    {

    return iRtpObserver;

    }

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

// CMceManager::TransactionContainer

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

//

TMceTransactionDataContainer* CMceManager::TransactionContainer() const

	{

	return iContainer;

	}

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

// CMceManager::CMceManager

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

//

CMceManager::CMceManager( const TUid& /*aAppUid*/, 

                        TMceTransactionDataContainer* aContainer )

    :iContainer( aContainer )

    {

    }

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

// CMceManager::ConstructL

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

//

void CMceManager::ConstructL()	

    {

    // Fake having PCMU codec

    iSupportedAudioCodecs.AppendL( CMceAmrCodec::NewLC( KMceSDPNamePCMU() ) );

    CleanupStack::Pop();

    iSupportedAudioCodecs.AppendL( CMceAmrCodec::NewLC( KMceSDPNameAMR() ) );

    CleanupStack::Pop();

    // Avc codec, level default 1

    iSupportedVideoCodecs.AppendL( CMceAvcCodec::NewLC( KMceSDPNameH264() ) );

    CleanupStack::Pop();

    // Avc codec, level default 1, no profile id or constraint set defined

    CMceVideoCodec* avc_2nd_Level_1 = CMceAvcCodec::NewLC( KMceSDPNameH264() );

    avc_2nd_Level_1->SetAllowedBitrates( KMceAvcBitrateLevel1 );

    iSupportedVideoCodecs.AppendL( avc_2nd_Level_1 );

    CleanupStack::Pop( avc_2nd_Level_1 );    

    // Avc codec, level 1_3

    CMceVideoCodec* avcLevel_1_3 = CMceAvcCodec::NewLC( KMceSDPNameH264() );

    avcLevel_1_3->SetAllowedBitrates( KMceAvcCodecProfileIdBaseline | 

	                                  KMceAvcCodecProfileIopConstraintSet | 

	                                  KMceAvcBitrateLevel1_3 );

    iSupportedVideoCodecs.AppendL( avcLevel_1_3 );

    CleanupStack::Pop( avcLevel_1_3 );

    // H263 codec

    iSupportedVideoCodecs.AppendL( CMceH263Codec::NewLC( KMceSDPNameH2632000() ) );

    CleanupStack::Pop();	                                              

    }