/*
* Copyright (c) 2006 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 is responsible for handling network
*                connections, send and receive data from the
*                network and allow client to start media flow between
*                connection multiplexer and socket media connection wrapper.
*
*/




#include <in_sock.h>
#include <es_sock.h>
 
#include "cncmconnectionmultiplexer.h"
#include "mncmconnectionmultiplexerobserver.h"
#include "cncmmediasource.h"
#include "ncmconnectionmultiplexerlogs.h"
#include "cncmsession.h"
#include "cncmstream.h"
#include "cncmconnection.h"
//#include "natfwmediawrapper.h"

const TUint KFirstSessionId = 1;

//Media connection is allways the first one
const TUint KMediaConnection = 1;

const TUint KDefaultProtocolSource = 0;

// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::CNcmConnectionMultiplexer
// ---------------------------------------------------------------------------
//
CNcmConnectionMultiplexer::CNcmConnectionMultiplexer(
    MNcmConnectionMultiplexerObserver& aObserver ) :
    iObserver( aObserver ), iNextSessionId( KFirstSessionId )
    {
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CNcmConnectionMultiplexer* CNcmConnectionMultiplexer::NewL(
        MNcmConnectionMultiplexerObserver& aObserver )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::NewL" )

    CNcmConnectionMultiplexer* self =
        new (ELeave) CNcmConnectionMultiplexer( aObserver );

    return self;
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::~CNcmConnectionMultiplexer
// ---------------------------------------------------------------------------
//
CNcmConnectionMultiplexer::~CNcmConnectionMultiplexer()
    {
    __CONNECTIONMULTIPLEXER( 
        "CNcmConnectionMultiplexer::~CNcmConnectionMultiplexer" )
        
    iSessions.ResetAndDestroy();
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::CreateSessionL
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CNcmConnectionMultiplexer::CreateSessionL( TUint32 aIapId,
    TUint aPortRangeStart, TUint aPortRangeStop )
    {
 
    CNcmSession* session = 
        CNcmSession::NewLC( iNextSessionId, aIapId,
            aPortRangeStart, aPortRangeStop, iObserver, *this );
        
    iSessions.AppendL( session );
    CleanupStack::Pop( session );
    
    iNextSessionId++;
    
    return session->SessionId();    
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::CreateStreamL
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CNcmConnectionMultiplexer::CreateStreamL( TUint aSessionId,
    TInt aQos, TUint aProtocol )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::CreateStreamL" )
    
    CNcmSession* session( SessionByIdL( aSessionId ) );
    
    //__ASSERT_ALWAYS( session->Initialized(), User::Leave( KErrNotReady ) ); 
    
/*    TUint streamId( session->CreateStreamL( aQos, aProtocol ) );
   
    TInetAddr localAddr( session->LocalIPv4Address() );
    localAddr.SetPort( session->LocalIPv4Address().Port() );
    
    //StreamByIdL( streamId )->SetLocalAddr( localAddr );

    //Create a default connection for stream
    //CreateDefaultConnectionL( streamId, aProtocol );

    return streamId;*/
    return ( session->CreateStreamL( aQos, aProtocol ) );
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::GetStreamInfoL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::GetStreamInfoL( 
    TUint /*aStreamId*/, TUint32& /*aIapId*/, TInt& /*aQos*/,
    TUint& /*aProtocol*/ )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::GetStreamInfoL" )
/*    
    CNATFWMultiplexerStream* stream( StreamByIdL( aStreamId ) );
       
    aIapId = SessionByStreamIdL( aStreamId )->IapId();
    aQos = stream->Qos();
    aProtocol = stream->StreamProtocol();*/
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::LocalIPAddressL
// ---------------------------------------------------------------------------
//
EXPORT_C TInetAddr& CNcmConnectionMultiplexer::LocalIPAddressL(
    TUint aStreamId, TUint aConnectionId )
    {
    return StreamByIdL( aStreamId )->
        ConnectionL( aConnectionId )->LocalAddress();
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::GetSessionInfoL
// ---------------------------------------------------------------------------
//
EXPORT_C RSocketServ* CNcmConnectionMultiplexer::GetSessionInfoL(
    TUint aSessionId, TName& aConnectionName )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::GetSessionInfoL" )
    
    CNcmSession* session( SessionByIdL( aSessionId ) );

    User::LeaveIfError( session->GetConnectionName( aConnectionName ) );
    
    return &session->SocketServer();
    }
 
   
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::CreateConnectionL
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CNcmConnectionMultiplexer::CreateConnectionL( 
    TUint aStreamId, TUint /*aAddrFamily*/ )
    {
    __CONNECTIONMULTIPLEXER( 
        "CNcmConnectionMultiplexer::CreateConnectionL" )
    
    CNcmStream* stream( StreamByIdL( aStreamId ) );
    CNcmSession* session( SessionByStreamIdL( aStreamId ) );
    
    TInetAddr addr( KInetAddrNone, 0 );
        
    // Create Connection
    return stream->CreateConnectionL(
            *this, stream->ConnectionObserverHandler(),
            session->SocketServer(),
            session->Connection(), addr, EFalse );
               
//    return 2;
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::CreateConnectionL
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CNcmConnectionMultiplexer::CreateConnectionL( 
    TUint aStreamId, const TInetAddr& /*aLocalAddr*/ )
    {
    CNcmStream* stream( StreamByIdL( aStreamId ) );
    CNcmSession* session( SessionByStreamIdL( aStreamId ) );
    
    TInetAddr addr( KInetAddrNone, 0 );
    
    // Create Connection
    return stream->CreateConnectionL(
            *this, stream->ConnectionObserverHandler(),
            session->SocketServer(),
            session->Connection(), addr, ETrue );
    
//    return 2;
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::OpenTcpConnectionL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::OpenTcpConnectionL(
    TUint /*aStreamId*/, TUint /*aConnectionId*/,
    TNATFWTcpConnectionSetup /*aConfig*/, const TInetAddr& /*aDestAddr*/ )
    {
    __CONNECTIONMULTIPLEXER( 
        "CNcmConnectionMultiplexer::OpenTcpConnectionL" )
    }
        
        
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::CancelTcpConnectionSetupL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::CloseTcpConnection(
        TUint /*aStreamId*/, TUint /*aConnectionId*/ )
    {
    __CONNECTIONMULTIPLEXER( 
        "CNcmConnectionMultiplexer::CloseTcpConnectionSetup" )
    }
    
    
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::RemoveSessionL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::RemoveSessionL( TUint aSessionId )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::RemoveSessionL" )

    TInt sessionCount( iSessions.Count() );
    
    for ( TInt i = 0; i < sessionCount; i++ )
        {
        if ( iSessions[i]->SessionId() == aSessionId )
            {
            delete iSessions[i];
            iSessions.Remove( i );
            return;
            }
        }
    User::Leave( KErrNotFound );
    }

// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::RemoveStreamL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::RemoveStreamL( TUint aStreamId )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::RemoveStreamL" )

    CNcmSession* session( SessionByStreamIdL( aStreamId ) );    

    session->RemoveStreamL( aStreamId );
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::RemoveConnectionL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::RemoveConnectionL(
    TUint /*aStreamId*/, TUint /*aConnectionId*/ )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::RemoveConnectionL" )
    
/*    CNATFWMultiplexerStream* stream( StreamByIdL( aStreamId ) );
    
    if ( KMediaConnection == aConnectionId )
        {
        //Default media stream can't be deleted.        
        User::Leave( KErrPermissionDenied );
        }
        
    stream->RemoveConnectionL( aConnectionId );     */
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::RegisterIncomingConnectionObserverL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::
    RegisterIncomingConnectionObserverL( TUint /*aStreamId*/,
        MNcmIncomingConnectionObserver& /*aObserver*/ )
    {
    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::RegisterIncomingConnectionObserver" )
/*        
    StreamByIdL( aStreamId )->
        ConnectionObserverHandler().
        RegisterIncomingConnectionObserverL( aObserver );*/
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::RegisterOutgoingConnectionObserverL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::
    RegisterOutgoingConnectionObserverL(
        TUint /*aStreamId*/, MNcmOutgoingConnectionObserver& /*aObserver*/ )
    {
    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::RegisterOutgoingConnectionObserver" )
/*
    StreamByIdL( aStreamId )->
        ConnectionObserverHandler().
        RegisterOutgoingConnectionObserverL( aObserver );*/
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::RegisterMessageObserverL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::RegisterMessageObserverL(
    TUint /*aStreamId*/, MNcmMessageObserver& /*aObserver*/ )
    {
    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::RegisterMessageObserverL" )
    }

// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::UnregisterMessageObserverL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::UnregisterMessageObserverL(
    TUint /*aStreamId*/, MNcmMessageObserver& /*aObserver*/ )
    {
    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::UnregisterMessageObserverL" )
    }
            
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::UnregisterIncomingConnectionObserverL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::
    UnregisterIncomingConnectionObserverL(
        TUint /*aStreamId*/, MNcmIncomingConnectionObserver& /*aObserver*/ )
    {
    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::UnregisterIncomingConnectionObserver" )
/*
    StreamByIdL( aStreamId )->ConnectionObserverHandler().
        UnregisterIncomingConnectionObserverL( aObserver );*/
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::UnregisterOutgoingConnectionObserverL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::
    UnregisterOutgoingConnectionObserverL(
        TUint /*aStreamId*/, MNcmOutgoingConnectionObserver& /*aObserver*/ )
    {
    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::UnregisterOutgoingConnectionObserver" )
/*
    StreamByIdL( aStreamId )->ConnectionObserverHandler().
        UnregisterOutgoingConnectionObserverL( aObserver );*/
    }
    
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::RegisterConnectionObserverL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::RegisterConnectionObserverL(
    TUint /*aStreamId*/, MNcmConnectionObserver& /*aObserver*/ )
    {
    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::RegisterConnectionObserverL" )
/*
    StreamByIdL( aStreamId )->
        ConnectionObserverHandler().
        RegisterConnectionObserverL( aObserver );*/
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::UnregisterConnectionObserverL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::UnregisterConnectionObserverL(
    TUint /*aStreamId*/, MNcmConnectionObserver& /*aObserver*/ )
    {
    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::UnregisterConnectionObserverL" )
/*
    StreamByIdL( aStreamId )->ConnectionObserverHandler().
        UnregisterConnectionObserverL( aObserver );*/
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::RegisterMediaWrapperL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::RegisterMediaWrapperL(
    MNATFWMediaWrapper* /*aMediaWrapper*/ )
    {
/*    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::RegisterMediaWrapperL" )
        
    __ASSERT_ALWAYS( aMediaWrapper, User::Leave( KErrNotReady ) );
    
    TUint streamId( aMediaWrapper->StreamId() );
    
    CNATFWMultiplexerStream* stream( StreamByIdL( streamId ) );
    
    stream->RegisterWrapperL( aMediaWrapper );
    
    // set up media source (ownership tranferred)
    CNATFWMultiplexerConnection* connection(
        stream->ConnectionL( KMediaConnection ) );
       
    User::LeaveIfError( connection->RegisterSource(
        CNATFWMultiplexerMediaSource::NewL( *connection, *this,
        stream->WrapperL(), SessionByStreamIdL( streamId )->SocketServer(),
        stream->LocalAddress() ) ) );*/
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::SendL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint /*aStreamId*/,
    TUint /*aConnectionId*/, const TDesC8& /*aMessage*/,
    MNcmSenderObserver* /*aSenderObserver*/ )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::SendL" )
    
/*    CNATFWMultiplexerConnection* connection = StreamByIdL( aStreamId )->
        ConnectionL( aConnectionId );
    
    __ASSERT_ALWAYS( connection, User::Leave( KErrArgument ) );  
 
    // Get source for plug-in (always the first one)
    RPointerArray<CNATFWMultiplexerSourceBase> sources;
    CleanupClosePushL( sources );
    
    connection->GetSources( sources );
    
    if ( !sources.Count() )
        {
        User::Leave( KErrNotFound );
        }
        
    // Send the message
    User::LeaveIfError( static_cast<CNATFWMultiplexerProtocolSource*>( 
        sources[KDefaultProtocolSource] )->Send( aMessage, KAFUnspec,
        aSenderObserver ) );

    CleanupStack::PopAndDestroy( &sources );*/
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::SendL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint /*aStreamId*/,
    TUint /*aConnectionId*/, const TDesC8& /*aMessage*/,
    const TInetAddr& /*aDestinationAddress*/,
    MNcmSenderObserver* /*aSenderObserver*/  )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::SendL" )
    
/*    CNATFWMultiplexerConnection* connection( NULL );
    CNATFWMultiplexerStream* stream = StreamByIdL( aStreamId );
    
    if ( aConnectionId )
        {     
        connection = stream->ConnectionL( aConnectionId );      
        }
    else
        {
        connection =
            stream->ConnectionByDestinationAddressL( aDestinationAddress );
        } 
    
    __ASSERT_ALWAYS( connection, User::Leave( KErrArgument ) ); 
  
    // Get source for plug-in (always the first one)
    RPointerArray<CNATFWMultiplexerSourceBase> sources;
    CleanupClosePushL( sources );
    
    connection->GetSources( sources );
    
    __ASSERT_ALWAYS( sources.Count(), User::Leave( KErrNotFound ) );

    // Send the message
    User::LeaveIfError( static_cast<CNATFWMultiplexerProtocolSource*>( 
        sources[KDefaultProtocolSource] )->
            Send( aMessage, aDestinationAddress, aSenderObserver ) );

    CleanupStack::PopAndDestroy( &sources );     */
    }
    
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::SendL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint /*aStreamId*/,
    TUint /*aConnectionId*/, const TDesC8& /*aMessage*/, TBool /*aSendDirectly*/,
    MNcmSenderObserver* /*aSenderObserver*/ )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::SendL" )
/*     
    if ( aSendDirectly )
        {
        CNATFWMultiplexerSocketDestination* dest = 
            static_cast<CNATFWMultiplexerSocketDestination*>( 
            StreamByIdL( aStreamId )->
            ConnectionL( aConnectionId )->Destination() );
          
        dest->PutMessage( aMessage, aSenderObserver );
        }
    else
        {
        this->SendL( aStreamId, aConnectionId, aMessage, aSenderObserver );
        }*/
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::SendL
// ---------------------------------------------------------------------------
//
EXPORT_C  void CNcmConnectionMultiplexer::SendL( TUint /*aStreamId*/, const TDesC8& /*aMessage*/,
    const TInetAddr& /*aNextHopAddress*/, const TInetAddr& /*aDestinationAddress*/ )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::SendL" )
    }
        
        
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::SocketHandlesL
// ---------------------------------------------------------------------------
//
//EXPORT_C RConnection& CNcmConnectionMultiplexer::GetSocketHandlesL(
//    TUint /*aStreamId*/, TUint /*aConnectionId*/, RSocketServ& /*aSocketServ*/,
//    RSocket& /*aSocket*/ )
//    {
//    __CONNECTIONMULTIPLEXER( 
//        "CNcmConnectionMultiplexer::GetSocketHandlesL" )
/*    
    CNATFWMultiplexerSocketDestination* dest = 
        static_cast<CNATFWMultiplexerSocketDestination*>( 
        StreamByIdL( aStreamId )->
        ConnectionL( aConnectionId )->Destination() );
        
    aSocketServ = SessionByStreamIdL( aStreamId )->SocketServer();  
    aSocket = dest->Socket();
    
    return SessionByStreamIdL( aStreamId )->Connection();*/
//    RConnection* connection = NULL;
    
//    return *connection;
//    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::PortStore
// ---------------------------------------------------------------------------
//
EXPORT_C CNcmPortStore& CNcmConnectionMultiplexer::PortStoreL(
    TUint /*aSessionId*/ )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::PortStore" )
    CNcmPortStore* store = NULL;
//    return SessionByIdL( aSessionId )->PortStore();
    return *store;
    }

// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::SetSendingStateL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::SetSendingStateL(
        TUint /*aStreamId*/, TUint /*aConnectionId*/, const TInetAddr& /*aDestAddr*/,
        TNATFWStreamingState /*aState*/ )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::SetSendingStateL" )
/*    
    CNATFWMultiplexerSocketDestination* dest = 
        static_cast<CNATFWMultiplexerSocketDestination*>( 
        StreamByIdL( aStreamId )->
        ConnectionL( aConnectionId )->Destination() );
        
    dest->SetSendingStateL( aDestAddr, aState );  */
    }
    
    
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::SetReceivingStateL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::SetReceivingStateL(
    TUint /*aStreamId*/, TUint /*aConnectionId*/, TNATFWStreamingState /*aState*/ )
    {
    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::SetReceivingStateL" )
/*        
    CNATFWMultiplexerSocketDestination* dest = 
        static_cast<CNATFWMultiplexerSocketDestination*>( 
        StreamByIdL( aStreamId )->
        ConnectionL( aConnectionId )->Destination() );
        
    dest->SetReceivingStateL( aState );*/
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::SetAcceptedFromAddressL
// ---------------------------------------------------------------------------
//
EXPORT_C void CNcmConnectionMultiplexer::SetAcceptedFromAddressL( 
    TUint /*aStreamId*/, TUint /*aConnectionId*/, const TInetAddr& /*aAddress*/ )
    {
    __CONNECTIONMULTIPLEXER(
        "CNcmConnectionMultiplexer::SetAcceptedFromAddressL" )
    
/*    CNcmSocketDestination* dest = 
        static_cast<CNcmSocketDestination*>( 
        StreamByIdL( aStreamId )->
        ConnectionL( aConnectionId )->Destination() );
    
    dest->SetAcceptedFromAddress( aAddress );*/
    }


// ---------------------------------------------------------------------------
// From class MNATFWMultiplexerConnectionObserver
//
// CNcmConnectionMultiplexer::ConnectionError
// ---------------------------------------------------------------------------
//
void CNcmConnectionMultiplexer::ConnectionError(
    TUint /*aSessionId*/, TUint /*aStreamId*/, TUint /*aConnectionId*/,
    TMultiplexerConnectionNotifyType /*aNotifyType*/, TInt /*aError*/ )
    {
    __CONNECTIONMULTIPLEXER( 
        "CNcmConnectionMultiplexer::MultiplexerError" )
    
/*    CNATFWMultiplexerStream* stream( StreamById( aStreamId ) ); 
    
    if ( stream )
        {
        // Notify connection observers
        stream->ConnectionObserverHandler().
            ConnectionNotify( aStreamId, aConnectionId, aNotifyType, aError );
                                                      
        // Lets notify stream user                  
        iObserver.Notify( aSessionId, aStreamId,
            MNcmConnectionMultiplexerObserver::EStreamError, aError );
        }*/
    }


// ---------------------------------------------------------------------------
// From class MNATFWMultiplexerSocketDestinationObserver
//
// CNcmConnectionMultiplexer::ConnectionNotify
// ---------------------------------------------------------------------------
//
void CNcmConnectionMultiplexer::ConnectionNotify( TUint /*aStreamId*/,
    TUint /*aConnectionId*/, TMultiplexerConnectionNotifyType /*aType*/,
    TInt /*aError*/ )
    {
    __CONNECTIONMULTIPLEXER( 
        "CNcmConnectionMultiplexer::ConnectionNotify" )
/*        
    TRAP_IGNORE(
        ConnectionNotifyL( aStreamId, aConnectionId, aType, aError ) )*/
    }


// ---------------------------------------------------------------------------
// From class MNATFWMultiplexerSocketDestinationObserver
//
// CNcmConnectionMultiplexer::GetNewFreePort
// ---------------------------------------------------------------------------
//
void CNcmConnectionMultiplexer::GetNewFreePort( TUint /*aStreamId*/,
    TUint /*aConnectionId*/, TUint& /*aPort*/ )
    {
    __CONNECTIONMULTIPLEXER( 
        "CNcmConnectionMultiplexer::GetNewFreePort" )
        
    //TRAP_IGNORE( GetNewFreePortL( aStreamId, aConnectionId, aPort ) )
    }
    

// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::ConnectionNotifyL
// ---------------------------------------------------------------------------
//
void CNcmConnectionMultiplexer::ConnectionNotifyL( TUint /*aStreamId*/,
    TUint aConnectionId, TMultiplexerConnectionNotifyType aType,
    TInt /*aError*/ )
    {
    
//    CNATFWMultiplexerStream* stream( StreamByIdL( aStreamId ) );
       
//    TUint sessionId( SessionByStreamIdL( aStreamId )->SessionId() );
    
    if ( KMediaConnection == aConnectionId )
        {        
        switch ( aType )
            {
            case EMultiplexerReceivingActivated:
                {          
//                MNATFWMediaWrapper& wrapper = stream->WrapperL();
//                TRAPD( error, wrapper.ConnectL() );
      
/*                if ( KErrNone != error )
                    {
                    __CONNECTIONMULTIPLEXER_INT1(
                        "CNcmConnectionMultiplexer::ConnectionNotify - Wrapper connecting error: ", error )
                    
                    CNATFWMultiplexerSocketDestination* dest = 
                        static_cast<CNATFWMultiplexerSocketDestination*>( 
                        stream->ConnectionL( aConnectionId )->Destination() );
                        
                    dest->SetReceivingStateL( EStreamingStatePassive );  
                    
                    iObserver.Notify( sessionId, aStreamId,
                        MNcmConnectionMultiplexerObserver::EStreamError,
                        aError );
                    }
                else
                    {
                    iObserver.Notify( sessionId, aStreamId,
                        MNcmConnectionMultiplexerObserver::
                        EReceivingActivated, aError );
                    }*/
                break;
                }
           
            case EMultiplexerSendingActivated:
                {
/*                MNATFWMediaWrapper& wrapper = stream->WrapperL();           

                TRAPD( error, wrapper.StartListeningL() );
      
                if ( KErrNone != error )
                    {
                    __CONNECTIONMULTIPLEXER_INT1(
                        "CNcmConnectionMultiplexer::ConnectionNotify - Wrapper start listenin error: ", error )
                    
                    CNATFWMultiplexerSocketDestination* dest = 
                        static_cast<CNATFWMultiplexerSocketDestination*>( 
                        stream->ConnectionL( aConnectionId )->Destination() );
                        
                    dest->SetSendingStateL( KAFUnspec, EStreamingStatePassive );  
                    
                    iObserver.Notify( sessionId, aStreamId,
                        MNcmConnectionMultiplexerObserver::EStreamError,
                        aError );               

                    }
                else
                    {
                    iObserver.Notify( sessionId, aStreamId,
                        MNcmConnectionMultiplexerObserver::ESendingActivated
                        ,aError );
                    }  
                              
  */  
                break;
                }
                
            case EMultiplexerReceivingDeactivated:
                {
/*                MNATFWMediaWrapper& wrapper = stream->WrapperL();            
                wrapper.DeactivateSending();

                iObserver.Notify( sessionId, aStreamId,
                    MNcmConnectionMultiplexerObserver::EReceivingDeactivated
                    ,aError );                 
    */
                break;
                }    
                
            case EMultiplexerSendingDeactivated:
                {
/*                MNATFWMediaWrapper& wrapper = stream->WrapperL();             
                wrapper.DeactivateReceiving();

                iObserver.Notify( sessionId, aStreamId,
                    MNcmConnectionMultiplexerObserver::ESendingDeactivated
                    ,aError );                 */
    
                break;
                }  
            case EMultiplexerConnectionError:
                { 
/*                iObserver.Notify( sessionId, aStreamId,
                    MNcmConnectionMultiplexerObserver::EStreamError,
                    aError );              */
                break;
                }
            case EMultiplexerConnectionRemoved:
                {
                break;
                }    
            }       
        }
    else
        {
/*        stream->ConnectionObserverHandler().
            ConnectionNotify( aStreamId, aConnectionId, aType, aError );*/
        }              
    }
  
    
// ---------------------------------------------------------------------------
// From class MNATFWMultiplexerSessionObserver
//
// Called as a result for CreateSessionL() when wrapper is connected
// ---------------------------------------------------------------------------
//
void CNcmConnectionMultiplexer::SessionCreationFailed( TUint /*aSessionId*/ )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::SessionCreationFailed" )
    
//    TRAP_IGNORE( RemoveSessionL( aSessionId ) )
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::SessionByIdL()
// ---------------------------------------------------------------------------
//       
CNcmSession* CNcmConnectionMultiplexer::SessionByIdL(
    TUint aSessionId )
    {
    TInt ind( iSessions.Count() );
    
    while ( ind-- )
        {
        if ( iSessions[ind]->SessionId() == aSessionId )
            {
            return iSessions[ind];
            }
        }
   
    User::Leave( KErrNotFound );
#ifndef _DEBUG_EUNIT 
    return NULL;
#endif
    }
 
    
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::StreamByIdL()
// ---------------------------------------------------------------------------
//       
CNcmStream* CNcmConnectionMultiplexer::StreamByIdL(
    TUint aStreamId )
    {   
    TInt sessInd( iSessions.Count() );
    
    while ( sessInd-- )
        {
        CNcmStream* stream = iSessions[sessInd]->
            StreamByIdL( aStreamId );
            
        if ( stream )
            {
            return stream;
            }
        }
   
    User::Leave( KErrNotFound ); 
#ifndef _DEBUG_EUNIT 
    return NULL;
#endif
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::StreamById()
// ---------------------------------------------------------------------------
//       
//CNATFWMultiplexerStream* CNcmConnectionMultiplexer::StreamById(
//    TUint /*aStreamId*/ )
/*    {
    CNATFWMultiplexerStream* stream( NULL );
    
    TRAP_IGNORE( ( stream = StreamByIdL( aStreamId ) ) )
 
    return stream;
    }*/
 
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::SessionByStreamIdL()
// ---------------------------------------------------------------------------
//       
CNcmSession* CNcmConnectionMultiplexer::SessionByStreamIdL(
    TUint aStreamId )
    {   
    TInt sessInd( iSessions.Count() );
    
    while ( sessInd-- )
        {
        CNcmStream* stream = iSessions[sessInd]->
            StreamByIdL( aStreamId );
            
        if ( stream )
            {
            return iSessions[sessInd];
            }
        }

    User::Leave( KErrNotFound );
#ifndef _DEBUG_EUNIT 
    return NULL;
#endif
    }   

    
// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::CreateDefaultConnectionL
// ---------------------------------------------------------------------------
//     
//void CNcmConnectionMultiplexer::CreateDefaultConnectionL( TUint /*aStreamId*/,
//    TUint /*aProtocol*/ )
/*    {
    __CONNECTIONMULTIPLEXER( 
        "CNcmConnectionMultiplexer::CreateConnectionL" )
    
    CNATFWMultiplexerStream* stream( StreamByIdL( aStreamId ) );
    
    // Create Connection ( Create multiplexer )
    TUint connectionId = stream->
        CreateConnectionL( *this, stream->ConnectionObserverHandler() );  
                                     
    // Retrive created Multiplexer instance
    CNATFWMultiplexerConnection* connection =
        stream->ConnectionL( connectionId );
         
    // set up protocol source (ownership tranferred)
    connection->RegisterSource(
        CNATFWMultiplexerProtocolSource::NewL( *connection ) );  

    // set up destination (ownership tranferred)
    connection->SetDestination( CNATFWMultiplexerSocketDestination::NewL(
                aStreamId,
                connectionId,
                stream->Port(),
                stream->Qos(),
                SessionByStreamIdL( aStreamId )->SocketServer(),
                SessionByStreamIdL( aStreamId )->Connection(),
                aProtocol,
                *connection,
                *this ) );
    }*/

// ---------------------------------------------------------------------------
// From class MNATFWMultiplexerMediaSourceObserver
//
// CNcmConnectionMultiplexer::WrapperSenderError
// ---------------------------------------------------------------------------
//
void CNcmConnectionMultiplexer::WrapperSenderError( TUint /*aStreamId*/,
    TInt /*aError*/ )
    {
/*        
    this->ConnectionNotify( aStreamId, KMediaConnection,
        EMultiplexerConnectionError, aError );*/
    }

// ---------------------------------------------------------------------------
// From class MNcmMediaSourceObserver
//
// CNcmConnectionMultiplexer::FirstMediaPacketSent
// ---------------------------------------------------------------------------
//
void CNcmConnectionMultiplexer::FirstMediaPacketSent( TUint /*aStreamId*/ )
    {
/*    __CONNECTIONMULTIPLEXER_INT1(
        "CNcmConnectionMultiplexer::FirstMediaPacketSent- aStreamId: ", aStreamId )
 
    TInt connectionId( 0 );
    
    TRAP_IGNORE(
        connectionId = StreamByIdL( aStreamId )->MediaConnectionId() )
    
    TRAP_IGNORE( this->ConnectionNotifyL( aStreamId, connectionId,
        EMultiplexerFirstMediaPacketSent, KErrNone ) )*/
    }


// ---------------------------------------------------------------------------
// From class MNATFWMultiplexerMediaSourceObserver
//
// CNcmConnectionMultiplexer::GetFreePort
// ---------------------------------------------------------------------------
//
void CNcmConnectionMultiplexer::GetFreePort( TUint /*aStreamId*/, TUint& /*aPort*/ )
    {
    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::GetFreePort" )       
    //TRAP_IGNORE( ( aPort = SessionByStreamIdL( aStreamId )->PortStore().Port() ) );
    }


// ---------------------------------------------------------------------------
// CNcmConnectionMultiplexer::CancelMessageSend
// ---------------------------------------------------------------------------
//
void CNcmConnectionMultiplexer::CancelMessageSend( TUint /*aStreamId*/, TUint /*aConnectionId*/,
        const MNcmSenderObserver* /*aSenderObserver*/ )
    {
    
    }