/*
* Copyright (c) 2005 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 "natfwstunclientobserver.h"
#include "casynccallback.h"
#include "stunassert.h"

// -----------------------------------------------------------------------------
// CAsyncCallback::NewL
// -----------------------------------------------------------------------------
//
CAsyncCallback* CAsyncCallback::NewL( MSTUNClientObserver& aObserver )
    {
    CAsyncCallback* self = new (ELeave) CAsyncCallback( aObserver );
    CActiveScheduler::Add( self );
    self->WaitForRequests();
    return self;
    }

// -----------------------------------------------------------------------------
// CAsyncCallback::CAsyncCallback
// -----------------------------------------------------------------------------
//
CAsyncCallback::CAsyncCallback( MSTUNClientObserver& aObserver ) :
    CActive( EPriorityStandard ),
    iObserver( aObserver ),
    iPendingCallbacks( _FOFF( TSTUNCallbackInfo, iLink ) )
    {
    }

// ---------------------------------------------------------------------------
// CAsyncCallback::CAsyncCallback
// Dummy implementation. Default constructor is declared private and not used.
// ---------------------------------------------------------------------------
//
CAsyncCallback::CAsyncCallback() :
    CActive( EPriorityStandard ),
    iObserver( *( MSTUNClientObserver* )0x1 )
    {
    }

// ---------------------------------------------------------------------------
// CAsyncCallback::CAsyncCallback
// Dummy implementation, as copy constructor is declared private and not used.
// ---------------------------------------------------------------------------
//
CAsyncCallback::CAsyncCallback( const CAsyncCallback& aAsyncCallback ) :
    CActive( EPriorityStandard ),
    iObserver( aAsyncCallback.iObserver )
    {    
    }

// -----------------------------------------------------------------------------
// CAsyncCallback::~CAsyncCallback
// -----------------------------------------------------------------------------
//
CAsyncCallback::~CAsyncCallback()
    {
    Cancel();

    TSTUNCallbackInfo* callback = iPendingCallbacks.First();
    while ( iPendingCallbacks.IsFirst( callback ) &&
            !iPendingCallbacks.IsEmpty() )
        {
        iPendingCallbacks.Remove( *callback );
        delete callback;
        callback = iPendingCallbacks.First();
        }
    }

// -----------------------------------------------------------------------------
// CAsyncCallback::DoCancel
// -----------------------------------------------------------------------------
//
void CAsyncCallback::DoCancel()
    {
    if ( iStatus == KRequestPending )
        {
        TRequestStatus* status = &iStatus;    
        User::RequestComplete( status, KErrCancel );
        }
    }

// -----------------------------------------------------------------------------
// CAsyncCallback::RunL
// -----------------------------------------------------------------------------
//
void CAsyncCallback::RunL()
    {
    WaitForRequests();
    ExecuteFirstCallback();
    }

// -----------------------------------------------------------------------------
// CAsyncCallback::RunError
// Currently RunL cannot leave.
// -----------------------------------------------------------------------------
//
TInt CAsyncCallback::RunError( TInt aError )
    {
    if ( aError == KErrNoMemory )
        {
        return aError;
        }
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CAsyncCallback::MakeCallbackL
// -----------------------------------------------------------------------------
//
void CAsyncCallback::MakeCallbackL( TSTUNCallbackInfo::TFunction aFunction,
                                    const CBinding* aBinding,
                                    TInt aErrorCode,
                                    const CSTUNClient* aClient )
    {    
    TSTUNCallbackInfo* callback = new ( ELeave ) TSTUNCallbackInfo( aFunction,
                                                                    aBinding,
                                                                    aErrorCode,
                                                                    aClient );
    CleanupStack::PushL( callback );
    __STUN_ASSERT_L( callback->Validate(), KErrArgument );
    CleanupStack::Pop( callback );

    //CActive::iActive won't tell whether User::RequestComplete has already
    //been called, so iStatus is inspected to see whether a previous call to
    //AddDeleteRequestL has already called User::RequestComplete.
    if ( iStatus == KRequestPending )
        {
        Wakeup();
        }

    iPendingCallbacks.AddLast( *callback );
    }

// -----------------------------------------------------------------------------
// CAsyncCallback::CancelCallback
// -----------------------------------------------------------------------------
//
void CAsyncCallback::CancelCallback( const CBinding& aBinding )
    {
    TSglQueIter<TSTUNCallbackInfo> iter( iPendingCallbacks );

    for ( TSTUNCallbackInfo* callback = iter++; callback; callback = iter++ )
        {
        if ( callback->iBinding == &aBinding )
            {
            iPendingCallbacks.Remove( *callback );
            delete callback;
            }
        }
    }

// -----------------------------------------------------------------------------
// CAsyncCallback::ExecuteFirstCallback
// Handle one callback request and wait for the next one. If there are more
// callbacks, complete the asynchronous request so that RunL will soon be called
// again. Don't call more than one callback, since upper layer might've deleted
// STUN client, causing CAsyncCallback to be deleted too. For the same reason
// nothing is done after executing the callback.
// -----------------------------------------------------------------------------
//    
void CAsyncCallback::ExecuteFirstCallback()
    {
    TSTUNCallbackInfo* callback = iPendingCallbacks.First();
    if ( iPendingCallbacks.IsFirst( callback ) &&
         !iPendingCallbacks.IsEmpty() )
        {
        iPendingCallbacks.Remove( *callback );
        
        if ( !iPendingCallbacks.IsEmpty() )
            {
            Wakeup();
            }

        callback->Execute( iObserver );
        delete callback;
        }
    }

// -----------------------------------------------------------------------------
// CAsyncCallback::WaitForRequests
// -----------------------------------------------------------------------------
//
void CAsyncCallback::WaitForRequests()
    {
    __STUN_ASSERT_RETURN( !IsActive(), KErrNotReady );

    iStatus = KRequestPending;
    SetActive();
    }

// -----------------------------------------------------------------------------
// CAsyncCallback::Wakeup
// -----------------------------------------------------------------------------
//
void CAsyncCallback::Wakeup()
    {
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, KErrNone );
    }