/*

* Copyright (c) 2005-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:  Helper class for asynchronous operations

*

*/

// INCLUDES

#include "CVPbkAsyncOperation.h"

#include "Error.h"

namespace VPbkEngUtils {

// anonymous namespace for local definitions

namespace {

} // anonymous namespace

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

// CVPbkAsyncOperation::CVPbkAsyncOperation

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

//

EXPORT_C CVPbkAsyncOperation::CVPbkAsyncOperation()

    :   iPriority( CActive::EPriorityIdle )

    {

    }

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

// CVPbkAsyncOperation::CVPbkAsyncOperation

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

//

EXPORT_C CVPbkAsyncOperation::CVPbkAsyncOperation( 

        CActive::TPriority aPriority )

        :   iPriority( aPriority )

    {

    }

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

// CVPbkAsyncOperation::~CVPbkAsyncOperation

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

//

EXPORT_C CVPbkAsyncOperation::~CVPbkAsyncOperation()

    {

    delete iIdle;

    iCallbacks.ResetAndDestroy();

    if (iDestroyed)

        {

        *iDestroyed = ETrue;

        }

    }

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

// CVPbkAsyncOperation::CallbackL

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

//

EXPORT_C void CVPbkAsyncOperation::CallbackL(MAsyncCallback* aCallback)

    {

    __ASSERT_DEBUG(aCallback, Error::Panic(Error::EPanicInvalidOperation));

    if ( !iIdle )

        {

        iIdle = CIdle::NewL( iPriority );

        }

    iCallbacks.AppendL( aCallback );

    IssueRequest();

    }

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

// CVPbkAsyncOperation::Purge

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

//

EXPORT_C void CVPbkAsyncOperation::Purge()

    {

    // Cancel and destroy all callbacks

    if ( iIdle )

        {

        iIdle->Cancel();

        }

    iCallbacks.ResetAndDestroy();

    }

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

// CVPbkAsyncOperation::CancelCallback

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

//

EXPORT_C void CVPbkAsyncOperation::CancelCallback( 

        const MAsyncCallback& aCallback )

    {

    TInt index = iCallbacks.Find( &aCallback );

    if ( index != KErrNotFound )

        {

        delete iCallbacks[index];

        iCallbacks.Remove( index );

        }

    }

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

// CVPbkAsyncOperation::CallbackCount

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

//

EXPORT_C TInt CVPbkAsyncOperation::CallbackCount() const

    {

    return iCallbacks.Count();

    }

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

// CVPbkAsyncOperation::CallbackAt

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

//

EXPORT_C const MAsyncCallback& CVPbkAsyncOperation::CallbackAt( 

        TInt aIndex ) const

    {

    return *iCallbacks[aIndex];

    }

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

// CVPbkAsyncOperation::IssueRequest

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

//

void CVPbkAsyncOperation::IssueRequest()

    {

    if ( !iIdle->IsActive() )

        {

        iIdle->Start( TCallBack( CVPbkAsyncOperation::IdleCallback, this) );

        }    

    }

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

// CVPbkAsyncOperation::HandleIdleCallback

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

//

TInt CVPbkAsyncOperation::HandleIdleCallback()

    {

    // Default is not to continue idle.

    TInt result = EFalse;

    volatile TBool destroyed = EFalse;

    iDestroyed = &destroyed;

    if (iCallbacks.Count() > 0)

        {

        MAsyncCallback* callback = iCallbacks[0];

        iCallbacks.Remove(0);

        TRAPD(err, (*callback)());

        if (err != KErrNone)

            {

            callback->Error(err);

            }

        delete callback;

        }

    if (!destroyed)

        {

        // Change to NULL because local variable goes out of scope

        // in the end of this function

        iDestroyed = NULL;

        if (iCallbacks.Count() > 0 && !iIdle->IsActive() )

            {

            // There are callbacks left and client hasn't called CallbackL in its

            // callback function -> continue CIdle.

            result = ETrue;

            }

        }

    // DO NOT TOUCH TO MEMBER VARIABLES AFTER THIS POINT BECAUSE THIS

    // OBJECT MAY ALREADY BE DESTROYED.

    return result;

    }

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

// CVPbkAsyncOperation::IdleCallback

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

//

TInt CVPbkAsyncOperation::IdleCallback( TAny* aThis )

    {

    return static_cast<CVPbkAsyncOperation*>( aThis )->HandleIdleCallback();

    }

} // namespace VPbkEngUtils