/*

* 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 "cnatfwasynccallback.h"

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

// CNatFwAsyncCallback::NewL

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

//

CNatFwAsyncCallback* CNatFwAsyncCallback::NewL()

    {

    CNatFwAsyncCallback* self

        = new (ELeave) CNatFwAsyncCallback();

    CActiveScheduler::Add( self );

    self->WaitForRequestsL();

    return self;

    }

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

// CNatFwAsyncCallback::CNatFwAsyncCallback

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

//

CNatFwAsyncCallback::CNatFwAsyncCallback() :

    CActive( EPriorityStandard ),

    iPendingCallbacks( _FOFF( CNatFwCallbackInfo, iLink ) )

    {

    }

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

// CNatFwAsyncCallback::~CNatFwAsyncCallback

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

//

CNatFwAsyncCallback::~CNatFwAsyncCallback()

    {

    Cancel();

    CNatFwCallbackInfo* callback = iPendingCallbacks.First();

    while ( iPendingCallbacks.IsFirst( callback ) &&

            !iPendingCallbacks.IsEmpty() )

        {

        iPendingCallbacks.Remove( *callback );

        delete callback;

        callback = iPendingCallbacks.First();

        }

    }

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

// CNatFwAsyncCallback::DoCancel

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

//

void CNatFwAsyncCallback::DoCancel()

    {

    if ( iStatus == KRequestPending )

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrCancel );

        }

    }

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

// CNatFwAsyncCallback::RunL

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

//

void CNatFwAsyncCallback::RunL()

    {

    WaitForRequestsL();

    ExecuteFirstCallback();

    }

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

// CNatFwAsyncCallback::RunError

// Currently RunL cannot leave.

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

//

TInt CNatFwAsyncCallback::RunError( TInt aError )

    {

    if ( aError == KErrNoMemory )

        {

        return aError;

        }

    return KErrNone;

    }

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

// CNatFwAsyncCallback::MakeCallbackL

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

//

void CNatFwAsyncCallback::MakeCallbackL(

    MNATFWRegistrationController& aController,

    CNatFwCallbackInfo::TFunction aFunction,

    TUint aSessionId,

    TUint aStreamId,

    TInt aErrorCode,

    TAny* aEventData )

    {

    CNatFwCallbackInfo* callback =

        new ( ELeave ) CNatFwCallbackInfo( aController,

                                           aFunction,

                                           aSessionId,

                                           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 );

    }

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

// CNatFwAsyncCallback::CancelCallback

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

//

void CNatFwAsyncCallback::CancelCallback( TUint aStreamId )

    {

    TSglQueIter<CNatFwCallbackInfo> iter( iPendingCallbacks );

    for ( CNatFwCallbackInfo* callback = iter++; callback; callback = iter++ )

        {

        if ( callback->iStreamId == aStreamId )

            {

            iPendingCallbacks.Remove( *callback );

            delete callback;

            }

        }

    }

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

// CNatFwAsyncCallback::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.

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

//

void CNatFwAsyncCallback::ExecuteFirstCallback()

    {

    CNatFwCallbackInfo* callback = iPendingCallbacks.First();

    if ( iPendingCallbacks.IsFirst( callback ) &&

         !iPendingCallbacks.IsEmpty() )

        {

        iPendingCallbacks.Remove( *callback );

        if ( !iPendingCallbacks.IsEmpty() )

            {

            Wakeup();

            }

        callback->Execute();

        delete callback;

        }

    }

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

// CNatFwAsyncCallback::WaitForRequestsL

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

//

void CNatFwAsyncCallback::WaitForRequestsL()

    {

    __ASSERT_ALWAYS( !IsActive(), User::Leave( KErrNotReady ) );

    iStatus = KRequestPending;

    SetActive();

    }

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

// CNatFwAsyncCallback::Wakeup

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

//

void CNatFwAsyncCallback::Wakeup()

    {

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    }