/*

* Copyright (c) 2006-2008 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, sending and receiving data from the

*                network and allows client to start media flow between

*                connection multiplexer and socket media connection wrapper. 

*

*/

#ifndef C_CNCMCONNECTIONMULTIPLEXER_H

#define C_CNCMCONNECTIONMULTIPLEXER_H

#include <e32base.h>

#include "natfwconnectivityapidefs.h"

#include "mncmmultiplexerconnectionobserver.h"

#include "mncmsessionobserver.h"

#include "mncmconnectionmultiplexer.h"

#include "mncmmediasourceobserver.h"

class TInetAddr;

class MNcmConnectionMultiplexerObserver;

class MNcmMultiplexerConnectionObserver;

class MNcmIncomingConnectionObserver;

class MNcmOutgoingConnectionObserver;

class MNATFWMediaWrapper;

class CNcmPortStore;

class CNcmConnectionObserverHandler;

class RSocket;

class RConnection;

class RSocketServ;

class CNcmSession;

class CNcmStream;

class MNATFWMediaWrapper;

class MNcmSenderObserver;

class CNcmCallBackExecuter;

/**

 *  Connection multiplexer is responsible for handling network

 *  connections, send and receive data from the network. It allows client

 *  to start data flow between connection multiplexer and socket media

 *  connection wrapper.

 *

 *  Connection Multiplexer have one session per IAP and in session can be

 *  multiple streams and in streams can be multiple connections.

 *

 *  @lib connectionmux.lib

 *  @since S60 v3.2

 */

class CNcmConnectionMultiplexer : public CBase,

    public MNcmConnectionMultiplexer,

    public MNcmMultiplexerConnectionObserver,

    public MNcmSessionObserver,

    public MNcmMediaSourceObserver

    {

    friend class UT_CNcmConnectionMultiplexer;

public:

    /** 

     * Two-phased constructor

     *

     * @param   aObserver      Observer for Connection Multiplexer

     */

    IMPORT_C static CNcmConnectionMultiplexer* NewL(

        MNcmConnectionMultiplexerObserver& aObserver );

    /** 

     * Destructor

     */

    virtual ~CNcmConnectionMultiplexer();

    /** 

     * Creates a new session. On return the client received identifier for

     * the session. The session is ready to be used when the client receives

     * MNcmConnectionMultiplexerObserver::Notify callback with event code 

     * ESessionCreated.

     *

     * @since   S60 v3.2

     * @param   aIapId              The IAP used for a conection

     * @param   aPortRangeStart     Port range start for session

     * @param   aPortRangeStop      Port range stop for session

     * @return  The ID for the created session.

     */

    IMPORT_C TUint CreateSessionL( TUint32 aIapId, TUint aPortRangeStart,

        TUint aPortRangeStop );

    /**

     * Creates a new stream.

     *

     * This is done synchronously.

     *

     * @since   S60 v3.2

     * @param   aSessionId      The ID identifying session

     * @param   aQos            The desired quality of service

     * @param   aProtocol       The protocol to be used,

     *                          KProtocolInetUdp / KProtocolInetTcp

     * @return  The ID for the created stream.

     */

    IMPORT_C TUint CreateStreamL( TUint aSessionId, TInt aQos,

        TUint aProtocol );

    /** 

     * Removes session and all its streams and streams connections

     *

     * This is done synchronously.  

     *

     * @since   S60 v3.2

     * @param   aSessionId      The ID identifying session

     * @return  void

     */

    IMPORT_C void RemoveSessionL( TUint aSessionId );

    /** 

     * Removes stream and all its connections.

     *

     * This is done synchronously.

     *

     * @since   S60 v3.2

     * @param   aStreamId     The ID identifying stream

     * @return  void

     */

    IMPORT_C void RemoveStreamL( TUint aStreamId );

    /**

     * Registers a media wrapper into stream. Ownership of wrapper is

     * also transferred to Connection Multiplexer.

     *

     * @since   S60 v3.2

     * @param   aMediaWrapper   Pointer to Socket Media Connection Wrapper

     * @return  void

     */

    IMPORT_C void RegisterMediaWrapperL( MNATFWMediaWrapper* aMediaWrapper );

    /**

     * Receives port store associated to session

     *

     * @since   S60 v3.2

     * @param   aSessionId    The ID identifying session

     * @return  Port store used on session

     */    

    IMPORT_C CNcmPortStore& PortStoreL( TUint aSessionId );

    /**

     * Gets the socket server handle and the unique name of

     * the RConnection used by the connection multiplexer session.

     *

     * @since   S60 v3.2

     * @param   aSessionId              The ID identifying session

     * @param   aConnectionName         The unique name of the RConnection

     * @return  handle to socket server   

     */

    IMPORT_C RSocketServ* GetSessionInfoL( TUint aSessionId, 

        TName& aConnectionName );  

    /**

     * Enables/disables media flow from Connection Multiplexer to 

     * Socket Media Connection Wrapper for the specified connection.

     *

     * The receiving is enabled/disabled when the client receives

     * MNcmConnectionMultiplexerObserver::Notify callback with event code 

     * EReceivingActivated/EReceivingDeactivated.

     * While incoming data from network is passed to Socket Media Connection

     * Wrapper if receiving for media is activated.

     *

     * @since   S60 v3.2

     * @param   aStreamId           The ID identifying stream

     * @param   aConnectionId       The ID identifying connection

     * @param   aState              The receiving state

     * @return  void

     */

    IMPORT_C void SetReceivingStateForMediaL( TUint aStreamId,

        TUint aConnectionId, TNATFWStreamingState aState );

    /**

     * Enables/disables media flow from Socket Media Connection Wrapper to 

     * Connection Multiplexer for the specified connection.

     *

     * The sending is enabled/disabled when the client receives

     * MNcmConnectionMultiplexerObserver::Notify callback with event code 

     * ESendingActivated/ESendingDeactivated. While incoming data from

     * Socket Media Connection Wrapper is delivered to specified connection

     * which is used to send media to network if sending for media is

     * activated.

     *

     * @since   S60 3.2

     * @param   aStreamId           The ID identifying stream

     * @param   aConnectionId       The ID identifying connection

     * @param   aState              The sending state

     * @return  void

     */

    IMPORT_C void SetSendingStateForMediaL( TUint aStreamId,

        TUint aConnectionId, TNATFWStreamingState aState );

    /**

     * Resolves the destination IP address from FQDN.

     * ( Address and port )

     * @since   S60 v3.2

     * @param   aStreamId      The ID identifying stream

     * @param   aAddress       The Destination FQDN

     * @param   aPort          The Destination port

     * @param   aResult        On return contains the resolved IP address

     * @return  void

     */

    IMPORT_C void ResolveDestinationAddressL( TUint aStreamId,

        const TDesC8& aAddress, TUint aPort, TInetAddr& aResult );

// from base class MNcmConnectionMultiplexer

    /**

     * Creates a new connection for stream. Will use same protocol as

     * used in stream. Address family specifies address family

     * which is used to choose whether IPv4 or IPv6 connection will be made.

     *

     * This is done synchronously.

     * 

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aAddrFamily     The address family(KAfInet/KAfInet6)

     *                          KAfInet, IPv4 local address is used

     *                          KAfInet6, IPv6 local address is used

     * @return  The ID for the created connection

     * @leave KErrNotSupported If specified local address hasn't found

     */

    IMPORT_C TUint CreateConnectionL( TUint aStreamId, TUint aAddrFamily );

    /**

     * Overloaded CreateConnectionL

     * Creates a new connection for stream. Will use same protocol as

     * used in stream. Connection is made by using specified local address.

     *

     * This is done synchronously.

     * 

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aLocalAddr      The specified local address.

     * @return  The ID for the created connection

     */

    IMPORT_C TUint CreateConnectionL( TUint aStreamId,

        const TInetAddr& aLocalAddr );

    /**

     * Removes the specified connection.

     * 

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aConnectionnId  The ID identifying connection

     * @return  void

     */

    IMPORT_C void RemoveConnectionL( TUint aStreamId, TUint aConnectionnId );

    /**

     * Fetches stream specific information which is formerly stored, while

     * stream was created

     *

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aIapId          IAP Id for session

     * @param   aQos            The quality of service

     * @param   aProtocol       KProtocolInetUdp / KProtocolInetTcp

     * @return  void

     */

    IMPORT_C void GetStreamInfoL( TUint aStreamId, TUint32& aIapId,

        TInt& aQos, TUint& aProtocol );

    /**

     * Returns the local IP address and port of specified connection.

     *

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aConnectionId   The ID identifying connection

     * @return  Local IP address

     */

    IMPORT_C TInetAddr& LocalIPAddressL( TUint aStreamId,

        TUint aConnectionId );

    /**

     * Establishes TCP connection. Connection will be established in specified

     * direction using given connection setup.

     *

     * MNcmConnectionObserver::ConnectionNotify is called with event code

     * ETcpSetupCompleted when connection setup is completed.

     * 

     * SetReceivingStateL/SetSendingStateL can be called normally after

     * successfull connection initialization.

     * 

     * @since   S60 3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aConnectionId   The ID identifying connection

     * @param   aConfig         TCP connection setup configuration

     * @param   aDestAddr       The destination address for active connection

     * @return  void

     */      

    IMPORT_C void OpenTcpConnectionL( TUint aStreamId, TUint aConnectionId,

        TNATFWTcpConnectionSetup aConfig, const TInetAddr& aDestAddr );

    /**

     * Closes TCP connection or cancels in-progress connection process.

     *

     * If TCP connection establishment is in-progress 

     * MNcmConnectionObserver::Notify is called with event code 

     * ETcpConnSetupCompleted and error code KErrCancel. 

     *

     * After successful connection closing SetupTcpConnectionL can be

     * called again with different destination address.

     * 

     * @since   S60 3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aConnectionId   The ID identifying connection

     * @return  void

     */

    IMPORT_C void CloseTcpConnection( TUint aStreamId, TUint aConnectionId );

    /**

     * Registers an observer for observing incoming messages in

     * specific stream. This method won't register observer again if

     * client have allready registered.

     *

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aObserver       Observer to be registered

     * @return  void

     */

    IMPORT_C void RegisterIncomingConnectionObserverL( TUint aStreamId,

        MNcmIncomingConnectionObserver& aObserver );

    /**

     * Registers an observer for outgoing messages in specific

     * stream. This method won't register observer again if

     * client have allready registered.

     *

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aObserver       Observer to be registered

     * @return  void

     */

    IMPORT_C void RegisterOutgoingConnectionObserverL( TUint aStreamId,

        MNcmOutgoingConnectionObserver& aObserver );

    /**

     * Unregisters specified observer.

     *

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aObserver       Observer to be unregistered

     * @return  void

     */

    IMPORT_C void UnregisterIncomingConnectionObserverL( TUint aStreamId,

        MNcmIncomingConnectionObserver& aObserver );

    /**

     *  Unregisters specified observer.

     *

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aObserver       Observer to be unregistered

     * @return  void

     */

    IMPORT_C void UnregisterOutgoingConnectionObserverL( TUint aStreamId,

        MNcmOutgoingConnectionObserver& aObserver );

    /**

     * Registers an observer for connection notifies.

     * This method won't register observer again if

     * client have allready registered.

     *

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aObserver       Observer to be registered

     * @return  void

     */

    IMPORT_C void RegisterConnectionObserverL( TUint aStreamId,

        MNcmConnectionObserver& aObserver );

    /**

     *  Unregisters specified observer.

     *

     * @since S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aObserver       Observer to be unregistered

     * @return void

     */

    IMPORT_C void UnregisterConnectionObserverL( TUint aStreamId,

        MNcmConnectionObserver& aObserver );

    /**

     * Registers an observer for receive incoming and outgoing message

     * notifications. All notifications are offered first to this observer.

     * There can be only one registered observer at a time.

     * Message observer is allowed to make modifications to offered

     * messages.

     *

     * @since   S60 v3.2

     * @param   aStreamId       The ID identifying stream

     * @param   aObserver       Observer to be registered

     * @return  void

     */

    IMPORT_C void RegisterMessageObserverL( TUint aStreamId,

        MNcmMessageObserver& aObserver );

    /**

     * Unregisters an observer for receiving incoming and outgoing message

     * notifications.

     *

     * @since S60 v3.2

     * @param aStreamId A stream ID

     * @param aObserver to be unregistered

     * @return void

     */

    IMPORT_C void UnregisterMessageObserverL( TUint aStreamId,

        MNcmMessageObserver& aObserver );

    /**

     * Sends a message from specified connection to network.

     *

     * @since   S60 v3.2

     * @param   aStreamId           The ID identifying stream

     * @param   aConnectionId       The ID identifying connection

     * @param   aMessage            A message to be copied and

     *                              then sent asynchronously.

     * @param   aSenderObserver     Observer for this send.

     * @return  void

     */

    IMPORT_C void SendL( TUint aStreamId, TUint aConnectionId,

        const TDesC8& aMessage, MNcmSenderObserver* aSenderObserver = NULL );

    /**

     * Overloaded SendL

     * Sends a message from specified connection to network. 

     * Destination address parameter tells

     * the destination address for the message. 

     *

     * @since   S60 v3.2

     * @param   aStreamId               The ID identifying stream

     * @param   aConnectionId           The ID identifying conenction

     * @param   aMessage                A message to be copied and

     *                                  then sent asynchronously.

     * @param   aDestinationAddress     Destination address

     * @param   aSenderObserver         Observer for this send.

     * @return  void

     */

    IMPORT_C void SendL( TUint aStreamId, TUint aConnectionId,

        const TDesC8& aMessage, const TInetAddr& aDestinationAddress,

        MNcmSenderObserver* aSenderObserver = NULL );

    /**

     * Overloaded SendL

     * Sends a message from connection which is found by next hop address.

     * Destination address parameter tells the destination address for

     * the message. 

     *

     * @since   S60 v3.2

     * @param   aStreamId               The ID identifying stream

     * @param   aMessage                A message

     * @param   aNextHopAddress         Specifies the IP address of the next

     *                                  hop in the route

     *                                  will be used to find connection which

     *                                  will be used for sending.

     * @param   aDestinationAddress     Destination address.

     * @return  void

     */

    IMPORT_C void SendL( TUint aStreamId, const TDesC8& aMessage,

        const TInetAddr& aNextHopAddress,

        const TInetAddr& aDestinationAddress );

    /**

     * Overloaded SendL

     * Sends a message directly from connection. Will not offer this

     * message to any registered observers if aSendDirectly is set to

     * ETrue

     *

     * @since   S60 v3.2

     * @param   aStreamId           The ID identifying stream

     * @param   aConnectionId       The ID identifying conenction

     * @param   aMessage            A message

     * @param   aSendDirectly       if ETrue sends a message directly.

     *                              Will not offer this message to any

     *                              registered observers.

     *                              normally and will be offered registered

     *                              observers.

     * @param   aSenderObserver     Observer for this send.

     * @return  void

     */

    IMPORT_C void SendL( TUint aStreamId, TUint aConnectionId,

        const TDesC8& aMessage, TBool aSendDirectly,

        MNcmSenderObserver* aSenderObserver = NULL );

    /**

     * Cancels sender observer's message send processes.

     *

     * Client MUST call its destructor on this method and cancel all send

     * processes which it is observing( Client have used SendL with 

     * sender observer param ), otherwise there can be panic.

     *

     * @since   S60 v3.2

     * @param   aStreamId           The ID identifying stream

     * @param   aConnectionId       The ID identifying connection         

     * @param   aSenderObserver     Observer which observing

     *                              message send processes 

     * @return  void

     */

     IMPORT_C void CancelMessageSend( TUint aStreamId, TUint aConnectionId,

        const MNcmSenderObserver* aSenderObserver );

    /**

     * Enables/disables data receiving for the specified connection.

     *

     * MNcmConnectionObserver::ConnectionNotify is called with event code

     * EReceivingActivated/EReceivingDeactivated when status change

     * has completed. While incoming data is received from network.

     *