FCL/sf/mw/mmappfw: comparison mmappcomponents/harvester/filehandler/src/mpxfolderscanner.cpp

equal deleted inserted replaced

-:fa0adf088850
+:c76ea6caa649
 #include "mpxfilescanstateobserver.h"
 #include "mpxfhcommon.h"
 // CONSTANTS
 const TInt KFileNumBreakCount = 5;
+_LIT( KTxtBackSlash, "\\" );
 // ======== LOCAL FUNCTIONS ========
 // ---------------------------------------------------------------------------
 // RArray compare function to compare strings
 // 2nd Phase Constructor
 // ---------------------------------------------------------------------------
 //
 void CMPXFolderScanner::ConstructL()
 {
-iDirScan = CDirScan::NewL(iFs);
 }
 // ---------------------------------------------------------------------------
 // Two Phased Constructor
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 CMPXFolderScanner::~CMPXFolderScanner()
 {
 Cancel();
+iDirQueue.ResetAndDestroy();
-delete iDirScan;
-delete iDir;
 iDrivesToScan.Close();
 }
 // ---------------------------------------------------------------------------
 // Scans a list of drives for files
 MPX_DEBUG1("CMPXFolderScanner::ScanL <---");
 // Copy all the other drives we want to scan
 //
 TInt count( aDrives.Count() );
+MPX_DEBUG2("CMPXFolderScanner::ScanL aDrives %d",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 )
 // Setup the next drive to scan
 //
 if( !SetupNextDriveToScanL() )
 {
 // Kick off the scanning
-iStatus = KRequestPending;
+iCurDirQueueEntry = iDirQueue[ 0 ];
-SetActive();
+iCurFullPath = iCurDirQueueEntry->iFullPath;
-TRequestStatus* status = &iStatus;
+ReadDirEntry();
-User::RequestComplete( status, KErrNone );
 // We've started scanning
 iScanning = ETrue;
 }
 else
 {
 }
 MPX_DEBUG1("CMPXFolderScanner::ScanL --->");
 }
 // ---------------------------------------------------------------------------
+// Reads dir entries asynchronously
+// ---------------------------------------------------------------------------
+//
+void CMPXFolderScanner::ReadDirEntry()
+{
+ASSERT( !IsActive() );
+iCurDirQueueEntry->iDir.Read( iCurDirQueueEntry->iEntryArray, iStatus );
+SetActive();
+}
+// ---------------------------------------------------------------------------
 // Continue Scanning for more files
 // ---------------------------------------------------------------------------
 //
 TBool CMPXFolderScanner::DoScanL()
 {
 MPX_DEBUG1("CMPXFolderScanner::DoScanL <---");
 TBool done (EFalse);
+TBool blocked ( EFalse );
-// Check each file in each directory
-TInt numFiles( iDir->Count() );
+// read successfully
-while( iCount < numFiles )
+if ( iStatus == KErrNone || iStatus == KErrEof )
 {
-TEntry entry = (*iDir)[iCount];
+TBuf<KMaxFileName> buffer;
+const TEntry* entry = NULL;
-// Construct the full path and file name
+TInt numEntries( iCurDirQueueEntry->iEntryArray.Count() );
-TParse fullEntry;
-TPtrC dirPath(iDirScan->FullPath());
+// process the entry one by one
-fullEntry.Set(entry.iName, &dirPath, NULL);
+while ( iCurDirQueueEntry->iPos < numEntries )
+{
-TPtrC fullname = fullEntry.FullName();
+entry = iCurDirQueueEntry->NextEntry();
-TInt index = iObserver.IsMediaFileL( fullname );
+buffer.Zero();
-if( KErrNotFound != index )
-{
+// Generates the full name of the entry
-iObserver.HandleFileAdditionL( fullname, index );
+buffer.Append( *iCurFullPath );
-}
+buffer.Append( entry->iName );
-// Break if we have scanned enough files
+if ( entry->IsDir() ) // entry is a directory
-//
-++iCount;
-if( iCount%KFileNumBreakCount == 0 )
-{
-return EFalse;
-}
-}
-// All files from this directory scanned, so move onto next
-//
-TInt err( KErrNone );
-TBool blocked (EFalse);
-if( iCount == numFiles )
-{
-// Get next Folder
-//
-iCount = 0;
-delete iDir;
-iDir = NULL;
-do
-{
-TRAP(err, iDirScan->NextL(iDir));
-blocked = iObserver.IsPathBlockedL( iDirScan->FullPath() );
-if( blocked )
 {
-delete iDir;
+buffer.Append( KTxtBackSlash );
-iDir = NULL;
+blocked = iObserver.IsPathBlockedL( buffer );
+if ( !blocked )
+{
+CDirQueueEntry* newEntry = CDirQueueEntry::NewL( buffer );
+TInt err = newEntry->iDir.Open( iFs,
+buffer,
+KEntryAttNormal | KEntryAttDir );
+if ( err == KErrNone )
+{
+CDirQueueEntry::PushL( iDirQueue, newEntry );
+}
+else
+{
+delete newEntry;
+}
+}
 }
-if( err == KErrNotReady )
+else // entry is a file
 {
-delete iDir;
+TInt index = iObserver.IsMediaFileL( buffer );
-iDir = NULL;
+if( KErrNotFound != index )
-break;
+{
+iObserver.HandleFileAdditionL( buffer, index );
+}
 }
-}
+if ( iCurDirQueueEntry->iPos % KFileNumBreakCount == 0 )
-while ( err == KErrPathNotFound || blocked );
+{
+return done;
-// No more directories to scan on this drive
+}
-//
+}
-if( !iDir )
+}
-{
-done = SetupNextDriveToScanL();
+// this dir has other entries to read
+if ( iStatus == KErrNone )
+{
+iCurDirQueueEntry->ResetPosition();
+ReadDirEntry();
+}
+// there is nothing to read or some error has occured during reading,
+// try to move to next dir
+else
+{
+CDirQueueEntry::PopAndDestroy( iDirQueue );
+if ( iDirQueue.Count() || !SetupNextDriveToScanL() )
+{
+iCurDirQueueEntry = iDirQueue[ 0 ];
+iCurFullPath = iCurDirQueueEntry->iFullPath;
+ReadDirEntry();
+}
+else // there is nothing to scan
+{
+done = ETrue;
 }
 }
 MPX_DEBUG1("CMPXFolderScanner::DoScanL --->");
 return done;
 MPX_DEBUG1("CMPXFolderScanner::SetupNextDriveToScanL <---");
 TBool done(EFalse);
 TBool blocked(EFalse);
 // Scan next drive
-while( iDir == NULL && !done )
+while( iDrivesToScan.Count() && !iDirQueue.Count() )
 {
-if( !iDrivesToScan.Count() )
+TPath path = iDrivesToScan[0];
-{
-// No more drives or folders that we are interested in
+MPX_DEBUG1( "CMPXFolderScanner::SetupNextDriveToScanL path blocked?" );
-done = ETrue;
+blocked = iObserver.IsPathBlockedL( path );
-}
+MPX_DEBUG2( "CMPXFolderScanner::SetupNextDriveToScanL path blocked %i",
-else
+blocked );
-{
-iDirScan->SetScanDataL(iDrivesToScan[0], KEntryAttNormal, ESortNone);
+// If there was something to scan
-iCount = 0;
+if( !blocked )
-TInt err(KErrNone);
+{
-do
+CDirQueueEntry* newEntry = CDirQueueEntry::NewL( path );
+TInt err = newEntry->iDir.Open( iFs,
+path,
+KEntryAttNormal | KEntryAttDir );
+if ( err == KErrNone )
 {
-MPX_DEBUG1("CMPXFolderScanner::SetupNextDriveToScanL iDirScan->NextL()");
+CDirQueueEntry::PushL( iDirQueue, newEntry );
-TRAP(err, iDirScan->NextL(iDir));
-MPX_DEBUG2("CMPXFolderScanner::SetupNextDriveToScanL path %S", &iDirScan->FullPath());
-blocked = iObserver.IsPathBlockedL( iDirScan->FullPath() );
-MPX_DEBUG2("CMPXFolderScanner::SetupNextDriveToScanL path blocked %i", blocked);
-if( blocked )
-{
-delete iDir;
-iDir = NULL;
-}
-}
-while (err == KErrPathNotFound || blocked );
-// If there was something to scan
-//
-if( iDir != NULL )
-{
 // Inform Observer of the new drive that we are scanning
 iObserver.HandleOpenDriveL( ::ExtractDrive(iDrivesToScan[0]),
 iDrivesToScan[0] );
 }
+else
-// Remove the 0th element
+{
-iDrivesToScan.Remove(0);
+delete newEntry;
-iDrivesToScan.Compress();
+}
 }
+// Remove the 0th element
+iDrivesToScan.Remove(0);
+iDrivesToScan.Compress();
+}
+if ( !iDirQueue.Count() )
+{
+done = ETrue;
 }
 MPX_DEBUG1("CMPXFolderScanner::SetupNextDriveToScanL --->");
 return done;
 {
 MPX_DEBUG1("CMPXFolderScanner::DoScanCompleteL <---");
 // Reset all arrays and data
 iDrivesToScan.Reset();
+iDirQueue.ResetAndDestroy();
 // All done!
 iScanning = EFalse;
-delete iDir;
-iDir = NULL;
 // Callback to observer
 iStateObserver.HandleScanStateCompleteL( MMPXFileScanStateObserver::EScanFiles,
 aErr );
 MPX_DEBUG1("CMPXFolderScanner::DoScanCompleteL --->");
 //
 if( KErrNone != err || done )
 {
 DoScanCompleteL( err );
 }
-else // if( !done )
+else if ( iCurDirQueueEntry->iPos ) // if( !done )
 {
 MPX_DEBUG1("CMPXFolderScanner::RunL -- Run again");
 iStatus = KRequestPending;
 SetActive();
 TRequestStatus* status = &iStatus;
 MPX_DEBUG2("CMPXFolderScanner::RunError(%d)", aError );
 TRAP_IGNORE( DoScanCompleteL( aError ) );
 return KErrNone;
 }
+// ---------------------------------------------------------------------------
+// Two Phased Constructor
+// ---------------------------------------------------------------------------
+//
+CMPXFolderScanner::CDirQueueEntry* CMPXFolderScanner::CDirQueueEntry::NewL(
+const TDesC& aFullPath )
+{
+CDirQueueEntry* self = new ( ELeave ) CDirQueueEntry;
+CleanupStack::PushL( self );
+self->ConstructL( aFullPath );
+CleanupStack::Pop( self );
+return self;
+}
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+//
+CMPXFolderScanner::CDirQueueEntry::~CDirQueueEntry()
+{
+iDir.Close();
+delete iFullPath;
+}
+// ---------------------------------------------------------------------------
+// Push a dir entry into a dir entry queue
+// ---------------------------------------------------------------------------
+//
+void CMPXFolderScanner::CDirQueueEntry::PushL(
+RPointerArray<CDirQueueEntry>& aDirQueue,
+CDirQueueEntry* aDirEntry )
+{
+aDirQueue.AppendL( aDirEntry );
+}
+// ---------------------------------------------------------------------------
+// Pop and destroy a dir entry from a dir entry queue
+// ---------------------------------------------------------------------------
+//
+void CMPXFolderScanner::CDirQueueEntry::PopAndDestroy(
+RPointerArray< CDirQueueEntry >& aDirQueue )
+{
+CDirQueueEntry* entry = aDirQueue[ 0 ];
+delete entry;
+aDirQueue.Remove( 0 );
+}
+// ---------------------------------------------------------------------------
+// CMPXFolderScanner::CDirQueueEntry::NextEntry
+// ---------------------------------------------------------------------------
+//
+const TEntry* CMPXFolderScanner::CDirQueueEntry::NextEntry()
+{
+const TEntry* entry = NULL;
+if ( iPos >= 0 && iPos < iEntryArray.Count() )
+{
+entry = &iEntryArray[ iPos++ ];
+}
+return entry;
+}
+// ---------------------------------------------------------------------------
+// Reset the current position of entry array
+// ---------------------------------------------------------------------------
+//
+void CMPXFolderScanner::CDirQueueEntry::ResetPosition()
+{
+iPos = 0;
+}
+// ---------------------------------------------------------------------------
+// Constructor
+// ---------------------------------------------------------------------------
+//
+CMPXFolderScanner::CDirQueueEntry::CDirQueueEntry()
+{
+// Do nothing
+}
+// ---------------------------------------------------------------------------
+// 2nd Phase Contructor
+// ---------------------------------------------------------------------------
+//
+void CMPXFolderScanner::CDirQueueEntry::ConstructL( const TDesC& aFullPath )
+{
+iFullPath = aFullPath.AllocL();
+}

changeset 58	c76ea6caa649
parent 27	cbb1bfb7ebfb