/*

* Copyright (c) 2004-2008 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:    UL/DL Session abstraction for Mcc Subthread clients

*

*/

// INCLUDE FILES

#include <e32math.h>

#include "mcculdlclient.h"

#include "mmccnetworksettings.h"

#include "mccsymsubthreadclient.h"

#include "mcccodecconfigurator.h"

#include "mccsubcontrollerlogs.h"

#include "mccrtpmediaclock.h"

#include "mmccsecureinterface.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CMccUlDlClient::CMccUlDlClient

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

// might leave.

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

CMccUlDlClient::CMccUlDlClient( MMccEventHandler* aMccEventHandler,

                                MMccResources* aMccResources,

                                TUint32 aSessionId ) :

                                iSessionId( aSessionId ),

                                iMccEventHandler( aMccEventHandler ),

                                iMccResources( aMccResources )

    {

    }

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

// CMccUlDlClient::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CMccUlDlClient::ConstructL()

    {

	__SUBCONTROLLER( "CMccUlDlClient::ConstructL" )

    User::LeaveIfNull( iMccEventHandler );

    User::LeaveIfNull( iMccResources );

    iRtpMediaClock = CMccRtpMediaClock::NewL();

	__SUBCONTROLLER( "CMccUlDlClient::ConstructL, exit" )

    }   

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

// CMccUlDlClient::NewL

// Static constructor.

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

EXPORT_C CMccUlDlClient* CMccUlDlClient::NewL( MMccEventHandler* aMccEventHandler,

                                               MMccResources* aMccResources,

                                               TUint32 aSessionId )

    {

    CMccUlDlClient* self = new ( ELeave ) CMccUlDlClient( aMccEventHandler,

                                                          aMccResources,

                                                          aSessionId );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMccUlDlClient::~CMccUlDlClient

// Destructor

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

EXPORT_C CMccUlDlClient::~CMccUlDlClient()

    {

	__SUBCONTROLLER( "CMccUlDlClient::~CMccUlDlClient" )

    iClientArray.ResetAndDestroy();

    iClientArray.Close();

    delete iRtpMediaClock;

	__SUBCONTROLLER( "CMccUlDlClient::~CMccUlDlClient, exit" )

    }

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

// CMccUlDlClient::MaxGainL

// Returns the maximum gain for uplink stream

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

//

EXPORT_C void CMccUlDlClient::MaxGainL( const TUint32 aLinkId, 

										const TUint32 aStreamId,

                                        TInt& aMaxGain )

    {

	__SUBCONTROLLER( "CMccUlDlClient::MaxGainL" )

    TInt stream = FindLinkL( aLinkId );

    aMaxGain = iClientArray[stream]->MaxGainL( aStreamId );

	__SUBCONTROLLER_INT1( "CMccUlDlClient::MaxGainL, exit with MaxGain",

	                      aMaxGain )

    }

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

// CMccUlDlClient::MaxVolumeL

// Returns the mareximum volume for downlink stream

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

//

EXPORT_C void CMccUlDlClient::MaxVolumeL( const TUint32 aLinkId,

										  const TUint32 aStreamId,

                                          TInt& aMaxVolume )

    {

	__SUBCONTROLLER( "CMccUlDlClient::MaxVolumeL" )

    TInt link = FindLinkL( aLinkId );

    aMaxVolume = iClientArray[link]->MaxVolumeL( aStreamId );

	__SUBCONTROLLER_INT1( "CMccUlDlClient::MaxVolumeL, exit with\

MaxVolume", aMaxVolume )

    }

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

// CMccUlDlClient::OpenL

// Opens ul/dl clients

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

//

EXPORT_C void CMccUlDlClient::OpenL( const TUint32 aLinkId,

                                     const TUint32 aStreamId,

                                     TInt aStreamType,

                                     TFourCC aFourCC,

                                     MDataSource* aDataSource, 

                                     MDataSink* aSink,

                                     TMMFPrioritySettings aSettings )

    {

	__SUBCONTROLLER( "CMccUlDlClient::OpenL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid", aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamid", aStreamId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->OpenL( aStreamType, aFourCC,

                               aDataSource, aSink,

                               aStreamId, aSettings );    

	__SUBCONTROLLER( "CMccUlDlClient::OpenL, exit with id" )

    }    

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

// CMccUlDlClient::PrepareL

// Prepare ul/dl client

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

//

EXPORT_C void CMccUlDlClient::PrepareL( const TUint32 aLinkId,

                                        const TUint32 aStreamId,

                                        const TUint32 aEndpointId )

    {

	__SUBCONTROLLER( "CMccUlDlClient::PrepareL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient endpointId",  aEndpointId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->PrepareL( aStreamId, aEndpointId );

	__SUBCONTROLLER( "CMccUlDlClient::PrepareL, exit" )

    }  

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

// CMccUlDlClient::PlayL

// Plays ul/dl stream

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

//

EXPORT_C void CMccUlDlClient::PlayL( const TUint32 aLinkId,

                                     const TUint32 aStreamId,

                                     const TUint32 aEndpointId,

                                     TBool aStreamPaused,

                                     TBool aEnableRTCP )

    {

	__SUBCONTROLLER( "CMccUlDlClient::PlayL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient endpointId",  aEndpointId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->PlayL( aStreamId, aEndpointId, aStreamPaused, aEnableRTCP );

	__SUBCONTROLLER( "CMccUlDlClient::PlayL, exit" )

    }

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

// CMccUlDlClient::PauseL

// Pauses ul/dl stream

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

//

EXPORT_C void CMccUlDlClient::PauseL( const TUint32 aLinkId,

                                      const TUint32 aStreamId,

                                      const TUint32 aEndpointId,

                                      TBool aEnableRTCP )

    {

	__SUBCONTROLLER( "CMccUlDlClient::PauseL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient endpointId",  aEndpointId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->PauseL( aStreamId, aEndpointId, aEnableRTCP );

	__SUBCONTROLLER( "CMccUlDlClient::PauseL, exit" )

    }

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

// CMccUlDlClient::StopL

// Stops ul/dl stream

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

//

EXPORT_C void CMccUlDlClient::StopL( const TUint32 aLinkId,

                                     const TUint32 aStreamId,

                                     const TUint32 aEndpointId )

    {

	__SUBCONTROLLER( "CMccUlDlClient::StopL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient endpointId",  aEndpointId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->StopL( aStreamId, aEndpointId );

	__SUBCONTROLLER( "CMccUlDlClient::StopL, exit" )

    }

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

// CMccUlDlClient::CloseL

// Closes ul/dl client

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

//

EXPORT_C void CMccUlDlClient::CloseL( const TUint32 aLinkId,

                                      const TUint32 aStreamId )    

    {

	__SUBCONTROLLER( "CMccUlDlClient::CloseL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

    TInt linkId = FindLinkL( aLinkId );

    iClientArray[linkId]->CloseL( aStreamId );

	__SUBCONTROLLER( "CMccUlDlClient::CloseL, exit" )

    }

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

// CMccUlDlClient::ResumeL

// Resumes ul/dl stream

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

//

EXPORT_C void CMccUlDlClient::ResumeL( const TUint32 aLinkId,

                                       const TUint32 aStreamId,

                                       const TUint32 aEndpointId,

                                       TBool aEnableRTCP )

    {

	__SUBCONTROLLER( "CMccUlDlClient::ResumeL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient endpointId",  aEndpointId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->ResumeL( aStreamId, aEndpointId, aEnableRTCP );

	__SUBCONTROLLER( "CMccUlDlClient::ResumeL, exit" )

    }    

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

// CMccUlDlClient::ResumeL

// Resumes ul/dl stream

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

//

EXPORT_C TBool CMccUlDlClient::StreamsExistsL( const TUint32 aLinkId )

    {

	__SUBCONTROLLER( "CMccUlDlClient::StreamsExistsL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

    TInt link = FindLinkL( aLinkId );

    return iClientArray[link]->StreamsExistsL();

    }    

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

// CMccUlDlClient::GetGainL

// Get the current ul gain

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

//

EXPORT_C TInt CMccUlDlClient::GetGainL( const TUint32 aLinkId,

                                        const TUint32 aStreamId,

                                        TInt& aGain )

    {

	__SUBCONTROLLER( "CMccUlDlClient::GetGainL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

    TInt link = FindLinkL( aLinkId );

    aGain = iClientArray[link]->GetGainL( aStreamId );

	__SUBCONTROLLER( "CMccUlDlClient::GetGainL, exit" )

    return KErrNone;

    }

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

// CMccUlDlClient::GetCodecL

// Get current codec

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

//

EXPORT_C void CMccUlDlClient::GetCodecL( const TUint32 aLinkId,

                                         const TUint32 aStreamId,

                                         TMccCodecInfo& aCodec )

    {

	__SUBCONTROLLER_INT1( "CMccUlDlClient::GetCodecL linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient::GetCodecL streamId",  aStreamId )

    const TInt link = FindLinkL( aLinkId );

    iClientArray[link]->CodecInformationL( aStreamId, aCodec );

	__SUBCONTROLLER( "CMccUlDlClient::GetCodecL exit" )

    }

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

// CMccUlDlClient::GetFmtpAttrL

// Get current codec

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

//

EXPORT_C void CMccUlDlClient::GetFmtpAttrL( const TUint32 aLinkId,

                                              const TUint32 aStreamId,

                                              TDes8& aFmtp )

    {

	__SUBCONTROLLER( "CMccUlDlClient::GetFmtpAttrL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

    TInt link = this->FindLinkL( aLinkId );

    iClientArray[link]->GetFmtpAttrL( aStreamId, aFmtp );

	__SUBCONTROLLER( "CMccUlDlClient::GetFmtpAttrL, exit" )

    }

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

// CMccUlDlClient::GetPlayBalanceL

// Returns the play balance of dl client 

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

//

EXPORT_C TInt CMccUlDlClient::GetPlayBalanceL( const TUint32 aLinkId,

                                               const TUint32 aStreamId,

                                               TInt& aLeftBalance,

                                               TInt& aRightBalance )

    {

	__SUBCONTROLLER( "CMccUlDlClient::GetPlayBalanceL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->GetBalanceL( aStreamId, aLeftBalance, aRightBalance );

	__SUBCONTROLLER( "CMccUlDlClient::GetPlayBalanceL, exit" )

    return KErrNone;

    }

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

// CMccUlDlClient::GetRecordBalanceL

// Returns the record balance of ul client

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

//

EXPORT_C TInt CMccUlDlClient::GetRecordBalanceL( const TUint32 aLinkId,

                                                 const TUint32 aStreamId,

                                                 TInt& aLeftBalance,

                                                 TInt& aRightBalance )

    {

	__SUBCONTROLLER( "CMccUlDlClient::GetRecordBalanceL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->GetBalanceL( aStreamId, aLeftBalance, aRightBalance );

	__SUBCONTROLLER( "CMccUlDlClient::GetRecordBalanceL, exit" )

    return KErrNone;

    }

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

// CMccUlDlClient::SetPriorityL

// Sets the link priority

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

//

EXPORT_C TInt CMccUlDlClient::SetPriorityL( const TUint32 aLinkId,

                                            const TUint32 aStreamId,

                                            TMMFPrioritySettings aPrioritySettings )

    {

	__SUBCONTROLLER( "CMccUlDlClient::SetPriorityL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->SetPrioritySettingsL( aStreamId, aPrioritySettings );

	__SUBCONTROLLER( "CMccUlDlClient::SetPriorityL, exit" )

    return KErrNone;

    }   

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

// CMccUlDlClient::SetVolumeL

// Sets the volume for downlink stream

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

//

EXPORT_C TInt CMccUlDlClient::SetVolumeL( TInt aVolume )

    {

	__SUBCONTROLLER( "CMccUlDlClient::GetRecordBalanceL" )

    TInt indexCount = iClientArray.Count();      

    TInt err = KErrNone;

    TInt i = 0;

     for ( i = 0 ;  i < indexCount ; i++ )

        { 

        iClientArray[i]->SetVolumeL( aVolume );

        }

	__SUBCONTROLLER( "CMccUlDlClient::GetRecordBalanceL, exit" )

    return err;

    }

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

// CMccUlDlClient::SetGainL

// Sets the gain for uplink stream

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

//

EXPORT_C TInt CMccUlDlClient::SetGainL( TInt aGain )

    {

	__SUBCONTROLLER( "CMccUlDlClient::SetGainL" )

    TInt indexCount = iClientArray.Count();

    TInt err = KErrNone;

    TInt i = 0;

    for ( i = 0 ;  i < indexCount ; i++ )

        { 

        iClientArray[i]->SetGainL( aGain );

        }

	__SUBCONTROLLER( "CMccUlDlClient::SetGainL, exit" )

    return err;

    }

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

// CMccUlDlClient::SetRecordBalanceL

// Set the record balance for uplink stream

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

//

EXPORT_C void CMccUlDlClient::SetRecordBalanceL( const TUint32 aLinkId,

                                                 const TUint32 aStreamId, 

                                                 TInt aLeftBalance, 

                                                 TInt aRightBalance )

    {

	__SUBCONTROLLER( "CMccUlDlClient::SetRecordBalanceL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->SetBalanceL( aStreamId, aLeftBalance, aRightBalance );

	__SUBCONTROLLER( "CMccUlDlClient::SetRecordBalanceL, exit" )

    }

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

// CMccUlDlClient::SetPlayBalanceL

// Set the record balance for downlink stream

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

//

EXPORT_C void CMccUlDlClient::SetPlayBalanceL( const TUint32 aLinkId, 

                                               const TUint32 aStreamId, 

                                               TInt aLeftBalance, 

                                               TInt aRightBalance )

    {

	__SUBCONTROLLER( "CMccUlDlClient::SetPlayBalanceL" )

	__SUBCONTROLLER_INT1( "CMccUlDlClient linkid",  aLinkId )

	__SUBCONTROLLER_INT1( "CMccUlDlClient streamId",  aStreamId )

    TInt link = FindLinkL( aLinkId );

    iClientArray[link]->SetBalanceL( aStreamId, aLeftBalance, aRightBalance );

	__SUBCONTROLLER( "CMccUlDlClient::SetPlayBalanceL, exit" )

    }

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

// CMccUlDlClient::CreateLinkL

// Creates link, 1st step in link creation

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

//

EXPORT_C void CMccUlDlClient::CreateLinkL( TUint32& aLinkId,

                                           TInt aType )

    {

	__SUBCONTROLLER( "CMccUlDlClient::CreateLinkL" )

	TInt err( KErrNone );

    switch ( aType )

        {

        case KMccLinkGeneral:

        case KMccLinkGeneralVideo:

            {

            CMccSymSubthreadClient* symClient = 

                CMccSymSubthreadClient::NewL( this, iMccResources, aType, iSessionId );

            err = StoreLink( symClient );

            if ( err == KErrNone )

                {

                aLinkId = reinterpret_cast<TUint32>( symClient );

                symClient->SetLinkId( aLinkId );

                }

            else

                {

                delete symClient;

                }

            break;

            }