/*

* 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 "cncmconnectionmultiplexer.h"

#include "mncmconnectionmultiplexerobserver.h"

#include "cncmportstore.h"

#include "cncmmediasource.h"

#include "ncmconnectionmultiplexerlogs.h"

#include "cncmsession.h"

#include "cncmstream.h"

#include "cncmconnection.h"

#include "natfwmediawrapper.h"

const TUint KFirstSessionId = 1;

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

// 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::NewL( iNextSessionId, aIapId,

            aPortRangeStart, aPortRangeStop, iObserver, *this );

    CleanupStack::PushL( session ); 

    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 ) );

    TUint streamId( session->CreateStreamL( aQos, aProtocol ) );;

    return streamId;

    }

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

// CNcmConnectionMultiplexer::GetStreamInfoL

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

//

EXPORT_C void CNcmConnectionMultiplexer::GetStreamInfoL( 

    TUint /*aStreamId*/, TUint32& /*aIapId*/, TInt& /*aQos*/,

    TUint& /*aProtocol*/ )

    {

    }

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

// CNcmConnectionMultiplexer::LocalIPAddressL

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

//

EXPORT_C TInetAddr& CNcmConnectionMultiplexer::LocalIPAddressL(

    TUint /*aStreamId*/, TUint /*aConnectionId*/ )

    {

    TInetAddr add;

    return add;

    }

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

// CNcmConnectionMultiplexer::ResolveDestinationAddressL

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

//

EXPORT_C void CNcmConnectionMultiplexer::ResolveDestinationAddressL(

    TUint /*aStreamId*/, const TDesC8& /*aAddress*/, TUint /*aPort*/,

    TInetAddr& /*aResult*/ )

    {

    }

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

// CNcmConnectionMultiplexer::CreateConnectionL

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

//

EXPORT_C TUint CNcmConnectionMultiplexer::CreateConnectionL( 

    TUint /*aStreamId*/, TUint /*aAddrFamily*/ )

    {

    return 0;

    }

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

// CNcmConnectionMultiplexer::CreateConnectionL - overloaded

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

//

EXPORT_C TUint CNcmConnectionMultiplexer::CreateConnectionL( 

    TUint /*aStreamId*/, const TInetAddr& /*aLocalAddr*/ )

    {

    return 0;

    }

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

// CNcmConnectionMultiplexer::OpenTcpConnectionL

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

//

EXPORT_C void CNcmConnectionMultiplexer::OpenTcpConnectionL(

    TUint /*aStreamId*/, TUint /*aConnectionId*/,

    TNATFWTcpConnectionSetup /*aConfig*/, const TInetAddr& /*aDestAddr*/ )

    {

    }

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

// CNcmConnectionMultiplexer::CloseTcpConnection

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

//

EXPORT_C void CNcmConnectionMultiplexer::CloseTcpConnection(

        TUint /*aStreamId*/, TUint /*aConnectionId*/ )

    {

    }     

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

// 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*/ )

    {

    }

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

// CNcmConnectionMultiplexer::RegisterIncomingConnectionObserverL

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

//

EXPORT_C void CNcmConnectionMultiplexer::

    RegisterIncomingConnectionObserverL( TUint /*aStreamId*/,

        MNcmIncomingConnectionObserver& /*aObserver*/ )

    {

    }

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

// CNcmConnectionMultiplexer::RegisterOutgoingConnectionObserverL

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

//

EXPORT_C void CNcmConnectionMultiplexer::

    RegisterOutgoingConnectionObserverL(

        TUint /*aStreamId*/, MNcmOutgoingConnectionObserver& /*aObserver*/ )

    {

    }

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

// CNcmConnectionMultiplexer::UnregisterIncomingConnectionObserverL

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

//

EXPORT_C void CNcmConnectionMultiplexer::

    UnregisterIncomingConnectionObserverL(

        TUint /*aStreamId*/,MNcmIncomingConnectionObserver& /*aObserver*/ )

    {

    }

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

// CNcmConnectionMultiplexer::UnregisterOutgoingConnectionObserverL

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

//

EXPORT_C void CNcmConnectionMultiplexer::

    UnregisterOutgoingConnectionObserverL(

        TUint /*aStreamId*/, MNcmOutgoingConnectionObserver& /*aObserver*/ )

    {

    }

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

// CNcmConnectionMultiplexer::RegisterConnectionObserverL

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

//

EXPORT_C void CNcmConnectionMultiplexer::RegisterConnectionObserverL(

    TUint /*aStreamId*/, MNcmConnectionObserver& /*aObserver*/ )

    {

    }

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

// CNcmConnectionMultiplexer::UnregisterConnectionObserverL

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

//

EXPORT_C void CNcmConnectionMultiplexer::UnregisterConnectionObserverL(

    TUint /*aStreamId*/, MNcmConnectionObserver& /*aObserver*/ )

    {

    }

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

// CNcmConnectionMultiplexer::RegisterMessageObserverL

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

//

EXPORT_C void CNcmConnectionMultiplexer::RegisterMessageObserverL(

    TUint /*aStreamId*/, MNcmMessageObserver& /*aObserver*/ )

    {

    }

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

// CNcmConnectionMultiplexer::UnregisterMessageObserverL

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

//

EXPORT_C void CNcmConnectionMultiplexer::UnregisterMessageObserverL(

    TUint /*aStreamId*/, MNcmMessageObserver& /*aObserver*/ )

    {

    }

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

// CNcmConnectionMultiplexer::RegisterMediaWrapperL

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

//

EXPORT_C void CNcmConnectionMultiplexer::RegisterMediaWrapperL(

    MNATFWMediaWrapper* aMediaWrapper )

    {

    TUint streamId( aMediaWrapper->StreamId() );

    CNcmStream* stream( StreamByIdL( streamId ) );

    stream->RegisterWrapperL( aMediaWrapper );

    }

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

// CNcmConnectionMultiplexer::SendL

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

//

EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint /*aStreamId*/,

    TUint /*aConnectionId*/, const TDesC8& /*aMessage*/,

    MNcmSenderObserver* /*aSenderObserver*/ )

    {

    }

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

// CNcmConnectionMultiplexer::SendL

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

//

EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint /*aStreamId*/,

    TUint /*aConnectionId*/, const TDesC8& /*aMessage*/,

    const TInetAddr& /*aDestinationAddress*/,

    MNcmSenderObserver* /*aSenderObserver*/  )

    {

    }

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

// CNcmConnectionMultiplexer::SendL

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

//

EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint /*aStreamId*/,

    const TDesC8& /*aMessage*/, const TInetAddr& /*aNextHopAddress*/,

    const TInetAddr& /*aDestinationAddress*/ )

    {

    }

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

// CNcmConnectionMultiplexer::SendL

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

//

EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint /*aStreamId*/,

    TUint /*aConnectionId*/, const TDesC8& /*aMessage*/, TBool /*aSendDirectly*/,

    MNcmSenderObserver* /*aSenderObserver*/ )

    {

    }

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

// CNcmConnectionMultiplexer::CancelMessageSend

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

//

EXPORT_C void CNcmConnectionMultiplexer::CancelMessageSend( TUint /*aStreamId*/,

    TUint /*aConnectionId*/, const MNcmSenderObserver* /*aSenderObserver*/ )

    {

    __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::CancelMessageSend " )

    }

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

// CNcmConnectionMultiplexer::GetSessionInfoL

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

//

EXPORT_C RSocketServ* CNcmConnectionMultiplexer::GetSessionInfoL( TUint /*aSessionId*/,

    TName& /*aConnectionName*/ )

    {

    }

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

// CNcmConnectionMultiplexer::PortStore

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

//

EXPORT_C CNcmPortStore& CNcmConnectionMultiplexer::PortStoreL(

    TUint aSessionId )

    {

    return SessionByIdL( aSessionId )->PortStore();

    }

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

// CNcmConnectionMultiplexer::SetSendingStateL

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

//

EXPORT_C void CNcmConnectionMultiplexer::SetSendingStateL(

        TUint aStreamId, TUint /*aConnectionId*/, const TInetAddr& /*aDestAddr*/,

        TNATFWStreamingState aState )

    {

    switch( aState )

        {

        case EStreamingStatePassive:

            iObserver.Notify( SessionByStreamIdL( aStreamId )->SessionId(),

                        aStreamId,

                        MNcmConnectionMultiplexerObserver::

                        ESendingDeactivated, KErrNone );

            break;

        case EStreamingStateActive:

            iObserver.Notify( SessionByStreamIdL( aStreamId )->SessionId(),

                        aStreamId,

                        MNcmConnectionMultiplexerObserver::

                        ESendingActivated, KErrNone );

            break;

        default:

            break;

        }

    }

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

// CNcmConnectionMultiplexer::SetReceivingStateL

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

//

EXPORT_C void CNcmConnectionMultiplexer::SetReceivingStateL(

    TUint aStreamId, TUint /*aConnectionId*/, TNATFWStreamingState aState )

    {

    switch( aState )

        {

        case EStreamingStatePassive:

            iObserver.Notify( SessionByStreamIdL( aStreamId )->SessionId(),

                        aStreamId,

                        MNcmConnectionMultiplexerObserver::

                        EReceivingDeactivated, KErrNone );

            break;

        case EStreamingStateActive:

            iObserver.Notify( SessionByStreamIdL( aStreamId )->SessionId(),

                        aStreamId,

                        MNcmConnectionMultiplexerObserver::

                        EReceivingActivated, KErrNone );

        default:

            break;

        }

    }

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

// CNcmConnectionMultiplexer::SetAcceptedFromAddressL

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

//

EXPORT_C void CNcmConnectionMultiplexer::SetAcceptedFromAddressL(

    TUint /*aStreamId*/, TUint /*aConnectionId*/,

    const TInetAddr& /*aAddress*/ )

    {

    }

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

// CNcmConnectionMultiplexer::SetSendingStateForMediaL

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

//

EXPORT_C void CNcmConnectionMultiplexer::SetSendingStateForMediaL(

    TUint aStreamId, TUint /*aConnectionId*/, TNATFWStreamingState aState )

    {

    switch( aState )

        {

        case EStreamingStatePassive:

            iObserver.Notify( SessionByStreamIdL( aStreamId )->SessionId(),

                        aStreamId,

                        MNcmConnectionMultiplexerObserver::

                        ESendingDeactivated, KErrNone );

            break;

        case EStreamingStateActive:

            iObserver.Notify( SessionByStreamIdL( aStreamId )->SessionId(),

                        aStreamId,

                        MNcmConnectionMultiplexerObserver::

                        ESendingActivated, KErrNone );

        default:

            break;

        }

    }

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

// CNcmConnectionMultiplexer::SetReceivingStateForMediaL

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

//

EXPORT_C void CNcmConnectionMultiplexer::SetReceivingStateForMediaL(

    TUint aStreamId, TUint /*aConnectionId*/, TNATFWStreamingState aState )

    {

    switch( aState )

        {

        case EStreamingStatePassive:

            iObserver.Notify( SessionByStreamIdL( aStreamId )->SessionId(),

                        aStreamId,

                        MNcmConnectionMultiplexerObserver::

                        EReceivingDeactivated, KErrNone );

            break;

        case EStreamingStateActive:

            iObserver.Notify( SessionByStreamIdL( aStreamId )->SessionId(),

                        aStreamId,

                        MNcmConnectionMultiplexerObserver::

                        EReceivingActivated, KErrNone );

        default:

            break;

        }

    }

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

// From class MMultiplexerConnectionObserver

//

// CNcmConnectionMultiplexer::ConnectionError

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

//

void CNcmConnectionMultiplexer::ConnectionError(

    TUint /*aSessionId*/, TUint /*aStreamId*/, TUint /*aConnectionId*/,

    TMultiplexerConnectionNotifyType /*aNotifyType*/, TInt /*aError*/ )

    {

    }

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

// From class MMultiplexerSocketDestinationObserver

//

// CNcmConnectionMultiplexer::ConnectionNotify

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

//

void CNcmConnectionMultiplexer::ConnectionNotify( TUint /*aStreamId*/,

    TUint /*aConnectionId*/, TMultiplexerConnectionNotifyType /*aType*/,

    TInt /*aError*/ )

    {

    }

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