1 /*

     2 * Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0""

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Main class of the filemanagerengine

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <StringLoader.h>

    22 #include <barsread.h>

    23 #include <sysutil.h>

    24 #include <bautils.h>

    25 //#include <cmgxfilemanager.h>

    26 //#include <mgxfilemanagerfactory.h>

    27 //#include <cmgalbummanager.h>

    28 #include <pathinfo.h>

    29 #include <AknServerApp.h>

    30 #include <FileManagerEngine.rsg>

    31 #ifdef RD_MULTIPLE_DRIVE

    32 #include <driveinfo.h>

    33 #endif // RD_MULTIPLE_DRIVE

    34 #include "CFileManagerEngine.h"

    35 #include "CGflmNavigatorModel.h"

    36 #include "CGflmGroupItem.h"

    37 #include "CGflmFileSystemItem.h"

    38 #include "CGflmDriveItem.h"

    39 #include "CGflmGlobalActionItem.h"

    40 #include "MGflmItemGroup.h"

    41 #include "Cfilemanagerfolderarray.h"

    42 #include "CFilemanagerMimeIconArray.h"

    43 #include "CFileManagerActiveExecute.h"

    44 #include "CFileManagerRefresher.h"

    45 #include "Cfilemanagerfilesystemevent.h"

    46 #include "Cfilemanageractivesize.h"

    47 #include "Cfilemanageractivedelete.h"

    48 #include "FileManagerEngine.hrh"

    49 #include "CFileManagerCommonDefinitions.h"

    50 #include "CFileManagerUtils.h"

    51 #include "CFileManagerItemFilter.h"

    52 #include "CFileManagerDocHandler.h"

    53 #include "FileManagerDebug.h"

    54 #include "CFileManagerItemProperties.h"

    55 #include "CFileManagerRemovableDriveHandler.h"

    56 #include "CFileManagerRemoteDriveHandler.h"

    57 #include "CFileManagerBackupSettings.h"

    58 #include "CFileManagerRestoreSettings.h"

    59 #include "CFileManagerActiveRename.h"

    60 #include "CFileManagerFeatureManager.h"

    61 

    62 // CONSTANTS

    63 const TUint16 KIllegalChars[] = {

    64     '<', '>', '"', '/', '\\', '|', ':', '*', '?',

    65     0xFF02, // Full width quote

    66     0xFF0A, // Full width asterisk

    67     0xFF0F, // Full width slash

    68     0xFF1A, // Full width colon

    69     0xFF1C, // Full width left arrow

    70     0xFF1E, // Full width right arrow

    71     0xFF1F, // Full width question mark

    72     0xFF3C, // Full width back slash

    73     0xFF5C, // Full width pipe

    74     0x201C, // Left quote

    75     0x201D, // Right quote

    76     0x201F, // Reversed quote

    77     0x21B2, // Downwards arrow with tip leftwards

    78     0, // Array terminator

    79 };

    80 

    81 //const TInt KMGFileArrayGranularity = 32;

    82 

    83 

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

    85 // -----------------------------------------------------------------------------

    86 // SearchMGAlbumIdL

    87 // -----------------------------------------------------------------------------

    88 //

    89 /*static TInt SearchMGAlbumIdL(

    90         CMGAlbumManager& aAlbumManager, const TDesC& aFilename )

    91     {

    92     CDesCArray* fileArray =

    93         new ( ELeave ) CDesCArraySeg( KMGFileArrayGranularity );

    94     CleanupStack::PushL( fileArray );

    95     TInt albumCount( aAlbumManager.AlbumCount() );

    96     TInt ret( KErrNotFound );

    97     for( TInt i( 0 ); i < albumCount; ++i )

    98         {

    99         CMGAlbumInfo* albumInfo = aAlbumManager.AlbumInfoLC( i );

   100         TInt albumId( albumInfo->Id() );

   101         CleanupStack::PopAndDestroy( albumInfo );

   102         fileArray->Reset();

   103         aAlbumManager.GetAlbumFileArrayL( albumId, *fileArray );

   104         TInt pos( 0 );

   105         if( !fileArray->Find( aFilename, pos ) )

   106             {

   107             ret = albumId;

   108             break;

   109             }

   110         }

   111     CleanupStack::PopAndDestroy( fileArray );

   112     return ret;

   113     }

   114 */

   115 

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

   117 

   118 // -----------------------------------------------------------------------------

   119 // CFileManagerEngine::CFileManagerEngine

   120 // C++ default constructor can NOT contain any code, that

   121 // might leave.

   122 // -----------------------------------------------------------------------------

   123 //

   124 CFileManagerEngine::CFileManagerEngine( RFs& aFs ) :

   125 		iFs( aFs ), iObserver( NULL ), iSisFile( EFalse )

   126     {

   127     FUNC_LOG

   128     }

   129 

   130 // -----------------------------------------------------------------------------

   131 // CFileManagerEngine::NewL

   132 // Two-phased constructor.

   133 // -----------------------------------------------------------------------------

   134 //

   135 EXPORT_C CFileManagerEngine* CFileManagerEngine::NewL( RFs& aFs )

   136     {

   137     CFileManagerEngine* self = new ( ELeave ) CFileManagerEngine( aFs );

   138 

   139     CleanupStack::PushL( self );

   140     self->ConstructL();

   141     CleanupStack::Pop( self );

   142 

   143     return self;

   144     }

   145 

   146 // -----------------------------------------------------------------------------

   147 // CFileManagerEngine::ConstructL

   148 // -----------------------------------------------------------------------------

   149 //

   150 void CFileManagerEngine::ConstructL()

   151     {

   152     FUNC_LOG

   153 

   154     INFO_LOG( "CFileManagerEngine::ConstructL()-Create Feature Manager" )

   155     iFeatureManager = CFileManagerFeatureManager::NewL();

   156 

   157     iState = ENavigation;

   158 

   159     INFO_LOG( "CFileManagerEngine::ConstructL()-Create navigator" )

   160     iNavigator = CGflmNavigatorModel::NewL( iFs );

   161 

   162     // Create drives group

   163     MGflmItemGroup* newGroup = iNavigator->CreateGroupL(

   164         EFileManagerDrivesGroup, EDrives );

   165 #ifdef RD_FILE_MANAGER_BACKUP

   166     // Set backup action

   167     HBufC* actionCaption = StringLoader::LoadLC( R_QTN_FMGR_MAIN_BACKUP );

   168     newGroup->AddActionItemL( EFileManagerBackupAction, *actionCaption );

   169     CleanupStack::PopAndDestroy( actionCaption );

   170 #endif // RD_FILE_MANAGER_BACKUP

   171 

   172     // Create files and folders groups

   173     iNavigator->CreateGroupL( EFileManagerFilesGroup, EDirectories | EFiles );

   174 

   175     INFO_LOG( "CFileManagerEngine::ConstructL()-Create refresher" )

   176     iRefresher = CFileManagerRefresher::NewL( *iNavigator );

   177 

   178     INFO_LOG( "CFileManagerEngine::ConstructL()-Create utils" )

   179     iUtils = CFileManagerUtils::NewL( iFs, *iNavigator, *iFeatureManager );

   180 

   181     INFO_LOG( "CFileManagerEngine::ConstructL()-Create disk event" )

   182     iDiskEvent = CFileManagerFileSystemEvent::NewL( iFs, *this, ENotifyDisk );

   183 

   184     INFO_LOG( "CFileManagerEngine::ConstructL()-Create removable drive handler" )

   185     iRemovableDrvHandler = CFileManagerRemovableDriveHandler::NewL(

   186         iFs, *iUtils, *this );

   187     INFO_LOG( "CFileManagerEngine::ConstructL()-Create remote drive handler" )

   188     iRemoteDrvHandler = CFileManagerRemoteDriveHandler::NewL(

   189         *this, *iUtils );

   190 

   191     INFO_LOG( "CFileManagerEngine::ConstructL()-Create item filter" )

   192     iItemFilter = CFileManagerItemFilter::NewL( *this );

   193     iNavigator->SetCustomFilter( iItemFilter );

   194 

   195     // Store new starting index

   196     iNavigationIndices.AppendL( KErrNotFound );

   197     }

   198 

   199 // -----------------------------------------------------------------------------

   200 // CFileManagerEngine::~CFileManagerEngine

   201 // Destructor

   202 // -----------------------------------------------------------------------------

   203 // 

   204 EXPORT_C CFileManagerEngine::~CFileManagerEngine()

   205     {

   206     delete iActiveRename;

   207     iNavigationIndices.Reset();

   208     delete iRemoteDrvHandler;

   209     delete iBackupSettings;

   210     delete iRestoreSettings;

   211     delete iRemovableDrvHandler;

   212     delete iDocHandler;

   213     //delete iMgxFileManager;

   214     delete iFileSystemEvent;

   215     delete iRefresher;

   216     delete iNavigator;

   217     delete iItemFilter;

   218     delete iSearchString;

   219     delete iSearchFolder;

   220     delete iActiveSize;

   221     delete iDiskEvent;

   222     delete iUtils;

   223     delete iDriveName;

   224     delete iFeatureManager;

   225     }

   226 

   227 // -----------------------------------------------------------------------------

   228 // CFileManagerEngine::SetFileSystemEventL

   229 // -----------------------------------------------------------------------------

   230 //

   231 void CFileManagerEngine::SetFileSystemEventL( const TDesC& aFullPath )

   232     {

   233     delete iFileSystemEvent;

   234     iFileSystemEvent = NULL;

   235     if ( aFullPath != KNullDesC )

   236         {

   237         iFileSystemEvent = CFileManagerFileSystemEvent::NewL(

   238             iFs, *this, ENotifyEntry, aFullPath );

   239         }

   240     else

   241         {

   242         iFileSystemEvent = CFileManagerFileSystemEvent::NewL(

   243             iFs, *this, ENotifyEntry );

   244         }

   245     }

   246 

   247 // -----------------------------------------------------------------------------

   248 // CFileManagerEngine::IndexToFullPathL

   249 // -----------------------------------------------------------------------------

   250 //

   251 EXPORT_C HBufC* CFileManagerEngine::IndexToFullPathL(

   252         const TInt aIndex ) const

   253     {

   254     if ( aIndex < 0 || aIndex >= iNavigator->MdcaCount() )

   255         {

   256         User::Leave( KErrNotFound );

   257         }

   258     CGflmGroupItem* item = iNavigator->Item( aIndex );

   259     HBufC* fullPath = NULL;

   260     switch ( item->Type() )

   261         {

   262         case CGflmGroupItem::EFile: // Fall through

   263         case CGflmGroupItem::EDirectory:

   264             {

   265             CGflmFileSystemItem* fsItem =

   266                 static_cast< CGflmFileSystemItem* >( item );

   267             fullPath = fsItem->FullPathL();

   268             break;

   269             }

   270         case CGflmGroupItem::EDrive:

   271             {

   272             CGflmDriveItem* drvItem =

   273                 static_cast< CGflmDriveItem* >( item );

   274             fullPath = drvItem->RootDirectory().AllocL();

   275             break;

   276             }

   277         default:

   278             {

   279             User::Leave( KErrNotFound );

   280             break;

   281             }

   282         }

   283     return fullPath;

   284     }

   285 

   286 // -----------------------------------------------------------------------------

   287 // CFileManagerEngine::IndexToFullPathLC

   288 // -----------------------------------------------------------------------------

   289 //

   290 EXPORT_C HBufC* CFileManagerEngine::IndexToFullPathLC(

   291         const TInt aIndex ) const

   292     {

   293     HBufC* fullPath = IndexToFullPathL( aIndex );

   294     CleanupStack::PushL( fullPath );

   295     return fullPath;

   296     }

   297 

   298 // -----------------------------------------------------------------------------

   299 // CFileManagerEngine::AddFullPathLC

   300 // -----------------------------------------------------------------------------

   301 //

   302 HBufC* CFileManagerEngine::AddFullPathLC(

   303         const TDesC& aName, const TBool aIsFolder )

   304     {

   305     TPtrC dir( iNavigator->CurrentDirectory() );

   306     TInt len( dir.Length() + aName.Length() );

   307     if ( aIsFolder )

   308         {

   309         ++len; // Ensure space for backslash

   310         }

   311     HBufC* fullPath = HBufC::NewLC( len );

   312     TPtr ptr( fullPath->Des() );

   313     ptr.Append( dir );

   314     ptr.Append( aName );

   315     if ( aIsFolder )

   316         {

   317         CFileManagerUtils::EnsureFinalBackslash( ptr );

   318         }

   319     return fullPath;

   320     }

   321 

   322 // -----------------------------------------------------------------------------

   323 // CFileManagerEngine::SetMemoryL

   324 // -----------------------------------------------------------------------------

   325 //

   326 EXPORT_C TInt CFileManagerEngine::SetMemoryL( TFileManagerMemory /*aMemory*/ )

   327     {

   328     // Just check current drive avaibility, no matter what memory is set

   329     iLastDriveAvailable = CurrentDriveAvailable();

   330     return KErrNone;

   331     }

   332 

   333 // -----------------------------------------------------------------------------

   334 // CFileManagerEngine::Memory

   335 // -----------------------------------------------------------------------------

   336 //

   337 EXPORT_C TFileManagerMemory CFileManagerEngine::Memory() const

   338     {

   339 #ifdef RD_MULTIPLE_DRIVE

   340     CGflmDriveItem* drvItem = iNavigator->CurrentDrive();

   341     if ( drvItem )

   342         {

   343         TUint driveStatus( drvItem->DriveStatus() );

   344         if ( driveStatus & DriveInfo::EDriveInternal )

   345             {

   346             if ( driveStatus & DriveInfo::EDriveExternallyMountable )

   347                 {

   348                 return EFmMassStorage;

   349                 }

   350             return EFmPhoneMemory;

   351             }

   352         else if ( driveStatus & DriveInfo::EDriveUsbMemory )

   353             {

   354             return EFmUsbMemory;

   355             }

   356         else if ( driveStatus & DriveInfo::EDriveRemovable )

   357             {

   358             return EFmMemoryCard;

   359             }

   360         else if ( driveStatus & DriveInfo::EDriveRemote )

   361             {

   362             return EFmRemoteDrive;

   363             }

   364         }

   365     return EFmPhoneMemory;

   366 #else // RD_MULTIPLE_DRIVE

   367     CGflmDriveItem* drvItem = iNavigator->CurrentDrive();

   368     if ( drvItem )

   369         {

   370         const TVolumeInfo vol( drvItem->VolumeInfo() );

   371         if ( vol.iDrive.iDriveAtt & KDriveAttInternal )

   372             {

   373             return EFmPhoneMemory;

   374             }

   375         else if ( vol.iDrive.iDriveAtt & KDriveAttRemovable )

   376             {

   377             return EFmMemoryCard;

   378             }

   379         else if ( vol.iDrive.iDriveAtt & KDriveAttRemote )

   380             {

   381             return EFmRemoteDrive;

   382             }

   383         }

   384     return EFmPhoneMemory;

   385 #endif // RD_MULTIPLE_DRIVE

   386     }

   387 

   388 // -----------------------------------------------------------------------------

   389 // CFileManagerEngine::FileList

   390 // -----------------------------------------------------------------------------

   391 //

   392 EXPORT_C MDesCArray* CFileManagerEngine::FileList() const

   393     {

   394     return iNavigator;

   395     }

   396 

   397 // -----------------------------------------------------------------------------

   398 // CFileManagerEngine::OpenL

   399 // -----------------------------------------------------------------------------

   400 //

   401 EXPORT_C void CFileManagerEngine::OpenL( const TInt aIndex )

   402     {

   403     // Store drive letter for current drive changed checking

   404     TChar prevDrive( 0 );

   405     TPtrC prevDir( iNavigator->CurrentDirectory() );

   406     if ( prevDir.Length() )

   407         {

   408         prevDrive = prevDir[ 0 ];

   409         }   

   410 

   411     if ( aIndex < 0 || aIndex >= iNavigator->MdcaCount() )

   412         {

   413         User::Leave( KErrNotFound );

   414         }

   415     CGflmGroupItem* item = iNavigator->Item( aIndex );

   416     switch ( item->Type() )

   417         {

   418         case CGflmGroupItem::EFile: // Fall through

   419         case CGflmGroupItem::EDirectory: // Fall through

   420         case CGflmGroupItem::EDrive:

   421             {

   422 

   423 #ifdef RD_MULTIPLE_DRIVE

   424             // Ensure that default folders exist

   425             if ( item->Type() == CGflmGroupItem::EDrive )

   426                 {

   427                 CGflmDriveItem* drvItem =

   428                     static_cast< CGflmDriveItem* >( item );

   429                 iUtils->CreateDefaultFolders(

   430                     drvItem->Drive(), EFalse );

   431                 }

   432 #endif // RD_MULTIPLE_DRIVE

   433 

   434             // Store navigation position

   435             SetCurrentIndex( aIndex );

   436 

   437             HBufC* fullPath = IndexToFullPathLC( aIndex );

   438             if ( item->Type() == CGflmGroupItem::EFile )

   439                 {

   440                 OpenFileL( *fullPath );

   441                 }

   442             else

   443                 {

   444                 OpenDirectoryL( *fullPath );

   445 

   446                 // Setup new navigation position

   447                 iNavigationIndices.AppendL( 0 );

   448                 }

   449             CleanupStack::PopAndDestroy( fullPath );

   450             break;

   451             }

   452         case CGflmGroupItem::EGlobalActionItem:

   453             {

   454             CGflmGlobalActionItem* actItem = 

   455                 static_cast< CGflmGlobalActionItem* >( item );

   456             if ( iProcessObserver )

   457                 {

   458                 iProcessObserver->NotifyL(

   459                     MFileManagerProcessObserver::ENotifyActionSelected,

   460                     actItem->Id() );

   461                 }

   462             break;

   463             }

   464         default:

   465             {

   466             break;

   467             }

   468         }

   469  

   470     // Ensure that cached current drive info gets updated if drive was changed

   471     TPtrC dir( iNavigator->CurrentDirectory() );

   472     if ( dir.Length() )

   473         {

   474         if ( dir[ 0 ] != prevDrive )

   475             {

   476             iCurrentDriveInfoRefreshed = EFalse;

   477             }

   478         }

   479     }

   480 

   481 // -----------------------------------------------------------------------------

   482 // CFileManagerEngine::SetObserver

   483 // -----------------------------------------------------------------------------

   484 //

   485 EXPORT_C void CFileManagerEngine::SetObserver(

   486         MFileManagerProcessObserver* aObserver )

   487     {

   488     iProcessObserver = aObserver;

   489     iRefresher->SetObserver( aObserver );

   490     iRemovableDrvHandler->SetObserver( aObserver );

   491     }

   492 

   493 // -----------------------------------------------------------------------------

   494 // CFileManagerEngine::CurrentDirectory

   495 // -----------------------------------------------------------------------------

   496 //

   497 EXPORT_C TPtrC CFileManagerEngine::CurrentDirectory() const

   498     {

   499     return iNavigator->CurrentDirectory();

   500     }

   501 

   502 // -----------------------------------------------------------------------------

   503 // CFileManagerEngine::CurrentDirectory

   504 // -----------------------------------------------------------------------------

   505 //

   506 EXPORT_C TPtrC CFileManagerEngine::LocalizedNameOfCurrentDirectory() const

   507     {

   508     return iNavigator->LocalizedNameOfCurrentDirectory();

   509     }

   510 

   511 // -----------------------------------------------------------------------------

   512 // CFileManagerEngine::BackstepL

   513 // -----------------------------------------------------------------------------

   514 //

   515 EXPORT_C void CFileManagerEngine::BackstepL()

   516     {

   517     // Store drive letter for current drive changed checking

   518     TChar prevDrive( 0 );

   519     // Note that prevDir gets invalid after BackstepL

   520     TPtrC prevDir( iNavigator->CurrentDirectory() );

   521     if ( prevDir.Length() )

   522         {

   523         prevDrive = prevDir[ 0 ];

   524         }

   525 

   526     // Setup backstep navigation index

   527     if ( !iNavigator->NavigationLevel() )

   528         {

   529         // Always first for initial root level

   530         iCurrentItemName.Zero();

   531         }

   532     else if( !iCurrentItemName.Length() )

   533         {

   534         // Otherwise previously opened folder

   535         iCurrentItemName.Copy(

   536             iNavigator->LocalizedNameOfCurrentDirectory() );

   537         }

   538     TInt pos( iNavigationIndices.Count() - 1 );

   539     if ( pos >= 0 )

   540         {

   541         iNavigationIndices.Remove( pos );

   542         }

   543 

   544     iNavigator->BackstepL();

   545 

   546     // Ensure that cached current drive info gets updated if drive was changed

   547     TPtrC dir( iNavigator->CurrentDirectory() );

   548     if ( dir.Length() )

   549         {

   550         if ( dir[ 0 ] != prevDrive )

   551             {

   552             iCurrentDriveInfoRefreshed = EFalse;

   553             }

   554         }

   555     else

   556         {

   557         // Make sure that drive info is refreshed

   558         ClearDriveInfo();

   559         }

   560     }

   561 

   562 // -----------------------------------------------------------------------------

   563 // CFileManagerEngine::FileTypeL

   564 // -----------------------------------------------------------------------------

   565 //

   566 EXPORT_C TUint32 CFileManagerEngine::FileTypeL( const TInt aIndex ) const

   567     {

   568     TUint32 fileType( CFileManagerItemProperties::ENotDefined );

   569     if ( aIndex >= 0 )

   570         {

   571         HBufC* fullPath = IndexToFullPathLC( aIndex );

   572         fileType = FileTypeL( *fullPath );

   573         CleanupStack::PopAndDestroy( fullPath ); 

   574         }

   575     return fileType;

   576     }

   577 

   578 // -----------------------------------------------------------------------------

   579 // CFileManagerEngine::FileTypeL

   580 // -----------------------------------------------------------------------------

   581 //

   582 EXPORT_C TUint32 CFileManagerEngine::FileTypeL( const TDesC& aFullPath ) const

   583     {

   584     return iUtils->FileTypeL( aFullPath );

   585     }

   586 

   587 // -----------------------------------------------------------------------------

   588 // CFileManagerEngine::DeleteL

   589 // -----------------------------------------------------------------------------

   590 //

   591 EXPORT_C CFileManagerActiveDelete* CFileManagerEngine::CreateActiveDeleteL( 

   592                                               CArrayFixFlat< TInt >& aIndexList )

   593     {

   594 

   595     CFileManagerActiveDelete* activeDelete = 

   596         CFileManagerActiveDelete::NewL( aIndexList, *this, *iUtils );

   597     return activeDelete;

   598     }

   599 

   600 // -----------------------------------------------------------------------------

   601 // CFileManagerEngine::NewFolder

   602 // -----------------------------------------------------------------------------

   603 //

   604 EXPORT_C void CFileManagerEngine::NewFolderL( const TDesC& aFolderName )

   605     {   

   606     // Add backslash to end so that MkDir realizes that it is directory

   607     HBufC* fullPath = AddFullPathLC( aFolderName, ETrue );

   608     TPtr ptr( fullPath->Des() );

   609 

   610     if ( ptr.Length() <= KMaxFileName )

   611         {

   612         iCurrentItemName.Copy( aFolderName );

   613 

   614         // Remove white spaces from end, file server also ignores those

   615         iCurrentItemName.TrimRight();

   616 

   617         User::LeaveIfError( iFs.MkDir( ptr ) );

   618         }

   619     else

   620         {

   621         User::Leave( KErrBadName );

   622         }

   623 

   624     CleanupStack::PopAndDestroy( fullPath ); 

   625     }

   626 

   627 // -----------------------------------------------------------------------------

   628 // CFileManagerEngine::SetCurrentItemName

   629 // -----------------------------------------------------------------------------

   630 //

   631 EXPORT_C void CFileManagerEngine::SetCurrentItemName( const TDesC& aFileName )

   632     { 

   633 

   634     iCurrentItemName.Copy( aFileName );

   635 

   636     // Remove white spaces from end, file server also ignores those

   637     iCurrentItemName.TrimRight();

   638 

   639     }

   640 // -----------------------------------------------------------------------------

   641 // CFileManagerEngine::RenameL

   642 // -----------------------------------------------------------------------------

   643 //

   644 EXPORT_C void CFileManagerEngine::RenameL(

   645         const TInt aIndex,

   646         const TDesC& aNewFileName )

   647     {

   648     FUNC_LOG

   649 

   650     // Make those given names as full paths

   651     TBool isFolder( IsFolder( aIndex ) );

   652     HBufC* fullPathOld = IndexToFullPathLC( aIndex );

   653     HBufC* fullPathNew = AddFullPathLC( aNewFileName, isFolder );

   654 

   655     if ( !fullPathOld->Compare( *fullPathNew ) )

   656         {

   657         // The name has not changed, rename is not required

   658         CleanupStack::PopAndDestroy( fullPathNew );

   659         CleanupStack::PopAndDestroy( fullPathOld );

   660         return;

   661         }

   662 

   663     // Gallery notification is relevant only for local drives

   664     TBool isRemoteDrive( iUtils->IsRemoteDrive( *fullPathOld ) );

   665 

   666     // Media Gallery albums get easily messed up when files are renamed.

   667     // Direct album editing seems a trick but it is seems to only way 

   668     // to update Gallery properly.

   669     /*CMGAlbumManager* albumManager = MGAlbumManagerFactory::NewAlbumManagerL();

   670     CleanupStack:: PushL( albumManager );

   671     TInt albumId( KErrNotFound );

   672     if ( !isFolder && !isRemoteDrive )

   673         {

   674         // Do album search for files only

   675         TRAPD( err, albumId = SearchMGAlbumIdL( *albumManager, *fullPathOld ) );

   676         if( err != KErrNone )

   677             {

   678             albumId = KErrNotFound;

   679             }

   680         }

   681 */

   682     // Handle rename

   683     delete iActiveRename;

   684     iActiveRename = NULL;

   685     iActiveRename = CFileManagerActiveRename::NewL(

   686         *this, *iUtils, *fullPathOld, *fullPathNew );

   687     ShowWaitDialogL( *iActiveRename );

   688     User::LeaveIfError( iActiveRename->Result() );

   689 

   690     // Update Media Gallery album if file exist in album

   691     /*if( albumId != KErrNotFound )

   692         {

   693         TRAP_IGNORE( { albumManager->RemoveFromAlbumL( *fullPathOld, albumId );

   694             albumManager->AddToAlbumL( *fullPathNew, albumId ); } );

   695         }

   696     CleanupStack::PopAndDestroy( albumManager );*/

   697 

   698     iCurrentItemName.Copy( aNewFileName );

   699 

   700     /*if ( !isRemoteDrive )

   701         {

   702         // Notify Media Gallery again

   703         TRAP_IGNORE( MGXFileManagerL().UpdateL( *fullPathOld, *fullPathNew ) );

   704         }*/

   705 

   706     CleanupStack::PopAndDestroy( fullPathNew );

   707     CleanupStack::PopAndDestroy( fullPathOld );

   708     }

   709 

   710 // -----------------------------------------------------------------------------

   711 // CFileManagerEngine::FolderLevel

   712 // -----------------------------------------------------------------------------

   713 //

   714 EXPORT_C TInt CFileManagerEngine::FolderLevel()

   715     {

   716     CGflmDriveItem* drvItem = iNavigator->CurrentDrive();

   717     if ( !drvItem )

   718         {

   719         return KErrNotFound;  // Main level

   720         }

   721     TPtrC dir( iNavigator->CurrentDirectory() );

   722     TInt count( dir.Length() );

   723     if ( !count )

   724         {

   725         return KErrNotFound; // Main level

   726         }

   727     // Count how many backslashes is in string to figure out the deepness

   728     TInt min( drvItem->RootDirectory().Length() );

   729 	TInt bsCount( 0 );

   730 	while( count > min )

   731 		{

   732         --count;

   733 		if ( dir[ count ] == KFmgrBackslash()[ 0 ] )

   734 			{

   735 			++bsCount;

   736 			}

   737 		}

   738 	return bsCount;

   739     }

   740 

   741 // -----------------------------------------------------------------------------

   742 // CFileManagerEngine::IsNameFoundL

   743 // -----------------------------------------------------------------------------

   744 //

   745 EXPORT_C TBool CFileManagerEngine::IsNameFoundL( const TDesC& aName )

   746     {

   747     return iUtils->IsNameFoundL( aName );

   748     }

   749 

   750 // -----------------------------------------------------------------------------

   751 // CFileManagerEngine::CurrentDrive

   752 // -----------------------------------------------------------------------------

   753 //

   754 EXPORT_C TInt CFileManagerEngine::CurrentDrive()

   755     {

   756     TInt ret( KErrNotFound );

   757     TPtrC ptr( iNavigator->CurrentDirectory() );

   758     if ( ptr.Length() )

   759         {

   760         if( RFs::CharToDrive( ptr[ 0 ], ret ) != KErrNone )

   761             {

   762             ret = KErrNotFound;

   763             }

   764         }

   765     return ret;

   766     }

   767 

   768 // -----------------------------------------------------------------------------

   769 // CFileManagerEngine::GetItemInfoL

   770 // -----------------------------------------------------------------------------

   771 //

   772 EXPORT_C CFileManagerItemProperties* CFileManagerEngine::GetItemInfoL( 

   773                                                 const TInt aIndex )

   774     {

   775     if ( aIndex < 0 || aIndex >= iNavigator->MdcaCount() )

   776         {

   777         User::Leave( KErrNotFound );

   778         }

   779     CGflmGroupItem* item = iNavigator->Item( aIndex );

   780     return CFileManagerItemProperties::NewL( *item, *iUtils, *this );

   781     }

   782 

   783 // -----------------------------------------------------------------------------

   784 // CFileManagerEngine::SetState

   785 // -----------------------------------------------------------------------------

   786 //

   787 EXPORT_C void CFileManagerEngine::SetState( TState aState )

   788     {

   789     iState = aState;

   790     iNavigator->EnableSearchMode( iState == ESearch );

   791     }

   792 

   793 // -----------------------------------------------------------------------------

   794 // CFileManagerEngine::SetState

   795 // -----------------------------------------------------------------------------

   796 //

   797 EXPORT_C CFileManagerEngine::TState CFileManagerEngine::State() const

   798     {

   799     return iState;

   800     }

   801 

   802 // -----------------------------------------------------------------------------

   803 // CFileManagerEngine::RefreshDirectory

   804 // -----------------------------------------------------------------------------

   805 //

   806 EXPORT_C void CFileManagerEngine::RefreshDirectory()

   807     {

   808     FUNC_LOG

   809 

   810 #ifdef FILE_MANAGER_INFO_LOG_ENABLED

   811     if ( iState == ENavigation )

   812         {

   813         TPtrC dir( iNavigator->CurrentDirectory() );

   814         INFO_LOG1( "CFileManagerEngine::RefreshDirectory-dir=%S", &dir );

   815         }

   816 #endif // FILE_MANAGER_INFO_LOG_ENABLED

   817 

   818     iRefresher->Refresh();

   819     }

   820 

   821 // -----------------------------------------------------------------------------

   822 // CFileManagerEngine::GetMMCInfoL

   823 // -----------------------------------------------------------------------------

   824 //

   825 EXPORT_C TFileManagerDriveInfo CFileManagerEngine::GetMMCInfoL() const

   826     {

   827     TFileManagerDriveInfo drvInfo;

   828     GetDriveInfoL(

   829         PathInfo::MemoryCardRootPath(), drvInfo );

   830     return drvInfo;

   831     }

   832 

   833 // -----------------------------------------------------------------------------

   834 // CFileManagerEngine::SearchString

   835 // -----------------------------------------------------------------------------

   836 //

   837 EXPORT_C TPtrC CFileManagerEngine::SearchString() const

   838     {

   839     if ( iSearchString )

   840         {

   841         return iSearchString->Des();

   842         }

   843     return TPtrC( KNullDesC );

   844     }

   845 

   846 // -----------------------------------------------------------------------------

   847 // CFileManagerEngine::IsValidName

   848 // -----------------------------------------------------------------------------

   849 //

   850 EXPORT_C TBool CFileManagerEngine::IsValidName(

   851         const TDesC& aDriveAndPath, const TDesC& aName, TBool aIsFolder ) const

   852     {

   853     // Check name for bad chars

   854     const TUint16 KMinAllowedChar = 0x0020;

   855     const TUint16 KParagraphSeparator = 0x2029;

   856     const TUint16 KDot = '.';

   857     TInt nameLen( aName.Length() );

   858     if ( !nameLen )

   859         {

   860         return EFalse;

   861         }

   862     for ( TInt i( 0 ); i < nameLen; i++ )

   863         {

   864         TUint16 ch( aName[ i ] );

   865         if ( ch < KMinAllowedChar || ch == KParagraphSeparator )

   866             {

   867             return EFalse;

   868             }

   869         }

   870     // File system ignores totally dot in the end of name, so 

   871     // we set here as not valid name, so that user gets correctly informed

   872     if ( aName[ nameLen - 1 ] == KDot || IllegalChars( aName ) )

   873         {

   874         return EFalse;

   875         }

   876     // Get full path length

   877     TPtrC pathPtr( aDriveAndPath.Length() ?

   878         TPtrC( aDriveAndPath ) : TPtrC( iNavigator->CurrentDirectory() ) );

   879     TInt pathLen( pathPtr.Length() );

   880     if ( !pathLen )

   881         {

   882         return EFalse;

   883         }

   884     TInt fullPathLen( pathLen );

   885     if ( !CFileManagerUtils::HasFinalBackslash( pathPtr ) )

   886         {

   887         ++fullPathLen; // Add backslash before name

   888         }

   889     fullPathLen += nameLen;

   890     if ( aIsFolder )

   891         {

   892         ++fullPathLen; // Add folder final backslash

   893         }

   894 

   895     TBool ret( EFalse );

   896     if ( fullPathLen <= KMaxFileName )

   897         {

   898         // Check full path

   899         HBufC* fullPath = HBufC::New( KMaxFileName );

   900         if ( fullPath )

   901             {

   902             TPtr ptr( fullPath->Des() );

   903             ptr.Copy( pathPtr );

   904             CFileManagerUtils::EnsureFinalBackslash( ptr ); // Add backslash before name

   905             ptr.Append( aName );

   906             ret = iFs.IsValidName( ptr );

   907             delete fullPath;

   908             }

   909         }

   910     return ret;

   911     }

   912 

   913 // -----------------------------------------------------------------------------

   914 // CFileManagerEngine::IllegalChars

   915 // -----------------------------------------------------------------------------

   916 //

   917 EXPORT_C TBool CFileManagerEngine::IllegalChars( const TDesC& aName ) const

   918     {

   919     for ( TInt i( 0 ); KIllegalChars[ i ]; i++ )

   920         {

   921         if ( aName.Locate( KIllegalChars[ i ] ) != KErrNotFound )

   922             {

   923             return ETrue;

   924             }

   925         }

   926     return EFalse;

   927     }

   928 

   929 // -----------------------------------------------------------------------------

   930 // CFileManagerEngine::EnoughSpaceL

   931 // -----------------------------------------------------------------------------

   932 //

   933 EXPORT_C TBool CFileManagerEngine::EnoughSpaceL(

   934         const TDesC& aToFolder, 

   935         TInt64 aSize, 

   936         MFileManagerProcessObserver::TFileManagerProcess aOperation ) const

   937     {

   938     TPtrC src( iNavigator->CurrentDirectory() );

   939     TInt srcDrv( KErrNotFound );

   940     if ( src.Length() )

   941         {

   942         User::LeaveIfError( RFs::CharToDrive( src[ 0 ], srcDrv ) );

   943         }

   944     TInt dstDrv( KErrNotFound );

   945     if ( aToFolder.Length() )

   946         {

   947         User::LeaveIfError( RFs::CharToDrive( aToFolder[ 0 ], dstDrv ) );

   948         }

   949     else

   950         {

   951         return ETrue; // Invalid destination

   952         }

   953 

   954     TBool ret( EFalse );

   955 

   956     // if operation is move and drive is same so there is always enough memory

   957     if ( srcDrv == dstDrv &&

   958         aOperation == MFileManagerProcessObserver::EMoveProcess )

   959         {

   960         ret = ETrue;

   961         }

   962     else

   963         {

   964         ret = !SysUtil::DiskSpaceBelowCriticalLevelL(

   965             &iFs,  aSize , dstDrv );

   966         }

   967 

   968     return ret;

   969     }

   970 

   971 // -----------------------------------------------------------------------------

   972 // CFileManagerEngine::FileSystemEvent

   973 // -----------------------------------------------------------------------------

   974 //

   975 EXPORT_C void CFileManagerEngine::FileSystemEvent( TBool aEventOn )

   976     {

   977     INFO_LOG2(

   978         "CFileManagerEngine::FileSystemEvent-aEventOn=%d,iFileSystemEventEnabled=%d",

   979         aEventOn, iFileSystemEventEnabled )

   980 

   981     INFO_LOG2(

   982         "CFileManagerEngine::FileSystemEvent-iDriveAddedOrChangedPostponed=%d,iEmbeddedApplicationOn=%d ",

   983         iDriveAddedOrChangedPostponed, iEmbeddedApplicationOn )

   984 

   985     if ( !iFileSystemEventEnabled && aEventOn )

   986         {

   987         iDriveAddedOrChangedPostponed = EFalse;

   988         iFileSystemEventEnabled = ETrue;

   989         }

   990     else if ( iFileSystemEventEnabled && !aEventOn )

   991         {

   992         iFileSystemEventEnabled = EFalse;

   993         if ( iDriveAddedOrChangedPostponed )

   994             {

   995             iDriveAddedOrChangedPostponed = EFalse;

   996             TRAP_IGNORE( DriveAddedOrChangedL() );

   997             }

   998         }

   999 

  1000     if ( iUtils->IsRemoteDrive( iNavigator->CurrentDirectory() ) )

  1001         {

  1002          // At the moment no use to have event for remote drives

  1003         delete iFileSystemEvent;

  1004         iFileSystemEvent = NULL;

  1005         return;

  1006         }

  1007 

  1008     // Set event on when there is no embedded app with event

  1009     if ( aEventOn &&

  1010          !( iEmbeddedApplicationOn && iFileSystemEvent ) )

  1011         {

  1012         TInt err( KErrNone );

  1013         switch ( iState )

  1014             {

  1015             case ENavigation:

  1016                 {

  1017                 TRAP( err, SetFileSystemEventL( iNavigator->CurrentDirectory() ) );

  1018                 break;

  1019                 }

  1020             case ESearch:

  1021                 {

  1022                 TRAP( err, SetFileSystemEventL() );

  1023                 break;

  1024                 }

  1025             default:

  1026                 {

  1027                 break;

  1028                 }

  1029             }

  1030         if ( err != KErrNone && iProcessObserver )

  1031             {

  1032             iProcessObserver->Error( err );

  1033             }

  1034         }

  1035     // Check event and set it off when there is no embedded app

  1036     else if( !iEmbeddedApplicationOn && iFileSystemEvent )

  1037         {

  1038         iFileSystemEvent->CheckFileSystemEvent();

  1039         delete iFileSystemEvent;

  1040         iFileSystemEvent = NULL;

  1041         }

  1042     }

  1043 

  1044 // ------------------------------------------------------------------------------

  1045 // CFileManagerEngine::CurrentIndex

  1046 //

  1047 // ------------------------------------------------------------------------------

  1048 //

  1049 EXPORT_C TInt CFileManagerEngine::CurrentIndex()

  1050     {

  1051     if ( iCurrentItemName.Length() )

  1052         {

  1053         TInt count( iNavigator->MdcaCount() );

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

  1055             {

  1056             CGflmGroupItem* item = iNavigator->Item( i );

  1057             if ( !item->Name().CompareF( iCurrentItemName ) )

  1058                 {

  1059                 iCurrentItemName.Zero();

  1060                 return i;

  1061                 }

  1062             }

  1063         iCurrentItemName.Zero();

  1064         }

  1065 

  1066     // Top navigation index

  1067     TInt pos( iNavigationIndices.Count() - 1 );

  1068     if ( pos >= 0 )

  1069         {

  1070         return iNavigationIndices[ pos ];

  1071         }

  1072     return KErrNotFound;

  1073     }

  1074 

  1075 // ------------------------------------------------------------------------------

  1076 // CFileManagerEngine::CanDelete

  1077 //

  1078 // ------------------------------------------------------------------------------

  1079 //

  1080 TBool CFileManagerEngine::CanDelete( const TDesC& aFileName ) const

  1081     {

  1082     return iUtils->CanDelete( aFileName );

  1083     }

  1084 

  1085 // ------------------------------------------------------------------------------

  1086 // CFileManagerEngine::LocalizedName

  1087 //

  1088 // ------------------------------------------------------------------------------

  1089 //

  1090 EXPORT_C TPtrC CFileManagerEngine::LocalizedName(

  1091         const TDesC& aFullPath ) const

  1092     {

  1093     return iUtils->LocalizedName( aFullPath );

  1094     }

  1095 

  1096 // ------------------------------------------------------------------------------

  1097 // CFileManagerEngine::FilesInFolderL

  1098 //

  1099 // ------------------------------------------------------------------------------

  1100 //

  1101 EXPORT_C TInt CFileManagerEngine::FilesInFolderL()

  1102     {

  1103     TInt ret( 0 );

  1104     switch ( iState )

  1105         {

  1106         case ENavigation: // Fall through

  1107         case ESearch:

  1108             {

  1109             TInt count( iNavigator->MdcaCount() );

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

  1111                 {

  1112                 CGflmGroupItem* item = iNavigator->Item( i );

  1113                 if ( item->Type() == CGflmGroupItem::EFile )

  1114                     {

  1115                     ++ret;

  1116                     }

  1117                 }

  1118             break;

  1119             }

  1120         default:

  1121             {

  1122             break;

  1123             }

  1124         }

  1125     return ret;

  1126     }

  1127 

  1128 // ------------------------------------------------------------------------------

  1129 // CFileManagerEngine::CancelRefresh

  1130 //

  1131 // ------------------------------------------------------------------------------

  1132 //

  1133 EXPORT_C TBool CFileManagerEngine::CancelRefresh()

  1134     {