/*------------------------------------------------------------------

 -

 * Software Name : UserEmulator

 * Version       : v4.2.1309

 * 

 * Copyright (c) 2009 France Telecom. All rights reserved.

 * This software is distributed under the License 

 * "Eclipse Public License - v 1.0" the text of which is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * France Telecom 

 *

 * Contributors:

 *------------------------------------------------------------------

 -

 * File Name: ScanFolders.cpp

 * 

 * Created: 13/08/2009

 * Author(s): Marcell Kiss, Reshma Sandeep Das

 *   

 * Description:

 * Active object implementation for folder scanning operation

 *------------------------------------------------------------------

 -

 *

 */

//System Includes

#include <EikApp.h>

#include <EikEnv.h>

#include <F32File.h>

//User Includes

#include "ScanFolders.h"

#include "FolderContentsListener.h"

#include "UserEmulatorScriptsView.h"

//Constants

const TInt KDRIVESIZE      = 3;

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

// CScanFolders::NewL

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

//

CScanFolders* CScanFolders::NewL()

{

	CScanFolders* self = CScanFolders::NewLC();

	CleanupStack::Pop(self);

	return self;

}

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

// CScanFolders::NewLC

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

//

CScanFolders* CScanFolders::NewLC()

{

	CScanFolders* self = new ( ELeave ) CScanFolders;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;	

}

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

// CScanFolders::CScanFolders

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

//

CScanFolders::CScanFolders() : CActive( EPriorityStandard )

{

}

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

// CScanFolders::~CScanFolders

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

//

CScanFolders::~CScanFolders()

{

	Cancel();

	iListeners.Close();

	iCurrentDir.Close();

	iFs.Close();

	delete iDirectories; 

	iDirectories = NULL;

	delete iFileNames; 

	iFileNames = NULL;

}

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

// CScanFolders::ConstructL

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

//

void CScanFolders::ConstructL()

{

	// Create an array to hold the directories

	iDirectories = new ( ELeave ) CDesCArrayFlat( 10 );

	// Create an array to hold the full filenames

	iFileNames = new ( ELeave ) CDesCArrayFlat( 10 );

	// Create a file server session

	User::LeaveIfError(iFs.Connect());

	// Register this as an active object (for the async file scanning)

	CActiveScheduler::Add( this );

}

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

// CScanFolders::AddListenerL

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

//

void CScanFolders::AddListenerL( CUserEmulatorScriptsView* aListener )

{

	if ( iListeners.Find( aListener ) != KErrNotFound )

	{

		User::Leave(KErrAlreadyExists);

	}

	iListeners.Append( aListener );

}

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

// CScanFolders::RemoveListener

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

//

void CScanFolders::RemoveListener( CUserEmulatorScriptsView * aListener )

{

	TInt index = iListeners.Find( aListener );

	iListeners.Remove( index );

}

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

// CScanFolders::SetFilter

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

//

void CScanFolders::SetFilter( const TDesC & aFilter )

{

	iFileFilter.Copy( aFilter );

	if ( iFileFilter[ iFileFilter.Length() - 1 ] != ';' )

	{

		iFileFilter.Append( ';' );

	}

}

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

// CScanFolders::SetFilter

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

//

void CScanFolders::SetFilter( const TDesC8 & aFilter )

{

	iFileFilter.Copy( aFilter );

	if ( iFileFilter[ iFileFilter.Length() - 1 ] != ';' )

	{

		iFileFilter.Append( ';' );

	}

}

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

// CScanFolders::ScanFolderL

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

//

void CScanFolders::ScanFolderL( const TDesC & aPath )

{

	iCurrentPath.Set( aPath, NULL, NULL );

	if ( IsActive() )

	{

		iStartNewScan = ETrue;

	}

	else

	{

		StartScanningL();

	}

}

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

// CScanFolders::ScanFolderL

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

//

void CScanFolders::ScanFolderL( const TDesC8 & aPath )

{

	TBuf< KBuffer256 > temp;

	temp.Copy( aPath );

	ScanFolderL( temp );

}

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

// CScanFolders::DoCancel

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

//

void CScanFolders::DoCancel()

{

	iAbortScan = ETrue;

}

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

// CScanFolders::RunL

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

//

void CScanFolders::RunL()

{

	switch ( iScanState )

	{

	case EIdle:

		User::Panic(KIDLE, 0);

		break;

	case EScanning:

		{

			if ( iStatus == KErrNone )

			{

				FireEntriesL();

				Reset();

				// After the initial entries have been fired, set the

				// #iContinued flag so that #FolderStarting is not called

				// again for this reading session.

				iContinued = ETrue;

				ContinueScanning();

			}

			else if ( iStatus == KErrEof )

			{

				// Before delivering this last set of entries, set the

				// #iComplete flag so that #FolderComplete is called in

				// #FireEntries.

				iComplete = ETrue;

				FireEntriesL();

				Reset();

				StopScanning();

			}

			else

			{

				Reset();

				FireError( iStatus.Int() );

			}

		}

		break;

	case EStartNewScan:

		Reset();

		StartScanningL();

		break;

	case EAbortScan:

		Reset();

		break;

	}

}

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

// CScanFolders::StartScanningL

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

//

void CScanFolders::StartScanningL()

{

	if ( iCurrentPath.FullName().Compare( KPATHDELIM ) == 0 )

	{

		DeliverDrivesL();

		return;

	}

	TInt error = iCurrentDir.Open( iFs, iCurrentPath.FullName(),

		KEntryAttNormal|KEntryAttDir|KEntryAttReadOnly|KEntryAttSystem|KEntryAttHidden );

	if ( error != KErrNone )

	{

		FireError( error );

		return;

	}

	iContinued = EFalse;

	iComplete = EFalse;

	ContinueScanning();

}

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

// CScanFolders::ContinueScanning

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

//

void CScanFolders::ContinueScanning()

{

	iCurrentDir.Read( iEntries, iStatus );

	if(!IsActive())

		SetActive();

	iScanState = EScanning;

}

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

// CScanFolders::StopScanning

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

//

void CScanFolders::StopScanning()

{

	iCurrentDir.Close();

}

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

// CScanFolders::DeliverDrivesL

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

//

void CScanFolders::DeliverDrivesL()

{

	FireFolderStarting( ETrue );

	TDriveList drives;

	User::LeaveIfError( iFs.DriveList( drives ) );

	for ( TInt idx = 0; idx < KMaxDrives; idx++ )

	{

		if ( drives[ idx ] == 0 )

		{

			continue;

		}

		TChar driveLetter;

		User::LeaveIfError( iFs.DriveToChar( idx, driveLetter ) );

		TBuf< KDRIVESIZE > temp;

		temp.Append( driveLetter );

		temp.Append( KDRIVEDEL );

		FireFolder( temp );

	}

	FireFolderCompleteL();

	Reset();

}

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

// CScanFolders::Reset

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

//

void CScanFolders::Reset()

{

	iDirectories->Reset();

	iFileNames->Reset();

	iScanState = EIdle;

}

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

// CScanFolders::FireError

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

//

void CScanFolders::FireError( TInt aReasonCode )

{

	for ( TInt idx = 0; idx < iListeners.Count(); idx++ )

	{

		iListeners[ idx ]->ErrorOccured( aReasonCode );

	}

}

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

// CScanFolders::FireEntriesL

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

//

void CScanFolders::FireEntriesL()

{

	if ( iContinued == EFalse )

	{

		FireFolderStarting( EFalse );

	}

	for ( TInt idx = 0; idx < iEntries.Count(); idx++ )

	{

		if ( iEntries[ idx ].IsDir() || IsMatch( iEntries[ idx ].iName ) )

		{

			FireEntry( iEntries[ idx ] );

		}

	}

	if ( iComplete )

	{

		FireFolderCompleteL();

	}

}

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

// CScanFolders::FireEntry

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

//

void CScanFolders::FireEntry( const TEntry & aEntry )

{

	if ( aEntry.IsDir() )

	{

		FireFolder( aEntry.iName );

	}

	else

	{

		FireFile( aEntry.iName );

	}

}

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

// CScanFolders::FireFolder

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

//

void CScanFolders::FireFolder( const TDesC & aFolder )

{

	for ( TInt idx = 0; idx < iListeners.Count(); idx++ )

	{

		iListeners[ idx ]->NewFolder( aFolder );

	}

}

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

// CScanFolders::FireFile

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

//

void CScanFolders::FireFile( const TDesC & aFile )

{

	for ( TInt idx = 0; idx < iListeners.Count(); idx++ )

	{

		iListeners[ idx ]->NewFile( aFile );

	}

}

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

// CScanFolders::FireFolderStarting

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

//

void CScanFolders::FireFolderStarting( TBool aIsDriveListFlag )

{

	for ( TInt idx = 0; idx < iListeners.Count(); idx++ )

	{		

		iListeners[ idx ]->FolderStarting( iCurrentPath.FullName(), aIsDriveListFlag );

	}

}

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

// CScanFolders::FireFolderCompleteL

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

//

void CScanFolders::FireFolderCompleteL()

{

	for ( TInt idx = 0; idx < iListeners.Count(); idx++ )

	{

		iListeners[ idx ]->FolderCompleteL();

	}

}

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

// CScanFolders::IsMatch

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

//

TBool CScanFolders::IsMatch( const TDesC & aFilename )

{

	TPtrC remaining = iFileFilter.Mid( 0 );

	while ( remaining.Length() > 0 )

	{

		TInt delimeterPos = remaining.Locate( ';' );

		if ( delimeterPos == KErrNotFound )

		{

			delimeterPos = remaining.Length();

		}

		TPtrC pattern = remaining.Mid( 0, delimeterPos );

		if ( aFilename.MatchF( pattern ) != KErrNotFound )

		{

			return ETrue;

		}

		if( delimeterPos + 1 <= remaining.Length() )

			remaining.Set( remaining.Mid( delimeterPos + 1 ) );

	}

	return EFalse;

}