/*

* Copyright (c) 2002-2003 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 "rtpmanager.h"

#include <utf.h>

// CONSTANTS

// Refer to RFC 1889

// The comparison in rates between NTP timestamp and RTP timestamp.

// A value of n means that each increment of an RTP timestamp

// corresponds to n microseconds.

//

const TUint8 KRtpPayloadClockConversions[KRtpMaxPayloadTypes] =

    {

    125, 125, 125, 125, 125, 125, 63, 125, 125, 63, // 0-9 

    23, 23, 125, 125, 11, 125, 91, 45, 125, 0,      // 10-19

    0, 0, 0, 0, 0, 11, 11, 0, 11, 0,                // 20-29

    0, 11, 11, 11, 11, 0, 0, 0, 0, 0,               // 30-39

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                   // 40-49

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                   // 50-59

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                   // 60-69

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                   // 70-79

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                   // 80-89

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                   // 90-99

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                   // 100-109

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,                   // 110-119

    0, 0, 0, 0, 0, 0, 0, 0                          // 120-127

    };

const TInt TArrayStore::iOffset = _FOFF( TArrayStore, iMagicKey );

const TInt KBufLength = 64;

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

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

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

// might leave.

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

//

CRtpManager::CRtpManager( MRtpErrNotify& aErrNotify ) 

    : iStandardRtp( ETrue ), 

      iEnableRtcp( EFalse ),

      iSocketServPtr( NULL ), 

      iConnPtr( NULL ), 

      iNumOfObjects( 0 ),

      iErrNotify( aErrNotify )

    {

    for ( TUint k = 0; k < KRtpMaxPayloadTypes; k++ )

        {

        iProfileRTPTimeRates[k] = ( TUint32 ) KRtpPayloadClockConversions[k];

        }

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CRtpManager::ConstructL()

    {

    // instantiate RTP session array

    iSessionArray = new ( ELeave ) CArrayFixFlat<TArrayStore>( 2 );

    }

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

// Two-phased constructor.

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

//

CRtpManager* CRtpManager::NewL( MRtpErrNotify& aErrNotify )

    {

    CRtpManager* self = new ( ELeave ) CRtpManager( aErrNotify );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // self

    return self;

    }

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

// Destructor

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

//

CRtpManager::~CRtpManager( void )

    {

    RTP_DEBUG_DETAIL( "CRtpManager::~CRtpManager" );

    Close();

    delete iSessionArray;

    if ( iDefaultSdes )

        {

        delete iDefaultSdes;

        iDefaultSdes = NULL;

        }

    iSocketServPtr = NULL;

    iConnPtr = NULL;

    }

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

// TInt CRtpManager::OpenL()

// Return error code

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

//

TInt CRtpManager::OpenL( const TRtpSdesParams& aSdesInfo, 

                         const TDesC* aRtpPacketDll,

                         RSocketServ* aSocketServPtr,

                         RConnection* aConnPtr )

    {

    RTP_DEBUG_DETAIL( "***********************************" );

    RTP_DEBUG_DETAIL( "***       OPENING NEW API       ***" );

    RTP_DEBUG_DETAIL( "***********************************" );

    RTP_DEBUG_DETAIL( "CRtpManager::OpenL" );

    TInt err( KErrNone );

    iDefaultSdes = CRtpSDES::NewL( aSdesInfo );

    if ( aSocketServPtr )

        {

        iSocketServPtr = aSocketServPtr;

        }

    else

        {

        iSocketServPtr = &iSocketServ;

        }

    if ( aConnPtr )

        {

        iConnPtr = aConnPtr;

        }

    else

        {

        iConnPtr = &iConn;

        }

    //compare string to default DLL names, if string is "", then load default

    if ( !aRtpPacketDll )

        {

        // Use standard RTP

        iStandardRtp = ETrue;

        }

    else

        {

        // Dynamically load the specified DLL

        err = iLibrary.Load( *aRtpPacketDll );

        if ( err )

            {

            RTP_DEBUG_DETAIL( "CRtpManager::OpenL: error loading DLL" );

            User::Leave( err );

            }

        iStandardRtp = EFalse;

        }

    return err;

    }

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

// TInt CRtpManager::StartConnection()

// Starts the connection synchronously

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

//

TInt CRtpManager::StartConnection( TInt aIapId )

    {

    RTP_DEBUG_DETAIL( "CRtpManager::StartConnection (sync)" );

    TInt error( PrepareConnection( iPrefs, aIapId ) );

    if ( error != KErrNone )

        {

        return error;

        }

    error = iConnPtr->Start( iPrefs );

    if ( error != KErrNone )

        {

        iConnPtr->Close();

        iSocketServPtr->Close();

        RTP_DEBUG_DETAIL_DVALUE( "Error starting connection: ", error );

        }

    else

        {

        iIapId = aIapId;

        }

    return error;

    }

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

// TInt CRtpManager::StartConnection()

// Starts the connection asynchronously

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

//

TInt CRtpManager::StartConnection( TRequestStatus& aStatus, TInt aIapId )

    {

    RTP_DEBUG_DETAIL( "CRtpManager::StartConnection (async)" );

    TInt error( PrepareConnection( iPrefs, aIapId ) );

    if ( error != KErrNone )

        {

        return error;

        }

    iIapId = aIapId;

    iConnPtr->Start( iPrefs, aStatus );

    RTP_DEBUG_DETAIL( "Start request sent" );

    return KErrNone;

    }

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

// TInt CRtpManager::PrepareConnection()

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

//

TInt CRtpManager::PrepareConnection( TCommDbConnPref& aPrefs, TInt aIapId )

    {

    RTP_DEBUG_DETAIL( "CRtpManager::PrepareConnection"  );

    TInt err( KErrCouldNotConnect );

    if ( aIapId != KUseDefaultIap )

        {

	    aPrefs.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

        aPrefs.SetIapId( aIapId );

        }

    aPrefs.SetDirection( ECommDbConnectionDirectionOutgoing );

    err = iSocketServPtr->Connect();

    if ( err != KErrNone )

        {

        iSocketServPtr->Close();

        RTP_DEBUG_DETAIL_DVALUE( "Error opening socket server: " , err );

        return err;

        }

    err = iConnPtr->Open( *iSocketServPtr );

    if ( err != KErrNone )

        {

        iConnPtr->Close(); 

        iSocketServPtr->Close();

        RTP_DEBUG_DETAIL_DVALUE( "Error opening connection: " , err );

        return err;

        }

    return KErrNone;

    }

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

// CRtpManager::CancelStart()

// Cancels the asynchoronous start of the connection. 

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

//

void CRtpManager::CancelStart()

    {

    if ( iConnPtr )

        {

        iConnPtr->Close(); 

        }

    if ( iSocketServPtr )

        {

        iSocketServPtr->Close();

        }

    }

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

// CRtpManager::Close()

// Close rtp manager 

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

//

void CRtpManager::Close( void )

    {

    RemoveRtpAllObjects();

    if ( !iStandardRtp )

        {

        iLibrary.Close();

        }

    RTP_DEBUG_DETAIL( "CRtpManager::Close -- Closing RConnection"  );

    RTP_DEBUG_DETAIL( "CRtpManager::Close -- Closing Socket Server" );

    if ( iConnPtr )

        {

        iConnPtr->Close();

        }

    if ( iSocketServPtr )

        {

        iSocketServPtr->Close();

        }

    iConnected = EFalse;

    }

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

// CRtpManager::SetLocalSdes()

// Set local sdes

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

//

void CRtpManager::SetLocalSdes( const TRtpSdesParams& aSdesInfo )

    {

    iDefaultSdes->SetSDES( aSdesInfo );

    }

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

// TInetAddr& CRtpManager::GetLocalIPAddressL()

// return local IP address

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

//

TInetAddr& CRtpManager::GetLocalIPAddressL()

    {

    RTP_DEBUG_DETAIL( "CRtpManager::GetLocalIPAddress" );

 	TUint32 iapId;

    if ( iIapId == 0 )

        {

        RTP_DEBUG_DETAIL( "Error: IAP not set (=0)" );

        User::Leave( KErrNotSupported );

        }

    if ( iIapId < 0 )

        {

        User::LeaveIfError( GetIapId( iapId ) );

        }

    else

        {

        iapId = static_cast<TUint32>( iIapId );

        }

    CLocalAddrResolver* localAddressResolver = 

        CLocalAddrResolver::NewLC( *iSocketServPtr );

    localAddressResolver->GetLocalAddrL( iLocalAddr, iapId );

    CleanupStack::PopAndDestroy( localAddressResolver );

    return iLocalAddr;

    }

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

// TRtpId CRtpManager::CreateSessionL()

// Return session id 

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

//

TRtpId CRtpManager::CreateSessionL( const TCreateSessionParams& aSessionParams,

                                    TUint& aPort,

                                    TBool aEnableRtcp,

                                    const TRtcpParams* aRtcpParams )

    {

    RTP_DEBUG_DETAIL( "CRtpManager::CreateSessionL" );

    TInt err( KErrNone );

    // dont allow following combination: STP with RTCP

    if ((!iStandardRtp) && aEnableRtcp)

        User::Leave(KErrNotSupported);

    const TRtpId sessionId = AssignUniqueID();

    iEnableRtcp = aEnableRtcp;

	CheckSdesCName();

    CRtpSession* newSession = CRtpSession::NewL( aSessionParams,

                                                 aPort,

                                                 aEnableRtcp,

                                                 aRtcpParams,

                                                 *iSocketServPtr,

                                                 *iConnPtr,

                                                 sessionId,

                                                 iDefaultSdes,

                                                 iProfileRTPTimeRates,

                                                 iStandardRtp,

                                                 iLibrary,

                                                 iErrNotify,

                                                 *this );

    // add RTP Session to the server list 

    TArrayStore arrayData( sessionId, ( TUint ) newSession, ESession );

    err = AddRtpObject( arrayData );

    if ( err != KErrNone )

        {

        RTP_DEBUG_DETAIL_DVALUE( "Session creation failed with error = ", err );

        delete newSession;

        return KNullId;

        }

    RTP_DEBUG_DETAIL_DVALUE( "Session created with ID ", sessionId );

    return sessionId;

    }

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

// TRtpId CRtpManager::CreateSessionL()

// Return session id 

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

//

TRtpId CRtpManager::CreateSessionL( const TCreateSessionParams& aSessionParams,

                                    TUint& aPort,

                                    TBool aEnableRtcp,

                                    const TRtcpParams* aRtcpParams,

                                    CSRTPSession& aSRTPSession  )

    {

    RTP_DEBUG_DETAIL( "CRtpManager::CreateSessionL" );

    TInt err( KErrNone );

    // dont allow following combination: STP with RTCP

    if ((!iStandardRtp) && aEnableRtcp)

        User::Leave(KErrNotSupported);

    const TRtpId sessionId = AssignUniqueID();

    iEnableRtcp = aEnableRtcp;

	CheckSdesCName();

    CRtpSessionSrtp* newSession = CRtpSessionSrtp::NewL( aSessionParams,

                                                 aPort,

                                                 aEnableRtcp,

                                                 aRtcpParams,

                                                 *iSocketServPtr,

                                                 *iConnPtr,

                                                 sessionId,

                                                 iDefaultSdes,

                                                 iProfileRTPTimeRates,

                                                 iStandardRtp,

                                                 iLibrary,

                                                 iErrNotify,

                                                 *this,

												 aSRTPSession);

    // add RTP Session to the server list 

    TArrayStore arrayData( sessionId, ( TUint ) newSession, ESession );

    err = AddRtpObject( arrayData );

    if ( err != KErrNone )

        {

        RTP_DEBUG_DETAIL_DVALUE( "Session creation failed with error = ", err );

        delete newSession;

        return KNullId;

        }

    RTP_DEBUG_DETAIL_DVALUE( "Session created with ID ", sessionId );

    return sessionId;

    }

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

// TInt CRtpManager::StartSession()

// Start session, including starting rtp receiving and rtcp sending/receiving

// if RTCP is enabled. 

// Return KErrNone if successful; KErrNotFound otherwise

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

//

TInt CRtpManager::StartSession( TRtpId aSessionId )

    {

    RTP_DEBUG_DETAIL( "CRtpManager::StartSession entry"  );

    CRtpSession* session = GetSession( aSessionId );

    if ( session )

        {

        RTP_DEBUG_DETAIL( "CRtpManager::StartSession exit"  );

        return session->StartSession();

        }

    RTP_DEBUG_DETAIL( "Session not found" );

    return KErrNotFound;

    }

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

// CRtpManager::CloseSession()

// Close session. Delete all streams inside the session. 

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

//

void CRtpManager::CloseSession( TRtpId aSessionId )

    {

    RTP_DEBUG_DETAIL( "CRtpManager::CloseSession" );

    TInt result( RemoveRtpObject( aSessionId, ESession ) );

    if ( result == KErrNone )

        {

        RTP_DEBUG_DETAIL_DVALUE( "CRtpManager::CloseSession, Removed session with ID = ",

                  aSessionId );

        }

    else

        {

        RTP_DEBUG_DETAIL( "CRtpManager::CloseSession, Session not found"  );

        }

    }

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

// TInt CRtpManager::SetRemoteAddress()

// Set remote IP addresses and port numbers for RTP and RTCP. 

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

//

TInt CRtpManager::SetRemoteAddress( TRtpId aSessionId, TInetAddr& aRemoteAddr )

    {

    CRtpSession* session = GetSession( aSessionId );

    TInt result( KErrNotFound );

    if ( session )

        {

        result = session->SetRemoteAddress( aRemoteAddr );

        }

    else

        {

        RTP_DEBUG_DETAIL( "CRtpManager::SetRemoteAddress, Session not found" );

        }

    return result;

    }

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