/*
* 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 "mnatfwpluginobserver.h"
#include "cturnasynccallback.h"


// ---------------------------------------------------------------------------
// CTurnAsyncCallback::NewL
// ---------------------------------------------------------------------------
//
CTurnAsyncCallback* CTurnAsyncCallback::NewL(
    const CNATFWPluginApi& aTurnPlugin,
    MNATFWPluginObserver& aObserver )
    {
    CTurnAsyncCallback* self 
        = new (ELeave) CTurnAsyncCallback( aTurnPlugin, aObserver );
    CActiveScheduler::Add( self );
    self->WaitForRequestsL();
    return self;
    }

// ---------------------------------------------------------------------------
// CTurnAsyncCallback::CTurnAsyncCallback
// ---------------------------------------------------------------------------
//
CTurnAsyncCallback::CTurnAsyncCallback(
    const CNATFWPluginApi& aTurnPlugin, 
    MNATFWPluginObserver& aObserver )
    :
    CActive( EPriorityStandard ),
    iTurnPlugin( aTurnPlugin ),
    iObserver( aObserver ),
    iPendingCallbacks( _FOFF( TTurnPluginCallbackInfo, iLink ) )
    {
    }

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

// ---------------------------------------------------------------------------
// CTurnAsyncCallback::CTurnAsyncCallback
// Dummy implementation, as copy constructor is declared private and not used.
// ---------------------------------------------------------------------------
//
CTurnAsyncCallback::CTurnAsyncCallback(
    const CTurnAsyncCallback& aAsyncCallback ) :
    CActive( EPriorityStandard ),
    iTurnPlugin( *( CNATFWPluginApi* )0x1 ),
    iObserver( aAsyncCallback.iObserver )
    {
    }

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

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

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

// ---------------------------------------------------------------------------
// CTurnAsyncCallback::RunL
// ---------------------------------------------------------------------------
//
void CTurnAsyncCallback::RunL()
    {
    WaitForRequestsL();
    ExecuteFirstCallback();
    }

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

// ---------------------------------------------------------------------------
// CTurnAsyncCallback::MakeCallbackL
// ---------------------------------------------------------------------------
//
void CTurnAsyncCallback::MakeCallbackL(
    TTurnPluginCallbackInfo::TFunction aFunction,
    TUint aStreamId,
    TInt aErrorCode,
    TAny* aEventData )
    {
    TTurnPluginCallbackInfo* callback =
        new ( ELeave ) TTurnPluginCallbackInfo( iTurnPlugin,
                                                iObserver,
                                                aFunction,
                                                aStreamId,
                                                aErrorCode,
                                                aEventData );
    CleanupStack::PushL( callback );
    __ASSERT_ALWAYS( callback->Validate(), User::Leave( 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 );
    }

// ---------------------------------------------------------------------------
// CTurnAsyncCallback::CancelCallback
// ---------------------------------------------------------------------------
//
void CTurnAsyncCallback::CancelCallback( TUint aStreamId )
    {
    TSglQueIter<TTurnPluginCallbackInfo> iter( iPendingCallbacks );

    for ( TTurnPluginCallbackInfo* callback = iter++;
          callback; callback = iter++ )
        {
        if ( callback->iStreamId == aStreamId )
            {
            iPendingCallbacks.Remove( *callback );
            delete callback;
            }
        }
    }

// ---------------------------------------------------------------------------
// CTurnAsyncCallback::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 plugin, causing CTurnAsyncCallback to be deleted too.
// For the same reason nothing is done after executing the callback.
// ---------------------------------------------------------------------------
//    
void CTurnAsyncCallback::ExecuteFirstCallback()
    {
    TTurnPluginCallbackInfo* callback = iPendingCallbacks.First();
    if ( iPendingCallbacks.IsFirst( callback ) &&
         !iPendingCallbacks.IsEmpty() )
        {
        iPendingCallbacks.Remove( *callback );

        if ( !iPendingCallbacks.IsEmpty() )
            {
            Wakeup();
            }

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

// ---------------------------------------------------------------------------
// CTurnAsyncCallback::WaitForRequestsL
// ---------------------------------------------------------------------------
//
void CTurnAsyncCallback::WaitForRequestsL()
    {
    __ASSERT_ALWAYS( !IsActive(), User::Leave( KErrNotReady ) );

    iStatus = KRequestPending;
    SetActive();
    }

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

// End of file