/*

* Copyright (c) 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:  Folder scanning class to scan files in the file system

*

*/

#include <e32base.h>

#include <mpxlog.h>

#include "mpxfolderscanner.h"

#include "mpxfileadditionobserver.h"

#include "mpxfilescanstateobserver.h"

#include "mpxfhcommon.h"

// CONSTANTS

const TInt KFileNumBreakCount = 5;

// ======== LOCAL FUNCTIONS ========

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

// RArray compare function to compare strings

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

//

static TInt CompareString(const TPath& aFirst,

                          const TPath& aSecond)

    {

    return aFirst.Compare( aSecond );

    }

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

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

// Constructor

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

//

CMPXFolderScanner::CMPXFolderScanner( MMPXFileAdditionObserver& aObserver,

                                      MMPXFileScanStateObserver& aStateObs,

                                      RFs& aFs  ) : CActive(EPriorityNull),

                                                  iObserver( aObserver ),

                                                  iStateObserver( aStateObs ),

                                                  iFs( aFs )

    {

    CActiveScheduler::Add(this);

    }

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

// 2nd Phase Constructor

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

//

void CMPXFolderScanner::ConstructL()

    {

    }

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

// Two Phased Constructor

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

//

CMPXFolderScanner* CMPXFolderScanner::NewL( MMPXFileAdditionObserver& aObserver,

                                            MMPXFileScanStateObserver& aStateObs,

                                            RFs& aFs )

    {

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

                                                               aStateObs,

                                                               aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CMPXFolderScanner::~CMPXFolderScanner()

    {

    Cancel();

    iDrivesToScan.Close();

    }

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

// Scans a list of drives for files

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

//

void CMPXFolderScanner::ScanL( RArray<TPath>& aDrives )

    {

    MPX_DEBUG1("CMPXFolderScanner::ScanL <---");

    // Copy all the other drives we want to scan

    //

    TInt count( aDrives.Count() );

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

        {

        // Check if we are already scanning this drive

        TInt found( iDrivesToScan.FindInOrder( aDrives[i], CompareString ) ); 

        if( found == KErrNotFound )

            {

            iDrivesToScan.Append( aDrives[i] );

            }

        }

    // If we were already scanning, don't do it again

    //

    if( !iScanning )

        {

        // Setup the next drive to scan

        //

        if( !SetupNextDriveToScanL() )

            {

            // Kick off the scanning

            // We've started scanning

            iScanning = ETrue;

            }

        else

            {

            // Nothing to scan

            DoScanCompleteL(KErrNone);    

            }        

        }

    MPX_DEBUG1("CMPXFolderScanner::ScanL --->");

    }

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

// Continue Scanning for more files

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

//

TBool CMPXFolderScanner::DoScanL()

    {

    MPX_DEBUG1("CMPXFolderScanner::DoScanL <---");

    TBool done (EFalse);

        {

            }

        }

        {

            {

            }

            {

            }

        }

    MPX_DEBUG1("CMPXFolderScanner::DoScanL --->");

    return done;

    }

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

// Setup the object to scan the next directory

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

//

TBool CMPXFolderScanner::SetupNextDriveToScanL()

    {

    MPX_DEBUG1("CMPXFolderScanner::SetupNextDriveToScanL <---");

    TBool done(EFalse);

    TBool blocked(EFalse);

    // Scan next drive

        {

            {

                {

                // Inform Observer of the new drive that we are scanning

                                            iDrivesToScan[0] );

                }

            }

        }

    MPX_DEBUG1("CMPXFolderScanner::SetupNextDriveToScanL --->");

    return done;

    }

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

// Handle when scanning is complete

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

//

void CMPXFolderScanner::DoScanCompleteL( TInt aErr )

    {

    MPX_DEBUG1("CMPXFolderScanner::DoScanCompleteL <---");

    // Reset all arrays and data

    iDrivesToScan.Reset();

    // All done!

    iScanning = EFalse;

    // Callback to observer

    iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::EScanFiles, 

                                              aErr );

    MPX_DEBUG1("CMPXFolderScanner::DoScanCompleteL --->");

    }

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

// From CActive

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

//

void CMPXFolderScanner::RunL()

    {

    MPX_DEBUG1("CMPXFolderScanner::RunL <---");

    // Do more scanning

    TBool done(EFalse);

    TRAPD( err, done = DoScanL() );   

    // We are all done

    //

    if( KErrNone != err || done )

        {

        DoScanCompleteL( err );

        }

        {

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

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        }

    }

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

// From CActive

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

//

void CMPXFolderScanner::DoCancel()

    {

    if( iScanning )

        {

        // Callback to observer with the partial list?

        TRAP_IGNORE( DoScanCompleteL( KErrCancel ) );

        }

    }

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

// Handles a leave occurring in the request completion event handler RunL()

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

//

TInt CMPXFolderScanner::RunError(TInt aError)

    {

    MPX_DEBUG2("CMPXFolderScanner::RunError(%d)", aError );

    TRAP_IGNORE( DoScanCompleteL( aError ) );

    return KErrNone;