/*

* 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:  Active object to cleanup broken links

*

*/

#include <e32base.h>

#include <mpxlog.h>

#include <badesca.h>

#include "mpxfilescanstateobserver.h"

#include "mpxbrokenlinkcleanupobserver.h"

#include "mpxbrokenlinkcleanup.h"

// CONSTANTS

const TInt KDeleteGranularity = 10;

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

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

// Constructor

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

//

CMPXBrokenLinkCleanup::CMPXBrokenLinkCleanup( MMPXFileScanStateObserver& aObserver,

                                              MMPXBrokenLinkObserver& aBrokenLinkObserver ) 

                                           : CActive( EPriorityNull ),

                                             iStateObserver( aObserver ),

                                             iBrokenLinkObserver( aBrokenLinkObserver )

    {

    CActiveScheduler::Add( this );

    }

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

// 2nd Phase Constructor

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

//

void CMPXBrokenLinkCleanup::ConstructL()

    {

    iBrokenLinks = new(ELeave) CDesCArrayFlat(2);  // magic

    }

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

// Two-Phased Constructor

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

//

CMPXBrokenLinkCleanup* CMPXBrokenLinkCleanup::NewL( MMPXFileScanStateObserver& aObserver,

                                                    MMPXBrokenLinkObserver& aBrokenLinkObserver )

    {

    CMPXBrokenLinkCleanup* self = new( ELeave ) CMPXBrokenLinkCleanup( aObserver,

                                                                       aBrokenLinkObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Virtual destructor

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

//

CMPXBrokenLinkCleanup::~CMPXBrokenLinkCleanup()

    {

    Cancel();

    Reset();

    delete iBrokenLinks;

    iColIds.Close();

    iDBRefs.Close();

    }

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

// Start the broken link cleanup

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

//

void CMPXBrokenLinkCleanup::Start()

    {

    MPX_DEBUG1("CMPXBrokenLinkCleanup::Start <---");

    // If this isn't already running

    //

    if( !IsActive() )

        {

        iCleaningUp = ETrue;

        // Set Active

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );    

        MPX_DEBUG1("CMPXBrokenLinkCleanup::Started");

        }

    }

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

// Reset this object's state

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

//

void CMPXBrokenLinkCleanup::Reset()

    {

    iBrokenLinks->Reset();

    iColIds.Reset();

    iDBRefs.Reset();

    }

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

// Adds a broken link for cleanup

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

//

void CMPXBrokenLinkCleanup::AddBrokenLinkL( const TDesC& aFile,

                                            TInt aColId,

                                            CMPXHarvesterDB* aDb )

    {

    iBrokenLinks->AppendL( aFile );

    iColIds.AppendL( aColId );

    iDBRefs.AppendL( aDb );

    }

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

// From CActive

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

//

void CMPXBrokenLinkCleanup::DoCancel()

    {

    if( iCleaningUp )

        {

        MPX_DEBUG1("CMPXBrokenLinkCleanup::DoCancel <---");

        // Callback to observer 

        Reset();

        TRAP_IGNORE( iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::ECleanupBrokenLink,

                                                              KErrCancel ) );

        iCleaningUp = EFalse;

        }

    }

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

// From CActive

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

//

void CMPXBrokenLinkCleanup::RunL()

    {

    TBool done(EFalse);

    TRAPD( err, done = DoBrokenLinkL() );

    if( KErrNone != err || done )

        {

        // Callback to observer 

        MPX_DEBUG1("CMPXBrokenLinkCleanup::RunL -- Done");

        TRAP_IGNORE( iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::ECleanupBrokenLink,

                                                              err ) );

        iCleaningUp = EFalse;

        }

    else

        {

        MPX_DEBUG1("CMPXBrokenLinkCleanup::RunL -- Run again");

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );    

        }

    }

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

// From CActive

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

//

TInt CMPXBrokenLinkCleanup::RunError(TInt aError)

    {

    MPX_DEBUG1("CMPXBrokenLinkCleanup::RunError <---");

    Reset();

    TRAP_IGNORE( iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::ECleanupBrokenLink,

                                                          aError ) );

    iCleaningUp = EFalse;

    return KErrNone;

    }

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

// Perform one iteration of the broken link check

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

//

TBool CMPXBrokenLinkCleanup::DoBrokenLinkL()

    {

    MPX_DEBUG1("CMPXBrokenLinkCleanup::DoBrokenLinkL <---");

    TBool done(EFalse);

    // Call back to observer to perform the cleanup

    TInt count(iBrokenLinks->Count());

    iBrokenLinkObserver.HandleBrokenLinkL( *iBrokenLinks,

                                           iColIds,

                                           iDBRefs,

                                           count<KDeleteGranularity?count:KDeleteGranularity );

    // Loop through and remove KDeleteGranularity elements

    // from the broken links array

    //

    for( TInt i=0; i<KDeleteGranularity; ++i )

        {

        // No more to delete

        if( count == 0 )

            {

            done = ETrue;

            break;

            }

        iBrokenLinks->Delete(0);

        count--;

        }

    MPX_DEBUG1("CMPXBrokenLinkCleanup::DoBrokenLinkL --->");

    return done;

    }

// END OF FILE