/*
* Copyright (c) 2002-2006 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 saving Provisioning settings. Provides a progress note.
*
*/


// INCLUDE FILES
#include "CWPCxDeleter.h"
#include <aknquerydialog.h>
#include <eikprogi.h>
#include <ProvisioningCx.rsg>
#include <commdb.h>
#include <CWPEngine.h>
#include <CWPAdapter.h>
#include <ActiveFavouritesDbNotifier.h>

// CONSTANTS
const TInt KMaxWaitTime = 2000000;
const TInt KRetryCount = 5;

// CLASS DECLARATION

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

// C++ default constructor.
CWPCxDeleter::CWPCxDeleter( CWPEngine& aEngine, TUint32 aContext )
: CActive( EPriorityStandard ), iEngine( aEngine ), 
  iContext( aContext ),
  iCurrentItem( 0 ), iResult( KErrNone )
    {
    }

// ----------------------------------------------------------------------------
// CWPCxDeleter::ExecuteLD
// ----------------------------------------------------------------------------
//
void CWPCxDeleter::PrepareLC()
    {
    // Assume ownership of this.
    CleanupStack::PushL( this );

    iApDbNotifier = CActiveApDb::NewL( EDatabaseTypeIAP );
    iApDbNotifier->AddObserverL( this );
    
    User::LeaveIfError( iSession.Connect() );
    User::LeaveIfError( iBookmarkDb.Open( iSession, KBrowserBookmarks ) );
    iFavouritesNotifier = new(ELeave) CActiveFavouritesDbNotifier( iBookmarkDb, *this );

    iFavouritesNotifier->Start();

    iRetryTimer = CPeriodic::NewL( EPriorityStandard );

    // Set up the dialog and callback mechanism.
    iDialog = new(ELeave)CAknProgressDialog(
        reinterpret_cast<CEikDialog**>(&iDialog), EFalse );
    iDialog->SetCallback( this );
    iDialog->ExecuteLD(R_WAITNOTE_DELETE);
    CEikProgressInfo* progressInfo = iDialog->GetProgressInfoL();
    progressInfo->SetAndDraw(iCurrentItem);
    progressInfo->SetFinalValue(iEngine.ContextDataCountL(iContext));
    }

// ----------------------------------------------------------------------------
// CWPCxDeleter::ExecuteLD
// ----------------------------------------------------------------------------
//
TInt CWPCxDeleter::ExecuteLD( TInt& aNumDeleted )
    {
    PrepareLC();

    // Add us to active scheduler and make sure RunL() gets called.
    CActiveScheduler::Add( this );
    CompleteRequest();
    iWait.Start();

    // Progress note has been finished/cancelled. Cache the result
    // and delete this.
    TInt result( iResult );
    aNumDeleted = iCurrentItem;
    CleanupStack::PopAndDestroy(); // this

    return result;
    }

// Destructor
CWPCxDeleter::~CWPCxDeleter()
    {
    Cancel();

    delete iApDbNotifier;

    if( iFavouritesNotifier )
        {
        iFavouritesNotifier->Cancel();
        delete iFavouritesNotifier;
        }

    iBookmarkDb.Close();
    iSession.Close();

    delete iRetryTimer;
    }

// ----------------------------------------------------------------------------
// CWPCxDeleter::DoCancel
// ----------------------------------------------------------------------------
//
void CWPCxDeleter::DoCancel()
    {
    }

// ----------------------------------------------------------------------------
// CWPCxDeleter::RunL
// ----------------------------------------------------------------------------
//
void CWPCxDeleter::RunL()
    {
    // Choose whether to save or set as default
    TBool more( EFalse );
    TRAPD( err, more = iEngine.DeleteContextDataL( iContext ) );

    // If CommsDB or BookmarkDB are locked, schedule a retry
    if( err == EWPCommsDBLocked )
        {
        iWaitCommsDb = ETrue;
        DelayedCompleteRequestL();
        return;
        }
    else if( err == EWPBookmarksLocked )
        {
        iWaitFavourites = ETrue;
        DelayedCompleteRequestL();
        return;
        }
    else if( err != KErrNone )
        {
        // For all other errors, pass them through.
        User::LeaveIfError( err );
        }
    // Succesful save, so reset retry count
    iRetryCount = 0;

    // Normal progress
    if( !more )
        {
        iDialog->ProcessFinishedL();
        }
    else
        {
        CEikProgressInfo* progressInfo = iDialog->GetProgressInfoL();
        iCurrentItem++;
        progressInfo->SetAndDraw(iCurrentItem);
        CompleteRequest();
        }
    }

// ---------------------------------------------------------
// CWPCxDeleter::RunError
// ---------------------------------------------------------
//
TInt CWPCxDeleter::RunError( TInt aError )
    {
    // There was a leave in RunL(). Store the error and
    // stop the dialog.
    iResult = aError;
    iWait.AsyncStop();
    delete iDialog;
    iDialog = NULL;

    return KErrNone;
    }

// ---------------------------------------------------------
// CWPCxDeleter::DialogDismissedL
// ---------------------------------------------------------
//
void CWPCxDeleter::DialogDismissedL( TInt aButtonId )
    {
    if( aButtonId < 0 )
        {
        iResult = KErrCancel;
        }

    iWait.AsyncStop();
    }

// ----------------------------------------------------------------------------
// CWPCxDeleter::CompleteRequest
// ----------------------------------------------------------------------------
//
void CWPCxDeleter::CompleteRequest()
    {
    // Schedule an immediate complete. Make sure that there
    // is no timer alive first
    Cancel();
    iRetryTimer->Cancel();

    SetActive();
    TRequestStatus* sp = &iStatus;
    User::RequestComplete( sp, KErrNone );
    }

// ----------------------------------------------------------------------------
// CWPCxDeleter::DelayedCompleteRequestL
// ----------------------------------------------------------------------------
//
void CWPCxDeleter::DelayedCompleteRequestL()
    {
    if( iRetryCount < KRetryCount )
        {
        // Schedule a delayed complete.
        iRetryTimer->Cancel();
        iRetryTimer->Start( KMaxWaitTime, KMaxTInt32, TCallBack( Timeout, this ) );
        iRetryCount++;
        }
    else
        {
        User::Leave( KErrTimedOut );
        }
    }

// ----------------------------------------------------------------------------
// CWPCxDeleter::Retry
// ----------------------------------------------------------------------------
//
void CWPCxDeleter::Retry()
    {
    // Immediate retry. Mark that we're not waiting
    // for an event and complete request.

    iWaitCommsDb = EFalse;
    iWaitFavourites = EFalse;
    CompleteRequest();
    }

// ----------------------------------------------------------------------------
// CWPCxDeleter::Timeout
// ----------------------------------------------------------------------------
//
TInt CWPCxDeleter::Timeout(TAny* aSelf)
    {
    // There was a time-out. Retry saving even though we
    // didn't get a notify from database.
    CWPCxDeleter* self = STATIC_CAST(CWPCxDeleter*, aSelf);
    self->Retry();

    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CWPCxDeleter::HandleApDbEventL
// ----------------------------------------------------------------------------
//
void CWPCxDeleter::HandleApDbEventL( TEvent aEvent )
    {
    // We received an event from CommsDB. Retry if we're
    // waiting for it.
    if( iWaitCommsDb && aEvent == EDbAvailable )
        {
        Retry();
        }
    }

// ----------------------------------------------------------------------------
// CWPCxDeleter::HandleFavouritesDbEventL
// ----------------------------------------------------------------------------
//
void CWPCxDeleter::HandleFavouritesDbEventL( RDbNotifier::TEvent /*aEvent*/ )
    {
    // We received an event from BookmarkDB. Retry if we're
    // waiting for it.
    if( iWaitFavourites )
        {
        Retry();
        }
    }

//  End of File