/*

* 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 <badesca.h>

#include "natfwpluginapi.h"

#include "mnatfwconnectivityobserver.h"

#include "natfwcandidatepair.h"

#include "natfwcandidate.h"

#include "natfwsession.h"

#include "natfwstream.h"

#include "mnatfwregistrationcontroller.h"

#include <cnatfwsettingsapi.h>

#include "natfwclientlogs.h"

#include "cncmconnectionmultiplexer.h"

#include "cnatfwasynccallback.h"

const TUint KSendingActivationsNeeded = 2;

const TUint KReceivingActivationsNeeded = 2;

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

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

// CNATFWSession::CNATFWSession

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

//

CNATFWSession::CNATFWSession( CNcmConnectionMultiplexer& aMultiplexer,

        MNATFWRegistrationController& aController,

        CNatFwAsyncCallback& aAsyncCallback,

        TUint32 aIapId )

    :

    iIapId( aIapId ),

    iController( aController ),

    iMultiplexer( aMultiplexer ),

    iAsyncCallback( aAsyncCallback ),

    iServerConnectionState( EConnectionUnspecified )

    {

    }

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

// CNATFWSession::ConstructL

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

//

void CNATFWSession::ConstructL( const TDesC8& aDomain )

    {

    iDomain = aDomain.AllocL();

    TUint startPort( 0 );

    TUint endPort( 0 );

    iNatSettings = CNATFWNatSettingsApi::NewL( aDomain );

    iNatSettings->GetPortArea( startPort, endPort );

    iSessionId = iMultiplexer.CreateSessionL( iIapId, startPort, endPort );

    }

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

// CNATFWSession::NewL

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

//

CNATFWSession* CNATFWSession::NewL( CNcmConnectionMultiplexer& aMultiplexer,

        MNATFWRegistrationController& aController,

        CNatFwAsyncCallback& aAsyncCallback,

        const TDesC8& aDomain,

        TUint32 aIapId )

    {

    CNATFWSession* self =

        CNATFWSession::NewLC( aMultiplexer, aController, aAsyncCallback,

            aDomain, aIapId );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNATFWSession::NewLC

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

//

CNATFWSession* CNATFWSession::NewLC( CNcmConnectionMultiplexer& aMultiplexer,

        MNATFWRegistrationController& aController,

        CNatFwAsyncCallback& aAsyncCallback,

        const TDesC8& aDomain,

        TUint32 aIapId )

    {

    CNATFWSession* self = new ( ELeave ) CNATFWSession( aMultiplexer,

        aController, aAsyncCallback, aIapId );

    CleanupStack::PushL( self );

    self->ConstructL( aDomain );

    return self;

    }

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

// Destructor

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

//

CNATFWSession::~CNATFWSession()

    {

    iSendingStatusCounts.Close();

    iReceivingStatusCounts.Close();

    iFetchCandidateQueue.Close();

    iStreams.ResetAndDestroy();

    delete iDomain;

    delete iPlugin;

    delete iNatSettings;

    REComSession::FinalClose();

    TInt err = KErrNone;

    TRAP( err, iMultiplexer.RemoveSessionL( iSessionId ) );

    __NATFWCLIENT_INT1("CNATFWSession::~CNATFWSession, ERR:", err )

    }

// Non-derived function

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

// CNATFWSession::LoadPluginL()

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

//

void CNATFWSession::LoadPluginL( const CDesC8Array& aPlugins,

        TInt& aLoadedPluginInd )

    {

    __NATFWCLIENT("CNATFWSession::LoadPluginL")

    __ASSERT_ALWAYS( aPlugins.Count(), User::Leave( KErrArgument ) );

    CNATFWPluginApi::TNATFWPluginInitParams

        initParams( *this, iMultiplexer, *iDomain, iIapId );

    TInt error( KErrNotFound );

    TInt count( aPlugins.Count() );

    TInt index( 0 );

    delete iPlugin;

    iPlugin = NULL;

    while ( !iPlugin && index < count )

        {

        TRAP( error, iPlugin =

            CNATFWPluginApi::NewL( aPlugins[index], initParams ) );

        index++;

        }

    TInt ind( iStreams.Count() );

    while ( ind-- )

        {

        iStreams[ind]->SetProtocolPlugin( iPlugin );

        }

    User::LeaveIfError( error );

    aLoadedPluginInd = --index;

    RSocketServ* socketServ = NULL;

    TName connectionName;

    socketServ = iMultiplexer.GetSessionInfoL( iSessionId, connectionName );

    iPlugin->ConnectServerL( *socketServ, connectionName );

    iServerConnectionState = EConnectionInProgress;

    __NATFWCLIENT("CNATFWSession::LoadPluginL Exit")

    }

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

// CNATFWSession::FetchCandidateL

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

//

void CNATFWSession::FetchCandidateL( TUint aStreamId, TUint aAddrFamily )

    {

    __ASSERT_ALWAYS( iServerConnectionState != EConnectionUnspecified,

        User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS( iServerConnectionState != EConnectionFailed,

        User::Leave( KErrNotReady ) );

    if ( iServerConnectionState == EConnectionConnected )

        {

        StreamByIdL( aStreamId )->FetchCandidateL( aAddrFamily );

        }

    else

        {

        TFetchingData data( aStreamId, 0, 0, aAddrFamily, EFalse );

        iFetchCandidateQueue.InsertL( data, 0 );

        }

    }

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

// CNATFWSession::FetchCandidatesL

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

//

void CNATFWSession::FetchCandidatesL( TUint aStreamId, TUint aCollectionId,

        TUint aComponentId, TUint aAddrFamily )

    {

    __ASSERT_ALWAYS( iServerConnectionState != EConnectionUnspecified,

        User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS( iServerConnectionState != EConnectionFailed,

        User::Leave( KErrNotReady ) );

    if ( iServerConnectionState == EConnectionConnected )

        {

        StreamByIdL( aStreamId )->FetchCandidatesL(

            aCollectionId, aComponentId, aAddrFamily );

        }

    else

        {

        TFetchingData data( aStreamId, aCollectionId,

            aComponentId, aAddrFamily, ETrue );

        iFetchCandidateQueue.InsertL( data, 0 );

        }

    }

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

// CNATFWSession::SessionId

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

//

TUint CNATFWSession::SessionId() const

    {

    __NATFWCLIENT("CNATFWSession::SessionId")

    return iSessionId;

    }

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

// CNATFWSession::CreateStreamL

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

//

TUint CNATFWSession::CreateStreamL(

        TUint aProtocol, TInt aQoS )

    {

    __NATFWCLIENT("CNATFWSession::CreateStreamL")

    CNATFWStream* stream = CNATFWStream::NewL( iController, iMultiplexer,

        iAsyncCallback, *this, aProtocol, aQoS );

    CleanupStack::PushL( stream );

    iStreams.AppendL( stream );

    stream->SetProtocolPlugin( iPlugin );

    CleanupStack::Pop( stream );

    return stream->StreamId();

    }

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

// CNATFWSession::SetRoleL

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

//

void CNATFWSession::SetRoleL( TNATFWIceRole aRole )

    {

    __NATFWCLIENT("CNATFWSession::SetRoleL")

    iPlugin->SetRoleL( aRole );

    }

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

// CNATFWSession::PerformConnectivityChecksL

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

//

void CNATFWSession::PerformConnectivityChecksL(

        RPointerArray<CNATFWCandidate>& aRemoteCandidates )

    {

    __NATFWCLIENT("CNATFWSession::PerformConnectivityChecksL")

    iPlugin->PerformConnectivityChecksL( aRemoteCandidates );

    }

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

// CNATFWSession::UpdateIceProcessingL

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

//

void CNATFWSession::UpdateIceProcessingL(

        RPointerArray<CNATFWCandidatePair>& aPeerSelectedPairs )

    {

    iPlugin->UpdateIceProcessingL( aPeerSelectedPairs );

    }

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

// CNATFWSession::UpdateIceProcessingL

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

//

void CNATFWSession::UpdateIceProcessingL(

        RPointerArray<CNATFWCandidate>& aRemoteCands )

    {

    iPlugin->UpdateIceProcessingL( aRemoteCands );

    }

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

// CNATFWSession::CloseStream

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

//

void CNATFWSession::CloseStreamL( TUint aStreamId )

    {

    __NATFWCLIENT("CNATFWSession::CloseStreamL")

    CNATFWStream* stream = StreamByIdL( aStreamId );

    iStreams.Remove( iStreams.FindL( stream ) );

    delete stream;

    }

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

// CNATFWSession::StreamById

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

//

CNATFWStream* CNATFWSession::StreamById( TUint aStreamId )

    {

    __NATFWCLIENT("CNATFWSession::StreamById")

    TInt ind( iStreams.Count() );

    while ( ind-- )

        {

        if ( iStreams[ind]->StreamId() == aStreamId )

            {

            return iStreams[ind];

            }

        }

    return NULL;

    }

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

// CNATFWSession::StreamByIdL

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

//

CNATFWStream* CNATFWSession::StreamByIdL( TUint aStreamId )

    {

    __NATFWCLIENT("CNATFWSession::StreamByIdL")

    CNATFWStream* stream = StreamById( aStreamId );

    if ( !stream )

        {

        User::Leave( KErrNotFound );

        }

    return stream;

    }

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

// From class MNATFWPluginObserver.

// CNATFWSession::Error

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

//

void CNATFWSession::Error( const CNATFWPluginApi& /*aPlugin*/,

        TUint aStreamId, TInt aErrorCode )

    {

    __NATFWCLIENT("CNATFWSession::Error")

    DoNotify( aStreamId, MNATFWConnectivityObserver::EGeneralError,

        aErrorCode, NULL );

    }

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

// From class MNATFWPluginObserver.

// CNATFWSession::Notify

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

//

void CNATFWSession::Notify( const CNATFWPluginApi& /*aPlugin*/,

        TUint aStreamId, TNATFWPluginEvent aEvent, TInt aErrCode )

    {

    __NATFWCLIENT("CNATFWSession::Notify")

    // Activation notify must be waited from both plugin

    // and mediastream before notifying NATFW client

    switch ( aEvent )

        {

        case MNATFWPluginObserver::EServerConnected:

            {

            __NATFWCLIENT_INT1(

                "CNATFWSession::Notify EServerConnected, ERR:", aErrCode )

            if ( KErrNone != aErrCode )

                {

                iServerConnectionState = EConnectionFailed;

                }

            else

                {

                iServerConnectionState = EConnectionConnected;

                }

            HandleQueuedItems();

            }

            break;

        case MNATFWPluginObserver::ESendingActivated:

            {

            __NATFWCLIENT_INT1(

                "CNATFWSession::Notify ESendingActivated, ERR:", aErrCode )

            TInt index = iSendingStatusCounts.Count() - 1;

            TInt foundStreamInd( KErrNotFound );

            while ( 0 <= index && KErrNotFound == foundStreamInd )

                {

                if ( aStreamId == iSendingStatusCounts[index].iStreamId )

                    {

                    foundStreamInd = index;

                    if ( KErrNone != aErrCode )

                        {

                        iSendingStatusCounts[foundStreamInd].iErrorOccurred

                            = ETrue;

                        }

                    iSendingStatusCounts[foundStreamInd].iActivatedCount++;

                    }

                index--;

                }

            if ( KErrNotFound != foundStreamInd )

                {

                if ( KSendingActivationsNeeded ==

                    iSendingStatusCounts[foundStreamInd].iActivatedCount )

                    {

                    // The second notify for current stream's sending

                    // activation has occurred so NATFW Stream can be

                    // notified

                    CNATFWStream* stream = StreamById( aStreamId );

                    if ( stream )

                        {

                        if ( iSendingStatusCounts[foundStreamInd].

                            iErrorOccurred )

                            {

                            // Reset the error occurred flag

                            iSendingStatusCounts[foundStreamInd].iErrorOccurred

                                = EFalse;

                            // Do notification with error code

                            stream->Notify( iSessionId, aStreamId,

                                MNcmConnectionMultiplexerObserver::

                                    ESendingActivated, KErrGeneral );

                            }

                        else

                            {

                            stream->Notify( iSessionId, aStreamId,

                                MNcmConnectionMultiplexerObserver::

                                    ESendingActivated, KErrNone );

                            }

                        }

                    }

                }

            else

                {

                // The first notify for stream's sending activation has

                // occurred so store stream's status data in array

                TStatusCounter sendingActivated;

                sendingActivated.iActivatedCount++;

                sendingActivated.iStreamId = aStreamId;

                if ( KErrNone != aErrCode )

                    {

                    sendingActivated.iErrorOccurred = ETrue;

                    }

                iSendingStatusCounts.Append( sendingActivated );

                }

            }

            break;

        case MNATFWPluginObserver::ESendingDeactivated:

            {

            __NATFWCLIENT_INT1(

                "CNATFWSession::Notify ESendingDeactivated, ERR:", aErrCode )

            TInt index = iSendingStatusCounts.Count() - 1;

            TInt foundStreamInd( KErrNotFound );

            while ( 0 <= index && KErrNotFound == foundStreamInd )

                {

                if ( aStreamId == iSendingStatusCounts[index].iStreamId &&

                    iSendingStatusCounts[index].iActivatedCount != 0 )

                    {

                    foundStreamInd = index;

                    if ( aErrCode != KErrNone )

                        {

                        iSendingStatusCounts[foundStreamInd].iErrorOccurred

                            = ETrue;

                        }

                    iSendingStatusCounts[foundStreamInd].iActivatedCount--;

                    }

                index--;

                }

            if ( KErrNotFound != foundStreamInd )

                {

                if ( 0 == iSendingStatusCounts[foundStreamInd].

                    iActivatedCount )

                    {

                    CNATFWStream* stream = StreamById( aStreamId );

                    if ( stream )

                        {

                        if ( iSendingStatusCounts[foundStreamInd].

                            iErrorOccurred )

                            {

                            // Reset the error occurred flag

                            iSendingStatusCounts[foundStreamInd].iErrorOccurred

                                = EFalse;