/*

* Copyright (c) 2006-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:    Connection multiplexer stream abstraction.

*

*/

#include "cncmstream.h"

#include "ncmconnectionmultiplexerlogs.h"

#include "ncmconnectionmultiplexerassert.h"

#include "natfwmediawrapper.h"

#include "cncmconnectionobserverhandler.h"

#include "cncmconnection.h"

const TUint KFirstConnectionId = 1;

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

// CNcmStream::CNcmStream

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

//

CNcmStream::CNcmStream( TUint aSessionId,

    TUint aStreamId, TInt aQos, TUint aProtocol ):

    iSessionId( aSessionId ), iStreamId( aStreamId ), iQos( aQos ),

    iStreamProtocol( aProtocol ),

    iNextConnectionId( KFirstConnectionId ),

    iMediaConnectionId( 0 )

    {

    }

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

// CNcmStream::NewL

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

//

CNcmStream* CNcmStream::NewL( TUint aSessionId,

    TUint aStreamId, TInt aQos, TUint aProtocol )

    {

    __CONNECTIONMULTIPLEXER( "CNcmStream::NewL" )

    CNcmStream* self =

        CNcmStream::NewLC( aSessionId, aStreamId, aQos, aProtocol );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNcmStream::NewLC

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

//

CNcmStream* CNcmStream::NewLC( TUint aSessionId,

    TUint aStreamId, TInt aQos, TUint aProtocol )

    {

    __CONNECTIONMULTIPLEXER( "CNcmStream::NewLC" )

    CNcmStream* self =

        new( ELeave ) CNcmStream( aSessionId, aStreamId, aQos, aProtocol );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CNcmStream::ConstructL

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

//

void CNcmStream::ConstructL()

    {

    /*

    iConnectionObserverHandler =

        CNcmConnectionObserverHandler::NewL();

    */

    }

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

// CNcmStream::~CNcmStream

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

//

CNcmStream::~CNcmStream()

    {

    /*

    __CONNECTIONMULTIPLEXER_INT1(

        "CNcmStream::~CNcmStream, CONN_COUNT: ", 

        iConnections.Count() )

    TInt ind( KErrNotFound );

    while ( KErrNotFound != ( ind = iConnections.Count() - 1 ) )

        {

        TUint connectionId = iConnections[ind]->ConnectionId();

        delete iConnections[ind];

        iConnections.Remove( ind );

        if ( iConnectionObserverHandler )

            {

            iConnectionObserverHandler->ConnectionNotify( iStreamId,

                connectionId, EMultiplexerConnectionRemoved, KErrNone );

            }

        }

    iConnections.Close();

    if ( iWrapper )

        {

        iWrapper->Close();  

        }

    iWrapper = NULL;

    delete iConnectionObserverHandler;

    */

    }

/*    

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

// CNcmStream::CreateConnectionL

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

//

TUint CNcmStream::CreateConnectionL(

        MNcmMultiplexerConnectionObserver& aObserver,

        CNcmConnectionObserverHandler& 

        aConnectionObserverHandler )

    {   

    CNcmConnection* multiplexer(

        CNcmConnection::NewL( iSessionId, iStreamId,

            iNextConnectionId, iLocalAddr, aObserver,

            aConnectionObserverHandler ) );

    CleanupStack::PushL( multiplexer );

    iConnections.AppendL( multiplexer );

    iNextConnectionId++;

    CleanupStack::Pop( multiplexer ); 

    return multiplexer->ConnectionId();

    }

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

// CNcmStream::RemoveConnectionL

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

//

void CNcmStream::RemoveConnectionL( TUint aConnectionId )

    {

    __CONNECTIONMULTIPLEXER_INT1(

        "CNcmStream::Remove - RemoveConnectionL: ", aConnectionId )

    TInt count( iConnections.Count() );

    TBool found( EFalse );

    for ( TInt i = 0; i < count; i++ )

        {

        if ( iConnections[i]->ConnectionId() == aConnectionId )

            {      

            delete iConnections[i];  

            iConnections.Remove( i );

            found = ETrue;

            break;

            }

        }

    if ( !found )

        {

        User::Leave( KErrNotFound );

        }

    } 

*/   

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

// CNcmStream::StreamId

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

//

TUint CNcmStream::StreamId() const

    {

    return iStreamId;

    }

/*

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

// CNcmStream::Qos

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

//

TInt CNcmStream::Qos() const

    {

    return iQos;

    }

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

// CNcmStream::SetQos

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

//

void CNcmStream::SetQos( TInt aQos )

    {

    __CONNECTIONMULTIPLEXER_INT1( "CNcmStream::SetQos - aQos: ", aQos )

    iQos = aQos;

    }

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

// CNcmStream::ConnectionL

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

//

CNcmConnection* CNcmStream::ConnectionL(

    TUint aConnectionId )

    {

    __CONNECTIONMULTIPLEXER_INT1(

        "CNcmStream::ConnectionL - aConnectionId: ", aConnectionId )

    TInt count( iConnections.Count() );

    for ( TInt i = 0; i < count; i++ )

        {

        if ( iConnections[i]->ConnectionId() == aConnectionId )

            {

            return iConnections[i];

            }

        }

    User::Leave( KErrNotFound );    

#ifndef _DEBUG_EUNIT

    return NULL;

#endif

    }

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

// CNcmStream::RegisterWrapperL

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

//

void CNcmStream::RegisterWrapperL(

    MNATFWMediaWrapper* aWrapper )

    {

    __CONNECTIONMULTIPLEXER( 

        "CNcmStream::RegisterWrapperL" )

    __CONNECTIONMULTIPLEXER_ASSERT_L( NULL != aWrapper, KErrArgument );

    __CONNECTIONMULTIPLEXER_ASSERT_L( NULL == iWrapper, KErrAlreadyExists );

    iWrapper = aWrapper;

    }

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

// CNcmStream::WrapperL

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

//

MNATFWMediaWrapper& CNcmStream::WrapperL()

    {

    __CONNECTIONMULTIPLEXER( "CNcmStream::WrapperL" )

    __CONNECTIONMULTIPLEXER_ASSERT_L( NULL != iWrapper, KErrNotReady );

    return *iWrapper;

    }

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

// CNcmStream::StreamProtocol

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

//

TUint CNcmStream::StreamProtocol() const

    {

    __CONNECTIONMULTIPLEXER( 

        "CNcmStream::StreamProtocol" )

    return iStreamProtocol;

    }

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

// CNcmStream::SetStreamProtocol

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

//

void CNcmStream::SetStreamProtocol(

    TUint aProtocol )

    {

    __CONNECTIONMULTIPLEXER( 

        "CNcmStream::SetStreamProtocol" )

    iStreamProtocol = aProtocol;

    }

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

// SetPendingDefaultConnection

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

//

TUint CNcmStream::DefaultConnectionId() const

    {

    __CONNECTIONMULTIPLEXER( 

        "CNcmStream::DefaultConnectionId ")

    return iDefaultConnectionId;

    }

*/

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

// CNcmStream::SetLocalAddr

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

//

/*void CNcmStream::SetLocalAddr( const TInetAddr& aLocalAddr )

    {

    iLocalAddr = aLocalAddr; 

    iLocalAddr.SetPort( aLocalAddr.Port() ); 

    } */

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

// CNcmStream::LocalAddress

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

//

/*TInetAddr& CNcmStream::LocalAddress()

    {

    return iLocalAddr; 

    }*/

/*

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

// CNcmStream::Port()

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

//

TUint CNcmStream::Port() const

    {

    return iLocalAddr.Port(); 

    }

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

// CNcmStream::SetPort()

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

//

void CNcmStream::SetPort( TUint aPort )

    {

    iLocalAddr.SetPort( aPort ); 

    }

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

// CNcmStream::ConnectionObserverHandler

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

//    

CNcmConnectionObserverHandler&

    CNcmStream::ConnectionObserverHandler()   

    {

    return *iConnectionObserverHandler;

    }

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

// CNcmStream::ConnectionIdByDestinationAddressL(

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

//

CNcmConnection*

    CNcmStream::ConnectionByDestinationAddressL(

    const TInetAddr& aDestinationAddress )

    {

    __CONNECTIONMULTIPLEXER( 

        "CNcmStream::ConnectionByDestinationAddressL" ) 

    TInt ind( iConnections.Count() );

    while ( ind-- )

        {

        if ( iConnections[ind]->Destination()->

            CheckSenderValidityToSending( aDestinationAddress ) )

            {

            return iConnections[ind];

            }

        }

    User::Leave( KErrNotFound );   

#ifndef _DEBUG_EUNIT

    return NULL;

#endif

    }   

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

// CNcmStream::RegisterMediaSourceL

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

//

void CNcmStream::RegisterMediaSourceL( CNcmMediaSource* aMediaSource )

    {

    iConnectionObserverHandler->RegisterMediaSourceL( aMediaSource );

    }

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

// CNcmStream::IcmpErrorReceived

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

//

TBool CNcmStream::IcmpErrorReceived() const

    {

    return iIcmpErrorReceived; 

    }

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

// CNcmStream::SetIcmpErrorReceived

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

//

void CNcmStream::SetIcmpErrorReceived( TBool aIcmpErrorReceived )

    {

    iIcmpErrorReceived = aIcmpErrorReceived; 

    }

  */