/*
* Copyright (c) 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:   
*
*/




#include "mnatfwsocketmediaconnwrapper.h"
#include "mnatfwconnectivityobserver.h"
#include "natfwpluginapi.h"
#include "natfwstream.h"
#include "natfwsession.h"
#include "mnatfwregistrationcontroller.h"
#include "natfwsocketmediaconnwrapper.h"
#include "cncmconnectionmultiplexer.h"
#include "cncmportstore.h"
#include "cnatfwasynccallback.h"
#include "natfwclientlogs.h"

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

// ---------------------------------------------------------------------------
// CNATFWStream::CNATFWStream
// ---------------------------------------------------------------------------
//
CNATFWStream::CNATFWStream(
        MNATFWRegistrationController& aController,
        CNcmConnectionMultiplexer& aMultiplexer,
        CNatFwAsyncCallback& aAsyncCallback,
        CNATFWSession& aContext,
        TUint aProtocol, TInt aQoS )
    :
    iQoS( aQoS ),
    iProtocol( aProtocol ),
    iController( aController ),
    iMultiplexer( aMultiplexer ),
    iAsyncCallback( aAsyncCallback ),
    iContext( aContext )
    {
    }


// ---------------------------------------------------------------------------
// CNATFWStream::ConstructL
// ---------------------------------------------------------------------------
//
void CNATFWStream::ConstructL()
    {
    iStreamId = iMultiplexer.CreateStreamL( iContext.SessionId(),
        iQoS, iProtocol );
    }


// ---------------------------------------------------------------------------
// CNATFWStream::NewL
// ---------------------------------------------------------------------------
//
CNATFWStream* CNATFWStream::NewL(
        MNATFWRegistrationController& aController,
        CNcmConnectionMultiplexer& aMultiplexer,
        CNatFwAsyncCallback& aAsyncCallback,
        CNATFWSession& aContext,
        TUint aProtocol, TInt aQoS )
    {
    CNATFWStream* self = CNATFWStream::NewLC( aController, aMultiplexer,
        aAsyncCallback, aContext, aProtocol, aQoS );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CNATFWStream::NewLC
// ---------------------------------------------------------------------------
//
CNATFWStream* CNATFWStream::NewLC(
        MNATFWRegistrationController& aController,
        CNcmConnectionMultiplexer& aMultiplexer,
        CNatFwAsyncCallback& aAsyncCallback,
        CNATFWSession& aContext,
        TUint aProtocol, TInt aQoS )
    {
    CNATFWStream* self = new ( ELeave ) CNATFWStream( aController,
        aMultiplexer, aAsyncCallback, aContext, aProtocol, aQoS );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// ---------------------------------------------------------------------------
// CNATFWStream::~CNATFWStream
// ---------------------------------------------------------------------------
//
CNATFWStream::~CNATFWStream()
    {
    __NATFWCLIENT("CNATFWStream::~CNATFWStream")

    iPlugin = NULL;
    TInt err = KErrNone;
    TRAP( err, iMultiplexer.RemoveStreamL( iStreamId ) );

    __NATFWCLIENT_INT1( "CNATFWStream::~CNATFWStream end, ERR:", err )
    }


// Non-derived function

// ---------------------------------------------------------------------------
// Return unique identifier of the stream.
// ---------------------------------------------------------------------------
//
TUint CNATFWStream::StreamId() const
    {
    return iStreamId;
    }

// Derived function

// ---------------------------------------------------------------------------
// CNATFWStream::CreateWrapperL
// ---------------------------------------------------------------------------
//
MNATFWSocketMediaConnWrapper& CNATFWStream::CreateWrapperL( )
    {
    __NATFWCLIENT("CNATFWStream::CreateWrapperL")

    CNATFWSocketMediaConnWrapper* wrapper =
        CNATFWSocketMediaConnWrapper::NewL(
        iMultiplexer.PortStoreL( iContext.SessionId() ).Port(),
        iProtocol, iStreamId );

    // Ownership transfered to Connection Multiplexer
    iMultiplexer.RegisterMediaWrapperL( wrapper );
    return *wrapper;
    }

// ---------------------------------------------------------------------------
// CNATFWStream::SetProtocolPlugin
// ---------------------------------------------------------------------------
//
void CNATFWStream::SetProtocolPlugin( CNATFWPluginApi* aPlugin )
    {
    __NATFWCLIENT("CNATFWStream::SetProtocolPlugin")
    iPlugin = aPlugin;
    }


// ---------------------------------------------------------------------------
// CNATFWStream::FetchCandidateL
// ---------------------------------------------------------------------------
//
void CNATFWStream::FetchCandidateL( TUint aAddrFamily )
    {
    __NATFWCLIENT("CNATFWStream::FetchCandidateL")
    __ASSERT_ALWAYS( iPlugin, User::Leave( KErrNotReady ) );

    iPlugin->FetchCandidateL( iStreamId, 0, aAddrFamily );
    }


// ---------------------------------------------------------------------------
// CNATFWStream::FetchCandidatesL
// ---------------------------------------------------------------------------
//
void CNATFWStream::FetchCandidatesL( TUint aCollectionId,
        TUint aComponentId, TUint aAddrFamily )
    {
    __NATFWCLIENT("CNATFWStream::FetchCandidatesL")
    __ASSERT_ALWAYS( iPlugin, User::Leave( KErrNotReady ) );

    iPlugin->FetchCandidatesL( 
        aCollectionId, iStreamId, aComponentId, aAddrFamily );
    }


// ---------------------------------------------------------------------------
// CNATFWStream::SetCredentialsL
// ---------------------------------------------------------------------------
//
void CNATFWStream::SetCredentialsL(
    const CNATFWCandidate& aCandidate,
    const CNATFWCredentials& aCredentials )
    {
    __NATFWCLIENT("CNATFWStream::SetCredentialsL")
    __ASSERT_ALWAYS( iPlugin, User::Leave( KErrNotReady ) );

    iPlugin->SetCredentialsL( aCandidate, aCredentials );
    }


// ---------------------------------------------------------------------------
// CNATFWStream::SetReceivingStateL
// ---------------------------------------------------------------------------
//
void CNATFWStream::SetReceivingStateL( 
        const CNATFWCandidate& aLocalCandidate,
        TNATFWStreamingState aState )
    {
    TUint connectionForMedia( 0 );
    iPlugin->GetConnectionIdL( aLocalCandidate, connectionForMedia );

    iPlugin->SetReceivingStateL( aLocalCandidate, aState );
    iMultiplexer.SetReceivingStateForMediaL( 
        iStreamId, connectionForMedia, aState );
    }


// ---------------------------------------------------------------------------
// CNATFWStream::SetSendingStateL
// ---------------------------------------------------------------------------
//
void CNATFWStream::SetSendingStateL(
        const CNATFWCandidate& aLocalCandidate,
        TNATFWStreamingState aState, const TInetAddr& aDestAddr )
    {
    iDestAddr = aDestAddr;
    TUint connectionForMedia( 0 );
    iPlugin->GetConnectionIdL( aLocalCandidate, connectionForMedia );

    iPlugin->SetSendingStateL( aLocalCandidate, aState, aDestAddr );
    iMultiplexer.SetSendingStateForMediaL(
        iStreamId, connectionForMedia, aState );
    }


// ---------------------------------------------------------------------------
// CNATFWStream::Notify
// ---------------------------------------------------------------------------
//
void CNATFWStream::Notify( TUint aSessionId, TUint aStreamId,
    MNcmConnectionMultiplexerObserver::TNotifyType aType, TInt aError )
    {
    __NATFWCLIENT_INT2(
        "CNATFWStream::Notify, SESSION:", aSessionId, "STREAM:", aStreamId )

    switch ( aType )
        {
        case MNcmConnectionMultiplexerObserver::EReceivingActivated:
            {
            __NATFWCLIENT_INT1(
                "CNATFWStream::Notify, EReceivingActivated, ERR:", aError )

            DoNotify( aSessionId, aStreamId,
                MNATFWConnectivityObserver::EReceivingActivated, aError );
            }
            break;

        case MNcmConnectionMultiplexerObserver::EReceivingDeactivated:
            {
            __NATFWCLIENT_INT1(
                "CNATFWStream::Notify, EReceivingDeactivated, ERR:", aError )

            DoNotify( aSessionId, aStreamId,
                MNATFWConnectivityObserver::EReceivingDeactivated, aError );
            }
            break;

        case MNcmConnectionMultiplexerObserver::ESendingActivated:
            {
            __NATFWCLIENT_INT1(
                "CNATFWStream::Notify, ESendingActivated, ERR:", aError )

            DoNotify( aSessionId, aStreamId,
                MNATFWConnectivityObserver::ESendingActivated, aError );
            }
            break;

        case MNcmConnectionMultiplexerObserver::ESendingDeactivated:
            {
            __NATFWCLIENT_INT1(
                "CNATFWStream::Notify, ESendingDeactivated, ERR:", aError )

            DoNotify( aSessionId, aStreamId,
                MNATFWConnectivityObserver::ESendingDeactivated, aError );
            }
            break;

        case MNcmConnectionMultiplexerObserver::EStreamError:
            {
            __NATFWCLIENT_INT1(
                "CNATFWStream::Notify, EStreamError, ERR:", aError )

            DoNotify( aSessionId, aStreamId,
                MNATFWConnectivityObserver::EGeneralError, aError );
            }
            break;

        default:
            __NATFWCLIENT("CNATFWStream::Notify, DEFAULT")

            ASSERT( EFalse );
            break;
        }
    }


// ---------------------------------------------------------------------------
// CNATFWStream::DoNotify
// ---------------------------------------------------------------------------
//
void CNATFWStream::DoNotify( TUint aSessionId, TUint aStreamId,
    MNATFWConnectivityObserver::TNATFWConnectivityEvent aEvent, TInt aError )
    {

    CNatFwCallbackInfo::TFunction func =
        static_cast<CNatFwCallbackInfo::TFunction>( aEvent );

    TRAP_IGNORE( iAsyncCallback.MakeCallbackL( iController, func,
        aSessionId, aStreamId, aError, NULL ) )
    }