/*

* Copyright (c) 2004-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:    RTP Manager

*

*/

// INCLUDE FILES

#include <srtpsession.h>

#include "mccrtpmanager.h"

#include "mccinternalcodecs.h"

#include "mccrtpdatasink.h"

#include "mccrtpdatasource.h"

#include "mmccevents.h"

#include "mccsubcontrollerlogs.h"

#include "mccrtcpreceiver.h"

#include "mccrtpkeepalivecontainer.h"

#include "mccresources.h"

#include "mccqoshandler.h"

#include "mccinternaldef.h"

// LOCAL CONSTANTS AND MACROS

// Default IP type-of-service value.

const TInt KDefaultIpTOS = 184;

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

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

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

// CMccRtpManager::CMccRtpManager

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

// might leave.

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

//

CMccRtpManager::CMccRtpManager( 

    MAsyncEventHandler& aHandler, 

    MMccResources& aMccResources,

    TUint32 aMccSessionId ) : 

    iRtpSessionId( KNullId ), 

    iStreamArray( RArray<TRtpId>() ), 

    iEventHandler( aHandler ),

    iMccResources( aMccResources ),

    iIpTOS( KDefaultIpTOS ), 

    iLocalPort( KDefaultRtpPort ),

    iMccSessionId( aMccSessionId ),

    iDummyRcvStreamId( KNullId )

    {

    }

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

// CMccRtpManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccRtpManager::ConstructL()

    {

    __SUBCONTROLLER( "CMccRtpManager::ConstructL" )

    iRtpApi = CRtpAPI::NewL( *this );

    iRtcpReceiver = CMccRtcpReceiver::NewL( this, iEventHandler, iMccResources, *iRtpApi );

    iQosHandler = CMccQosHandler::NewL( *this );

    __SUBCONTROLLER( "CMccRtpManager::ConstructL exit" )

    }

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

// CMccRtpManager::NewL

// Static constructor.

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

//

CMccRtpManager* CMccRtpManager::NewL( 

    MAsyncEventHandler& aHandler,

    MMccResources& aMccResources,

    TUint32 aMccSessionId

    )

    {

    CMccRtpManager* self = new (ELeave) CMccRtpManager( aHandler, aMccResources, 

                                                        aMccSessionId );

    CleanupStack::PushL( self );      

    self->ConstructL();           

    CleanupStack::Pop( self );

    return self;

    }

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

// CMccRtpManager::~CMccRtpManager

// Destructor

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

//

CMccRtpManager::~CMccRtpManager()

    {

    __SUBCONTROLLER( "CMccRtpManager::~CMccRtpManager" )

    delete iRtcpReceiver;

    delete iRtpKeepaliveMechanism;

    if ( KNullId != iDummyRcvStreamId && iRtpApi )

        {

        iRtpApi->CloseStream( iDummyRcvStreamId );

        }

    if( KNullId != iRtpSessionId && iRtpApi )

        {

        iRtpApi->CloseSession( iRtpSessionId );

        iRtpApi->Close();

        }

    delete iSecSession;

    delete iRtpApi;

    delete iQosHandler;

    iStreamArray.Close();

    delete iCName;

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

    }

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

// CMccRtpManager::CreateSessionL

// Creates RTP session and adds session to SessionArray

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

//

void CMccRtpManager::CreateSessionL( 

    TUint& aPort, 

    TBool aEnableRTCP,

    TBool aSecurity, 

    TBool aIncreaseDefaultSocketSize )

    {

    __SUBCONTROLLER( "CMccRtpManager::CreateSessionL" )

    if( KNullId != iRtpSessionId )

        {

        User::Leave( KErrAlreadyExists );

        }

    TCreateSessionParams params;    

    params.iPriority = TCreateSessionParams::EPriorityStandard;    

    aEnableRTCP = ETrue;

    if ( aIncreaseDefaultSocketSize )

        {

        params.iSocketBufSize = KMccIncreasedRtpSocketSize;

        }

    __SUBCONTROLLER_INT1( "CMccRtpManager::CreateSessionL, socket size:", 

                          params.iSocketBufSize )

    TInetAddr localAddress = iRtpApi->GetLocalIPAddressL();

    if ( aSecurity )

        {

        iSecSession = CSRTPSession::NewL( localAddress );

        iRtpSessionId = iRtpApi->CreateSessionL( params, aPort, aEnableRTCP,

                                                 NULL, *iSecSession );

        }

    else

        {

        iRtpSessionId = iRtpApi->CreateSessionL( params, aPort, aEnableRTCP, NULL );

        }

    if( KNullId == iRtpSessionId )

        {

        User::Leave( KErrCouldNotConnect );

        }

    __ASSERT_ALWAYS( !iRtpKeepaliveMechanism, User::Leave( KErrAlreadyExists ) );     

    iRtpKeepaliveMechanism = 

        CMccRtpKeepaliveContainer::NewL( iEventHandler, 

                                         *iRtpApi, 

                                         iRtpSessionId );

    iLocalPort = aPort;

    iRtcpEnabled = aEnableRTCP;

    __SUBCONTROLLER( "CMccRtpManager::CreateSessionL, keepalive initialized" )

    iRtcpReceiver->HandleReceiving( iRtpSessionId, iRtcpEnabled );

    __SUBCONTROLLER( "CMccRtpManager::CreateSessionL, exit" )

    }

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

// CMccRtpManager::CloseSession

// Closes RTP session

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

//

void CMccRtpManager::CloseSession()

    {

    __SUBCONTROLLER( "CMccRtpManager::CloseSession" )

    if ( KNullId != iRtpSessionId ) 

        {

        if ( iRtpKeepaliveMechanism )

            {

            iRtpKeepaliveMechanism->StopAll();

            }

        iRtpApi->CloseSession( iRtpSessionId );

        iRtpApi->Close();

        iStreamArray.Reset();

        iRtpSessionId = KNullId;

        if ( iQosHandler->QoSEnabled() )

            {

            iQosHandler->DisableQoS();

            }

        }

    __SUBCONTROLLER( "CMccRtpManager::CloseSession, exit" )

    }

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

// CMccRtpManager::GetRtpReference

// Returns RTPApi reference

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

//

CRtpAPI* CMccRtpManager::GetRtpReferenceL( )

    {

    if ( !IsOpen() ) 

        {

        User::Leave( KErrNotFound );

        }

    return iRtpApi;

    }

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

// CMccRtpManager::SetRemoteAddress

// Sets RTP Remote Address

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

//

TInt CMccRtpManager::SetRemoteAddress( const TInetAddr& aRemoteAddress )

    {

    __SUBCONTROLLER( "CMccRtpManager::SetRemoteAddress" )

    TInt err( KErrNotFound );

    if ( KNullId != iRtpSessionId ) 

        {   

        // Do only if address has changed

        err =( iRemoteAddress.Address() == aRemoteAddress.Address() && 

               iRemoteAddress.Port() == aRemoteAddress.Port() ) ? KErrNone : err;

        if ( err )

            { 

            __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, setting addr:", 

                                  aRemoteAddress.Address() )

            __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, setting port:", 

                                  aRemoteAddress.Port() )

            err = iRtpApi->SetRemoteAddress( iRtpSessionId, aRemoteAddress );

            if ( !err )

                {

                iRemoteAddress.SetAddress( aRemoteAddress.Address() );

                iRemoteAddress.SetPort( aRemoteAddress.Port() );

                if ( iRtpKeepaliveMechanism )

                    {

                    err = iRtpKeepaliveMechanism->RemoteAddressSet();

                    }

                }

            }

        }

    __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, exit with err", err )

    return err;

    }

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

// CMccRtpManager::SetRemoteRtcpAddress

// Sets RTP Remote Address

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

//

TInt CMccRtpManager::SetRemoteRtcpAddr( const TInetAddr& aRemoteAddress )

    {

    __SUBCONTROLLER( "CMccRtpManager::SetRemoteRtcpAddress" )

    TInt err( KErrNotFound );

    if ( KNullId != iRtpSessionId ) 

        {   

        // Do only if address has changed

        err =( iRemoteRtcpAddr.Address() == aRemoteAddress.Address() && 

               iRemoteRtcpAddr.Port() == aRemoteAddress.Port() ) ? KErrNone : err;

        __SUBCONTROLLER_INT1( "Remote RtcpPort", aRemoteAddress.Port() )

        __SUBCONTROLLER_INT1( "Saved Remote RtcpPort", iRemoteAddress.Port() )

        if ( err )

            { 

            __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, setting addr:", 

                                  aRemoteAddress.Address() )

            __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, setting port:", 

                                  aRemoteAddress.Port() )

            err = iRtpApi->SetRemoteRtcpAddress( iRtpSessionId, aRemoteAddress );

            if ( !err )

                {

                iRemoteRtcpAddr.SetAddress( aRemoteAddress.Address() );

                iRemoteRtcpAddr.SetPort( aRemoteAddress.Port() );

                __SUBCONTROLLER_INT1( "Remote RtcpPort", aRemoteAddress.Port() )

                }

            }

        }

    __SUBCONTROLLER_INT1( "CMccRtpManager::SetRemoteAddress, exit with err", err )

    return err;

    }

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

// CMccRtpManager::SetIpTOS

// Sets TOS flag, must be called before StartSession

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

//

void CMccRtpManager::SetIpTOS( TInt aIpTOS ) 

    {

    iIpTOS = aIpTOS;

    }

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

// CMccRtpManager::StartSession

// Starts RTP session

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

//

void CMccRtpManager::StartSessionL()

    {

    __SUBCONTROLLER( "CMccRtpManager::StartSessionL" )

    if ( KNullId != iRtpSessionId ) 

        {

        __SUBCONTROLLER( "CMccRtpManager::StartSessionL, session exists" )

		RSocket* socketPtr = iRtpApi->GetRtpSocket( iRtpSessionId );

		if( !socketPtr )

		    {

		    __SUBCONTROLLER( "CMccRtpManager::StartSessionL, no socket!" )

            #ifdef TEST_EUNIT            

            // The stub for RTP API returns a NULL socket pointer. Just pretend

            // everything is fine.

            return;            

            #else

		    User::Leave( KErrNotReady );

            #endif

		    }

		else

		    {

            User::LeaveIfError( iRtpApi->StartSession( iRtpSessionId ) );      

            __SUBCONTROLLER_INT1( "CMccRtpManager::StartSessionL, iptos:", iIpTOS )

            User::LeaveIfError( socketPtr->SetOpt( KSoIpTOS, KSolInetIp, iIpTOS ) );

            User::LeaveIfError( socketPtr->SetOpt( KSoUdpReceiveICMPError, KSolInetUdp, 1 ) );

            if ( !iQosHandler->QoSEnabled() )

                {

                // These has to be set before enabling QoS

                iQosHandler->SetSubConnectionParams( iConnection,

                                             iSocketServ,

                                             *socketPtr );

                // If we cannot enable QoS for some reason, we should not

                // consider it as a fatal error. If error happens, then

                // disable qos. This will clean up some unneeded resources.

                // Also this leads to retries when streams are created.

                TRAPD( err, iQosHandler->EnableQosL() );

                if ( KErrNone != err )

                    {

                    __SUBCONTROLLER_INT1( "CMccRtpManager::StartSessionL QOS:", err )

                    iQosHandler->DisableQoS();

                    }

                }

		    }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    __SUBCONTROLLER( "CMccRtpManager::StartSessionL, exit" ) 

    }

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

// CMccRtpManager::Initialize

// Opens RTPApi and starts connection

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

//

void CMccRtpManager::InitializeL( TRequestStatus& aStatus, TInt aIapId )

    {

    TInt err = iRtpApi->OpenL( iRtpSdes, NULL, &iSocketServ, &iConnection );

    if ( KErrNone == err ) 

        {

        User::LeaveIfError( iRtpApi->StartConnection( aStatus, aIapId ) );

        }

    else

        {

        User::Leave( err );

        }

    }

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

// CMccRtpManager::CheckStreamExists

// Checks that stream exists

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

//

TBool CMccRtpManager::CheckStreamExists( const TRtpId& aStreamId ) const

    {

    TInt index = iStreamArray.Find( aStreamId );

    if( KErrNotFound == index )

        {

        return EFalse;

        }

    else

        {

        return ETrue;

        }

    }

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

// CMccRtpManager::IsOpen

// Checks that RTPApi is opened

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

//

TBool CMccRtpManager::IsOpen() const

    {

    if ( iRtpApi->GetRtpSocket( iRtpSessionId ) ) 

        {

        return ETrue;

        }

    else 

        {

        return EFalse;

        }

    }

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

// CMccRtpManager::RemoveStreamFromArray

// Removes RTP stream from stream array

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

//

void CMccRtpManager::RemoveStreamFromArray( const TRtpId& aStreamId )

    {

    const TInt index( iStreamArray.Find( aStreamId ) );

    if( KErrNotFound != index )

        {

        iStreamArray.Remove( index );

        }

    }

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

// CMccRtpManager::SessionId

// Returns the Session ID for this object

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

//

TRtpId CMccRtpManager::SessionId() const

    {

    return iRtpSessionId;

    }

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

// CMccRtpManager::ErrorNotify

// Error callback.

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

//

void CMccRtpManager::ErrorNotify( TInt aErrCode )

    {

    if ( KErrNone != aErrCode )

        {

        __SUBCONTROLLER_INT1( "CMccRtpManager::ErrorNotify, error", aErrCode )

        // Report all errors coming from here as rtp category stream errors

        // In HW when remote end drops from network, this function will be

        // called with KErrHostUnreach (-191) and in some cases this will return

        // as KErrGeneral with DTMF's. KErrCouldNotConnect error is received in

        // ICMP port unreachable situation. In these cases, handle just the 

        // KErrHostUnreach and KErrCouldNotConnect.

        if ( KErrHostUnreach == aErrCode || KErrCouldNotConnect == aErrCode )

            {

            TMccEvent event;

            event.iErrorCode = KErrHostUnreach;

            event.iEventCategory = KMccEventCategoryRtp;

            event.iEventType = KMccStreamError;

            // Use whatever internal uid

            TMccInternalEvent internalEvent( KMccRtpSourceUid, 

                                     EMccInternalEventNone,

                                     event );

            iEventHandler.SendEventToClient( internalEvent );

            }

        }

    }

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

// CMccRtpManager::CreateTransmitStreamL

// Creates a new transmit stream based on given parameters

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

//

TUint32 CMccRtpManager::CreateTransmitStreamL( MDataSink& aSink, 

    const TMccCodecInfo& aCodecInfo )

    {

    TUint32 streamId( 0 );

    if( aCodecInfo.iPayloadType < KMccPayloadTypeMax )

        {

        CMccRtpDataSink& dSink = static_cast<CMccRtpDataSink&>( aSink );

        TMccRtpSessionParams sessParams( iRtpApi, 

                                         iRtpSessionId, 

                                         iRtcpEnabled, 

                                         iRtpKeepaliveMechanism,

                                         iSecSession );

        dSink.SetSessionParamsL( sessParams );

        TMccCodecInfoBuffer infoBuffer( aCodecInfo );

        UpdateL( &aCodecInfo );

        }

    else

        {

        User::Leave( KErrArgument );

        }

    return streamId;

    }