/*
* Copyright (c) 2006-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 "stunassert.h"
#include "natfwstunrelaybinding.h"
#include "cstunrelaybindingimplementation.h"
#include "natfwstunclient.h"
#include "cstunclientimplementation.h"
#include "ut_cnatfwturnconnectionhandler.h"


const TInt KRtoValueUsedInRefreshTest = 555;

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

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CSTUNRelayBinding* CSTUNRelayBinding::NewL( CSTUNClient& aSTUNClient, 
                                                     TUint aStreamId, 
                                                     TUint aConnectionId )
    {
    __ASSERT_ALWAYS( aSTUNClient.IsInitialized(), User::Leave( KErrNotReady ) );
    CSTUNRelayBinding* self = CSTUNRelayBinding::NewLC( aSTUNClient,
                                                        aStreamId,
                                                        aConnectionId );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::NewLC
// ---------------------------------------------------------------------------
//
EXPORT_C CSTUNRelayBinding* CSTUNRelayBinding::NewLC( CSTUNClient& aSTUNClient, 
                                                      TUint aStreamId, 
                                                      TUint aConnectionId )
    {
    CSTUNRelayBinding* self = new ( ELeave ) CSTUNRelayBinding();
    CleanupStack::PushL( self );
    self->ConstructL( aSTUNClient, aStreamId, aConnectionId );
    return self;
    }
    
// ---------------------------------------------------------------------------
// CSTUNRelayBinding::CSTUNRelayBinding
// ---------------------------------------------------------------------------
//
CSTUNRelayBinding::CSTUNRelayBinding()
    {
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::CSTUNRelayBinding
// Dummy implementation, as copy constructor is declared private and not used.
// ---------------------------------------------------------------------------
//
CSTUNRelayBinding::CSTUNRelayBinding( const CBinding& /*aBinding*/ )
    {
    }


// ---------------------------------------------------------------------------
// CSTUNRelayBinding::ConstructL - overloaded
// ---------------------------------------------------------------------------
//
void CSTUNRelayBinding::ConstructL( CSTUNClient& /*aSTUNClient*/,
                                    TUint /*aStreamId*/,
                                    TUint /*aConnectionId*/ ) 
    {
/*    __ASSERT_ALWAYS( aSTUNClient.Implementation().MultiplexerInstance(), 
                     User::Leave( KErrBadHandle ) );
    iImplementation =
        CSTUNRelayBindingImplementation::NewL( *this,
                       aSTUNClient.Implementation(),
                       aStreamId,
                       aConnectionId,
                       aSTUNClient.Implementation().MultiplexerInstance() );*/
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::ConstructL
// ---------------------------------------------------------------------------
//
void CSTUNRelayBinding::ConstructL( CSTUNClient& /*aSTUNClient*/,
                                    RSocket& /*aSocket*/ )
    {
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::~CSTUNRelayBinding
// ---------------------------------------------------------------------------
//
EXPORT_C CSTUNRelayBinding::~CSTUNRelayBinding()
    {
//    delete iImplementation;
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::CancelRequest
// ---------------------------------------------------------------------------
//
EXPORT_C void CSTUNRelayBinding::CancelRequest()
    {
//    Implementation().CancelRequest();
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::AllocateRequestL
// ---------------------------------------------------------------------------
//
EXPORT_C void CSTUNRelayBinding::AllocateRequestL( TUint aRtoValue )
    {
//    Implementation().AllocateRequestL();

    if ( KRtoValueUsedInRefreshTest == aRtoValue )
        {
        if ( UT_CNATFWTurnConnectionHandler::iActiveSchedulerWait.IsStarted() )
            {
            UT_CNATFWTurnConnectionHandler::iActiveSchedulerWait.AsyncStop();
            }
        }
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::AddressResolved
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CSTUNRelayBinding::AddressResolved() const
    {
    return ETrue;
//    return Implementation().AddressResolved();
    }
        
// ---------------------------------------------------------------------------
// CSTUNRelayBinding::PublicAddr
// ---------------------------------------------------------------------------
//
EXPORT_C const TInetAddr& CSTUNRelayBinding::PublicAddr() const
    {    
//    return Implementation().PublicAddr();
    return KInetAddrAny;
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::RelayAddr
// ---------------------------------------------------------------------------
//
EXPORT_C const TInetAddr& CSTUNRelayBinding::RelayAddr() const
    {
//    return Implementation().RelayAddr();
    return KInetAddrAny;
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::HandleDataL
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* CSTUNRelayBinding::HandleDataL( const TDesC8& /*aData*/, 
    TBool& /*aConsumed*/, TInetAddr& /*aRemoteAddr*/ )
    {
    HBufC8* buffer = NULL;
//    return Implementation().HandleDataL( aData, aConsumed, aRemoteAddr );
    return buffer;
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::SetICESpecificAttributes
// ---------------------------------------------------------------------------
//
EXPORT_C void CSTUNRelayBinding::SetICESpecificAttributes( 
    const TICEAttributes& /*aAttributes*/ )
    {
//    Implementation().SetICESpecificAttributes( aAttributes );
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::SetActiveDestinationRequestL
// ---------------------------------------------------------------------------
//
EXPORT_C void CSTUNRelayBinding::SetActiveDestinationRequestL( 
    const TInetAddr& /*aRemoteAddr*/, TUint32& /*aTimerValue*/ )
    {
//    Implementation().SetActiveDestinationRequestL( aRemoteAddr, aTimerValue );
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::SendIndicationL
// ---------------------------------------------------------------------------
//
EXPORT_C void CSTUNRelayBinding::SendIndicationL( 
    const TInetAddr& /*aRemoteAddr*/, const TDesC8& /*aData*/, TBool /*aAddFingerprint*/ )
    {
//    Implementation().SendIndicationL( aRemoteAddr, aData );
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::ConnectRequestL
// ---------------------------------------------------------------------------
//
EXPORT_C void CSTUNRelayBinding::ConnectRequestL( const TInetAddr& /*aRemoteAddr*/ )
    {
//    Implementation().ConnectRequestL( aRemoteAddr );
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::StreamId
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CSTUNRelayBinding::StreamId() const
    {
//    return Implementation().StreamId();
    return 222;
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::ConnectionId
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CSTUNRelayBinding::ConnectionId() const
    {
    return 2;
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::STUNClient
// ---------------------------------------------------------------------------
//
EXPORT_C const CSTUNClient* CSTUNRelayBinding::STUNClient() const
    {
    CSTUNClient* client = NULL;
//    return Implementation().STUNClient();
    return client;
    }    

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::AlternateServerAddr
// ---------------------------------------------------------------------------
//
EXPORT_C const TInetAddr& CSTUNRelayBinding::AlternateServerAddr() const
    {    
    return TInetAddr();
    }
    
// ---------------------------------------------------------------------------
// CSTUNRelayBinding::RealmFromResponse
// ---------------------------------------------------------------------------
//
EXPORT_C const HBufC8* CSTUNRelayBinding::RealmFromResponse() const
    {    
//    return Implementation().RealmFromResponse();
    return NULL;
    }
    
// ---------------------------------------------------------------------------
// CSTUNRelayBinding::Implementation
// ---------------------------------------------------------------------------
//
CBindingImplementation& CSTUNRelayBinding::Implementation()
    {
//    __TEST_INVARIANT;

//    return *iImplementation;
    CBindingImplementation* impl = NULL;
    return *impl;
    }

// ---------------------------------------------------------------------------
// CSTUNRelayBinding::Implementation
// ---------------------------------------------------------------------------
//
const CBindingImplementation& CSTUNRelayBinding::Implementation() const
    {
//    __TEST_INVARIANT;

//    return *iImplementation;
    CBindingImplementation* impl = NULL;
    return *impl;
    }