filemanager/Engine/src/CFileManagerEngine.cpp
changeset 14 1957042d8c7e
parent 1 d1daf54a55b5
child 16 ada7962b4308
--- a/filemanager/Engine/src/CFileManagerEngine.cpp	Tue Feb 02 00:03:31 2010 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2221 +0,0 @@
-/*
-* Copyright (c) 2002-2008 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:  Main class of the filemanagerengine
-*
-*/
-
-
-
-// INCLUDE FILES
-#include <StringLoader.h>
-#include <barsread.h>
-#include <sysutil.h>
-#include <bautils.h>
-//#include <cmgxfilemanager.h>
-//#include <mgxfilemanagerfactory.h>
-//#include <cmgalbummanager.h>
-#include <pathinfo.h>
-#include <AknServerApp.h>
-#include <FileManagerEngine.rsg>
-#ifdef RD_MULTIPLE_DRIVE
-#include <driveinfo.h>
-#endif // RD_MULTIPLE_DRIVE
-#include "CFileManagerEngine.h"
-#include "CGflmNavigatorModel.h"
-#include "CGflmGroupItem.h"
-#include "CGflmFileSystemItem.h"
-#include "CGflmDriveItem.h"
-#include "CGflmGlobalActionItem.h"
-#include "MGflmItemGroup.h"
-#include "Cfilemanagerfolderarray.h"
-#include "CFilemanagerMimeIconArray.h"
-#include "CFileManagerActiveExecute.h"
-#include "CFileManagerRefresher.h"
-#include "Cfilemanagerfilesystemevent.h"
-#include "Cfilemanageractivesize.h"
-#include "Cfilemanageractivedelete.h"
-#include "FileManagerEngine.hrh"
-#include "CFileManagerCommonDefinitions.h"
-#include "CFileManagerUtils.h"
-#include "CFileManagerItemFilter.h"
-#include "CFileManagerDocHandler.h"
-#include "FileManagerDebug.h"
-#include "CFileManagerItemProperties.h"
-#include "CFileManagerRemovableDriveHandler.h"
-#include "CFileManagerRemoteDriveHandler.h"
-#include "CFileManagerBackupSettings.h"
-#include "CFileManagerRestoreSettings.h"
-#include "CFileManagerActiveRename.h"
-#include "CFileManagerFeatureManager.h"
-
-// CONSTANTS
-const TUint16 KIllegalChars[] = {
-    '<', '>', '"', '/', '\\', '|', ':', '*', '?',
-    0xFF02, // Full width quote
-    0xFF0A, // Full width asterisk
-    0xFF0F, // Full width slash
-    0xFF1A, // Full width colon
-    0xFF1C, // Full width left arrow
-    0xFF1E, // Full width right arrow
-    0xFF1F, // Full width question mark
-    0xFF3C, // Full width back slash
-    0xFF5C, // Full width pipe
-    0x201C, // Left quote
-    0x201D, // Right quote
-    0x201F, // Reversed quote
-    0x21B2, // Downwards arrow with tip leftwards
-    0, // Array terminator
-};
-
-//const TInt KMGFileArrayGranularity = 32;
-
-
-// ============================ LOCAL FUNCTIONS ================================
-// -----------------------------------------------------------------------------
-// SearchMGAlbumIdL
-// -----------------------------------------------------------------------------
-//
-/*static TInt SearchMGAlbumIdL(
-        CMGAlbumManager& aAlbumManager, const TDesC& aFilename )
-    {
-    CDesCArray* fileArray =
-        new ( ELeave ) CDesCArraySeg( KMGFileArrayGranularity );
-    CleanupStack::PushL( fileArray );
-    TInt albumCount( aAlbumManager.AlbumCount() );
-    TInt ret( KErrNotFound );
-    for( TInt i( 0 ); i < albumCount; ++i )
-        {
-        CMGAlbumInfo* albumInfo = aAlbumManager.AlbumInfoLC( i );
-        TInt albumId( albumInfo->Id() );
-        CleanupStack::PopAndDestroy( albumInfo );
-        fileArray->Reset();
-        aAlbumManager.GetAlbumFileArrayL( albumId, *fileArray );
-        TInt pos( 0 );
-        if( !fileArray->Find( aFilename, pos ) )
-            {
-            ret = albumId;
-            break;
-            }
-        }
-    CleanupStack::PopAndDestroy( fileArray );
-    return ret;
-    }
-*/
-
-// ============================ MEMBER FUNCTIONS ===============================
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::CFileManagerEngine
-// C++ default constructor can NOT contain any code, that
-// might leave.
-// -----------------------------------------------------------------------------
-//
-CFileManagerEngine::CFileManagerEngine( RFs& aFs ) :
-		iFs( aFs ), iObserver( NULL ), iSisFile( EFalse )
-    {
-    FUNC_LOG
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::NewL
-// Two-phased constructor.
-// -----------------------------------------------------------------------------
-//
-EXPORT_C CFileManagerEngine* CFileManagerEngine::NewL( RFs& aFs )
-    {
-    CFileManagerEngine* self = new ( ELeave ) CFileManagerEngine( aFs );
-
-    CleanupStack::PushL( self );
-    self->ConstructL();
-    CleanupStack::Pop( self );
-
-    return self;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::ConstructL
-// -----------------------------------------------------------------------------
-//
-void CFileManagerEngine::ConstructL()
-    {
-    FUNC_LOG
-
-    INFO_LOG( "CFileManagerEngine::ConstructL()-Create Feature Manager" )
-    iFeatureManager = CFileManagerFeatureManager::NewL();
-
-    iState = ENavigation;
-
-    INFO_LOG( "CFileManagerEngine::ConstructL()-Create navigator" )
-    iNavigator = CGflmNavigatorModel::NewL( iFs );
-
-    // Create drives group
-    MGflmItemGroup* newGroup = iNavigator->CreateGroupL(
-        EFileManagerDrivesGroup, EDrives );
-#ifdef RD_FILE_MANAGER_BACKUP
-    // Set backup action
-    HBufC* actionCaption = StringLoader::LoadLC( R_QTN_FMGR_MAIN_BACKUP );
-    newGroup->AddActionItemL( EFileManagerBackupAction, *actionCaption );
-    CleanupStack::PopAndDestroy( actionCaption );
-#endif // RD_FILE_MANAGER_BACKUP
-
-    // Create files and folders groups
-    iNavigator->CreateGroupL( EFileManagerFilesGroup, EDirectories | EFiles );
-
-    INFO_LOG( "CFileManagerEngine::ConstructL()-Create refresher" )
-    iRefresher = CFileManagerRefresher::NewL( *iNavigator );
-
-    INFO_LOG( "CFileManagerEngine::ConstructL()-Create utils" )
-    iUtils = CFileManagerUtils::NewL( iFs, *iNavigator, *iFeatureManager );
-
-    INFO_LOG( "CFileManagerEngine::ConstructL()-Create disk event" )
-    iDiskEvent = CFileManagerFileSystemEvent::NewL( iFs, *this, ENotifyDisk );
-
-    INFO_LOG( "CFileManagerEngine::ConstructL()-Create removable drive handler" )
-    iRemovableDrvHandler = CFileManagerRemovableDriveHandler::NewL(
-        iFs, *iUtils, *this );
-    INFO_LOG( "CFileManagerEngine::ConstructL()-Create remote drive handler" )
-    iRemoteDrvHandler = CFileManagerRemoteDriveHandler::NewL(
-        *this, *iUtils );
-
-    INFO_LOG( "CFileManagerEngine::ConstructL()-Create item filter" )
-    iItemFilter = CFileManagerItemFilter::NewL( *this );
-    iNavigator->SetCustomFilter( iItemFilter );
-
-    // Store new starting index
-    iNavigationIndices.AppendL( KErrNotFound );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::~CFileManagerEngine
-// Destructor
-// -----------------------------------------------------------------------------
-// 
-EXPORT_C CFileManagerEngine::~CFileManagerEngine()
-    {
-    delete iActiveRename;
-    iNavigationIndices.Reset();
-    delete iRemoteDrvHandler;
-    delete iBackupSettings;
-    delete iRestoreSettings;
-    delete iRemovableDrvHandler;
-    delete iDocHandler;
-    //delete iMgxFileManager;
-    delete iFileSystemEvent;
-    delete iRefresher;
-    delete iNavigator;
-    delete iItemFilter;
-    delete iSearchString;
-    delete iSearchFolder;
-    delete iActiveSize;
-    delete iDiskEvent;
-    delete iUtils;
-    delete iDriveName;
-    delete iFeatureManager;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetFileSystemEventL
-// -----------------------------------------------------------------------------
-//
-void CFileManagerEngine::SetFileSystemEventL( const TDesC& aFullPath )
-    {
-    delete iFileSystemEvent;
-    iFileSystemEvent = NULL;
-    if ( aFullPath != KNullDesC )
-        {
-        iFileSystemEvent = CFileManagerFileSystemEvent::NewL(
-            iFs, *this, ENotifyEntry, aFullPath );
-        }
-    else
-        {
-        iFileSystemEvent = CFileManagerFileSystemEvent::NewL(
-            iFs, *this, ENotifyEntry );
-        }
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::IndexToFullPathL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C HBufC* CFileManagerEngine::IndexToFullPathL(
-        const TInt aIndex ) const
-    {
-    if ( aIndex < 0 || aIndex >= iNavigator->MdcaCount() )
-        {
-        User::Leave( KErrNotFound );
-        }
-    CGflmGroupItem* item = iNavigator->Item( aIndex );
-    HBufC* fullPath = NULL;
-    switch ( item->Type() )
-        {
-        case CGflmGroupItem::EFile: // Fall through
-        case CGflmGroupItem::EDirectory:
-            {
-            CGflmFileSystemItem* fsItem =
-                static_cast< CGflmFileSystemItem* >( item );
-            fullPath = fsItem->FullPathL();
-            break;
-            }
-        case CGflmGroupItem::EDrive:
-            {
-            CGflmDriveItem* drvItem =
-                static_cast< CGflmDriveItem* >( item );
-            fullPath = drvItem->RootDirectory().AllocL();
-            break;
-            }
-        default:
-            {
-            User::Leave( KErrNotFound );
-            break;
-            }
-        }
-    return fullPath;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::IndexToFullPathLC
-// -----------------------------------------------------------------------------
-//
-EXPORT_C HBufC* CFileManagerEngine::IndexToFullPathLC(
-        const TInt aIndex ) const
-    {
-    HBufC* fullPath = IndexToFullPathL( aIndex );
-    CleanupStack::PushL( fullPath );
-    return fullPath;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::AddFullPathLC
-// -----------------------------------------------------------------------------
-//
-HBufC* CFileManagerEngine::AddFullPathLC(
-        const TDesC& aName, const TBool aIsFolder )
-    {
-    TPtrC dir( iNavigator->CurrentDirectory() );
-    TInt len( dir.Length() + aName.Length() );
-    if ( aIsFolder )
-        {
-        ++len; // Ensure space for backslash
-        }
-    HBufC* fullPath = HBufC::NewLC( len );
-    TPtr ptr( fullPath->Des() );
-    ptr.Append( dir );
-    ptr.Append( aName );
-    if ( aIsFolder )
-        {
-        CFileManagerUtils::EnsureFinalBackslash( ptr );
-        }
-    return fullPath;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetMemoryL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::SetMemoryL( TFileManagerMemory /*aMemory*/ )
-    {
-    // Just check current drive avaibility, no matter what memory is set
-    iLastDriveAvailable = CurrentDriveAvailable();
-    return KErrNone;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::Memory
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TFileManagerMemory CFileManagerEngine::Memory() const
-    {
-#ifdef RD_MULTIPLE_DRIVE
-    CGflmDriveItem* drvItem = iNavigator->CurrentDrive();
-    if ( drvItem )
-        {
-        TUint driveStatus( drvItem->DriveStatus() );
-        if ( driveStatus & DriveInfo::EDriveInternal )
-            {
-            if ( driveStatus & DriveInfo::EDriveExternallyMountable )
-                {
-                return EFmMassStorage;
-                }
-            return EFmPhoneMemory;
-            }
-        else if ( driveStatus & DriveInfo::EDriveUsbMemory )
-            {
-            return EFmUsbMemory;
-            }
-        else if ( driveStatus & DriveInfo::EDriveRemovable )
-            {
-            return EFmMemoryCard;
-            }
-        else if ( driveStatus & DriveInfo::EDriveRemote )
-            {
-            return EFmRemoteDrive;
-            }
-        }
-    return EFmPhoneMemory;
-#else // RD_MULTIPLE_DRIVE
-    CGflmDriveItem* drvItem = iNavigator->CurrentDrive();
-    if ( drvItem )
-        {
-        const TVolumeInfo vol( drvItem->VolumeInfo() );
-        if ( vol.iDrive.iDriveAtt & KDriveAttInternal )
-            {
-            return EFmPhoneMemory;
-            }
-        else if ( vol.iDrive.iDriveAtt & KDriveAttRemovable )
-            {
-            return EFmMemoryCard;
-            }
-        else if ( vol.iDrive.iDriveAtt & KDriveAttRemote )
-            {
-            return EFmRemoteDrive;
-            }
-        }
-    return EFmPhoneMemory;
-#endif // RD_MULTIPLE_DRIVE
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::FileList
-// -----------------------------------------------------------------------------
-//
-EXPORT_C MDesCArray* CFileManagerEngine::FileList() const
-    {
-    return iNavigator;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::OpenL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::OpenL( const TInt aIndex )
-    {
-    // Store drive letter for current drive changed checking
-    TChar prevDrive( 0 );
-    TPtrC prevDir( iNavigator->CurrentDirectory() );
-    if ( prevDir.Length() )
-        {
-        prevDrive = prevDir[ 0 ];
-        }   
-
-    if ( aIndex < 0 || aIndex >= iNavigator->MdcaCount() )
-        {
-        User::Leave( KErrNotFound );
-        }
-    CGflmGroupItem* item = iNavigator->Item( aIndex );
-    switch ( item->Type() )
-        {
-        case CGflmGroupItem::EFile: // Fall through
-        case CGflmGroupItem::EDirectory: // Fall through
-        case CGflmGroupItem::EDrive:
-            {
-
-#ifdef RD_MULTIPLE_DRIVE
-            // Ensure that default folders exist
-            if ( item->Type() == CGflmGroupItem::EDrive )
-                {
-                CGflmDriveItem* drvItem =
-                    static_cast< CGflmDriveItem* >( item );
-                iUtils->CreateDefaultFolders(
-                    drvItem->Drive(), EFalse );
-                }
-#endif // RD_MULTIPLE_DRIVE
-
-            // Store navigation position
-            SetCurrentIndex( aIndex );
-
-            HBufC* fullPath = IndexToFullPathLC( aIndex );
-            if ( item->Type() == CGflmGroupItem::EFile )
-                {
-                OpenFileL( *fullPath );
-                }
-            else
-                {
-                OpenDirectoryL( *fullPath );
-
-                // Setup new navigation position
-                iNavigationIndices.AppendL( 0 );
-                }
-            CleanupStack::PopAndDestroy( fullPath );
-            break;
-            }
-        case CGflmGroupItem::EGlobalActionItem:
-            {
-            CGflmGlobalActionItem* actItem = 
-                static_cast< CGflmGlobalActionItem* >( item );
-            if ( iProcessObserver )
-                {
-                iProcessObserver->NotifyL(
-                    MFileManagerProcessObserver::ENotifyActionSelected,
-                    actItem->Id() );
-                }
-            break;
-            }
-        default:
-            {
-            break;
-            }
-        }
- 
-    // Ensure that cached current drive info gets updated if drive was changed
-    TPtrC dir( iNavigator->CurrentDirectory() );
-    if ( dir.Length() )
-        {
-        if ( dir[ 0 ] != prevDrive )
-            {
-            iCurrentDriveInfoRefreshed = EFalse;
-            }
-        }
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetObserver
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::SetObserver(
-        MFileManagerProcessObserver* aObserver )
-    {
-    iProcessObserver = aObserver;
-    iRefresher->SetObserver( aObserver );
-    iRemovableDrvHandler->SetObserver( aObserver );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::CurrentDirectory
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TPtrC CFileManagerEngine::CurrentDirectory() const
-    {
-    return iNavigator->CurrentDirectory();
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::CurrentDirectory
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TPtrC CFileManagerEngine::LocalizedNameOfCurrentDirectory() const
-    {
-    return iNavigator->LocalizedNameOfCurrentDirectory();
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::BackstepL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::BackstepL()
-    {
-    // Store drive letter for current drive changed checking
-    TChar prevDrive( 0 );
-    // Note that prevDir gets invalid after BackstepL
-    TPtrC prevDir( iNavigator->CurrentDirectory() );
-    if ( prevDir.Length() )
-        {
-        prevDrive = prevDir[ 0 ];
-        }
-
-    // Setup backstep navigation index
-    if ( !iNavigator->NavigationLevel() )
-        {
-        // Always first for initial root level
-        iCurrentItemName.Zero();
-        }
-    else if( !iCurrentItemName.Length() )
-        {
-        // Otherwise previously opened folder
-        iCurrentItemName.Copy(
-            iNavigator->LocalizedNameOfCurrentDirectory() );
-        }
-    TInt pos( iNavigationIndices.Count() - 1 );
-    if ( pos >= 0 )
-        {
-        iNavigationIndices.Remove( pos );
-        }
-
-    iNavigator->BackstepL();
-
-    // Ensure that cached current drive info gets updated if drive was changed
-    TPtrC dir( iNavigator->CurrentDirectory() );
-    if ( dir.Length() )
-        {
-        if ( dir[ 0 ] != prevDrive )
-            {
-            iCurrentDriveInfoRefreshed = EFalse;
-            }
-        }
-    else
-        {
-        // Make sure that drive info is refreshed
-        ClearDriveInfo();
-        }
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::FileTypeL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TUint32 CFileManagerEngine::FileTypeL( const TInt aIndex ) const
-    {
-    TUint32 fileType( CFileManagerItemProperties::ENotDefined );
-    if ( aIndex >= 0 )
-        {
-        HBufC* fullPath = IndexToFullPathLC( aIndex );
-        fileType = FileTypeL( *fullPath );
-        CleanupStack::PopAndDestroy( fullPath ); 
-        }
-    return fileType;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::FileTypeL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TUint32 CFileManagerEngine::FileTypeL( const TDesC& aFullPath ) const
-    {
-    return iUtils->FileTypeL( aFullPath );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::DeleteL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C CFileManagerActiveDelete* CFileManagerEngine::CreateActiveDeleteL( 
-                                              CArrayFixFlat< TInt >& aIndexList )
-    {
-
-    CFileManagerActiveDelete* activeDelete = 
-        CFileManagerActiveDelete::NewL( aIndexList, *this, *iUtils );
-    return activeDelete;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::NewFolder
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::NewFolderL( const TDesC& aFolderName )
-    {   
-    // Add backslash to end so that MkDir realizes that it is directory
-    HBufC* fullPath = AddFullPathLC( aFolderName, ETrue );
-    TPtr ptr( fullPath->Des() );
-
-    if ( ptr.Length() <= KMaxFileName )
-        {
-        iCurrentItemName.Copy( aFolderName );
-
-        // Remove white spaces from end, file server also ignores those
-        iCurrentItemName.TrimRight();
-
-        User::LeaveIfError( iFs.MkDir( ptr ) );
-        }
-    else
-        {
-        User::Leave( KErrBadName );
-        }
-
-    CleanupStack::PopAndDestroy( fullPath ); 
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetCurrentItemName
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::SetCurrentItemName( const TDesC& aFileName )
-    { 
-
-    iCurrentItemName.Copy( aFileName );
-
-    // Remove white spaces from end, file server also ignores those
-    iCurrentItemName.TrimRight();
-
-    }
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::RenameL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::RenameL(
-        const TInt aIndex,
-        const TDesC& aNewFileName )
-    {
-    FUNC_LOG
-
-    // Make those given names as full paths
-    TBool isFolder( IsFolder( aIndex ) );
-    HBufC* fullPathOld = IndexToFullPathLC( aIndex );
-    HBufC* fullPathNew = AddFullPathLC( aNewFileName, isFolder );
-
-    if ( !fullPathOld->Compare( *fullPathNew ) )
-        {
-        // The name has not changed, rename is not required
-        CleanupStack::PopAndDestroy( fullPathNew );
-        CleanupStack::PopAndDestroy( fullPathOld );
-        return;
-        }
-
-    // Gallery notification is relevant only for local drives
-    TBool isRemoteDrive( iUtils->IsRemoteDrive( *fullPathOld ) );
-
-    // Media Gallery albums get easily messed up when files are renamed.
-    // Direct album editing seems a trick but it is seems to only way 
-    // to update Gallery properly.
-    /*CMGAlbumManager* albumManager = MGAlbumManagerFactory::NewAlbumManagerL();
-    CleanupStack:: PushL( albumManager );
-    TInt albumId( KErrNotFound );
-    if ( !isFolder && !isRemoteDrive )
-        {
-        // Do album search for files only
-        TRAPD( err, albumId = SearchMGAlbumIdL( *albumManager, *fullPathOld ) );
-        if( err != KErrNone )
-            {
-            albumId = KErrNotFound;
-            }
-        }
-*/
-    // Handle rename
-    delete iActiveRename;
-    iActiveRename = NULL;
-    iActiveRename = CFileManagerActiveRename::NewL(
-        *this, *iUtils, *fullPathOld, *fullPathNew );
-    ShowWaitDialogL( *iActiveRename );
-    User::LeaveIfError( iActiveRename->Result() );
-
-    // Update Media Gallery album if file exist in album
-    /*if( albumId != KErrNotFound )
-        {
-        TRAP_IGNORE( { albumManager->RemoveFromAlbumL( *fullPathOld, albumId );
-            albumManager->AddToAlbumL( *fullPathNew, albumId ); } );
-        }
-    CleanupStack::PopAndDestroy( albumManager );*/
-
-    iCurrentItemName.Copy( aNewFileName );
-
-    /*if ( !isRemoteDrive )
-        {
-        // Notify Media Gallery again
-        TRAP_IGNORE( MGXFileManagerL().UpdateL( *fullPathOld, *fullPathNew ) );
-        }*/
-
-    CleanupStack::PopAndDestroy( fullPathNew );
-    CleanupStack::PopAndDestroy( fullPathOld );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::FolderLevel
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::FolderLevel()
-    {
-    CGflmDriveItem* drvItem = iNavigator->CurrentDrive();
-    if ( !drvItem )
-        {
-        return KErrNotFound;  // Main level
-        }
-    TPtrC dir( iNavigator->CurrentDirectory() );
-    TInt count( dir.Length() );
-    if ( !count )
-        {
-        return KErrNotFound; // Main level
-        }
-    // Count how many backslashes is in string to figure out the deepness
-    TInt min( drvItem->RootDirectory().Length() );
-	TInt bsCount( 0 );
-	while( count > min )
-		{
-        --count;
-		if ( dir[ count ] == KFmgrBackslash()[ 0 ] )
-			{
-			++bsCount;
-			}
-		}
-	return bsCount;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::IsNameFoundL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TBool CFileManagerEngine::IsNameFoundL( const TDesC& aName )
-    {
-    return iUtils->IsNameFoundL( aName );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::CurrentDrive
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::CurrentDrive()
-    {
-    TInt ret( KErrNotFound );
-    TPtrC ptr( iNavigator->CurrentDirectory() );
-    if ( ptr.Length() )
-        {
-        if( RFs::CharToDrive( ptr[ 0 ], ret ) != KErrNone )
-            {
-            ret = KErrNotFound;
-            }
-        }
-    return ret;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::GetItemInfoL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C CFileManagerItemProperties* CFileManagerEngine::GetItemInfoL( 
-                                                const TInt aIndex )
-    {
-    if ( aIndex < 0 || aIndex >= iNavigator->MdcaCount() )
-        {
-        User::Leave( KErrNotFound );
-        }
-    CGflmGroupItem* item = iNavigator->Item( aIndex );
-    return CFileManagerItemProperties::NewL( *item, *iUtils, *this );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetState
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::SetState( TState aState )
-    {
-    iState = aState;
-    iNavigator->EnableSearchMode( iState == ESearch );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetState
-// -----------------------------------------------------------------------------
-//
-EXPORT_C CFileManagerEngine::TState CFileManagerEngine::State() const
-    {
-    return iState;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::RefreshDirectory
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::RefreshDirectory()
-    {
-    FUNC_LOG
-
-#ifdef FILE_MANAGER_INFO_LOG_ENABLED
-    if ( iState == ENavigation )
-        {
-        TPtrC dir( iNavigator->CurrentDirectory() );
-        INFO_LOG1( "CFileManagerEngine::RefreshDirectory-dir=%S", &dir );
-        }
-#endif // FILE_MANAGER_INFO_LOG_ENABLED
-
-    iRefresher->Refresh();
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::GetMMCInfoL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TFileManagerDriveInfo CFileManagerEngine::GetMMCInfoL() const
-    {
-    TFileManagerDriveInfo drvInfo;
-    GetDriveInfoL(
-        PathInfo::MemoryCardRootPath(), drvInfo );
-    return drvInfo;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SearchString
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TPtrC CFileManagerEngine::SearchString() const
-    {
-    if ( iSearchString )
-        {
-        return iSearchString->Des();
-        }
-    return TPtrC( KNullDesC );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::IsValidName
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TBool CFileManagerEngine::IsValidName(
-        const TDesC& aDriveAndPath, const TDesC& aName, TBool aIsFolder ) const
-    {
-    // Check name for bad chars
-    const TUint16 KMinAllowedChar = 0x0020;
-    const TUint16 KParagraphSeparator = 0x2029;
-    const TUint16 KDot = '.';
-    TInt nameLen( aName.Length() );
-    if ( !nameLen )
-        {
-        return EFalse;
-        }
-    for ( TInt i( 0 ); i < nameLen; i++ )
-        {
-        TUint16 ch( aName[ i ] );
-        if ( ch < KMinAllowedChar || ch == KParagraphSeparator )
-            {
-            return EFalse;
-            }
-        }
-    // File system ignores totally dot in the end of name, so 
-    // we set here as not valid name, so that user gets correctly informed
-    if ( aName[ nameLen - 1 ] == KDot || IllegalChars( aName ) )
-        {
-        return EFalse;
-        }
-    // Get full path length
-    TPtrC pathPtr( aDriveAndPath.Length() ?
-        TPtrC( aDriveAndPath ) : TPtrC( iNavigator->CurrentDirectory() ) );
-    TInt pathLen( pathPtr.Length() );
-    if ( !pathLen )
-        {
-        return EFalse;
-        }
-    TInt fullPathLen( pathLen );
-    if ( !CFileManagerUtils::HasFinalBackslash( pathPtr ) )
-        {
-        ++fullPathLen; // Add backslash before name
-        }
-    fullPathLen += nameLen;
-    if ( aIsFolder )
-        {
-        ++fullPathLen; // Add folder final backslash
-        }
-
-    TBool ret( EFalse );
-    if ( fullPathLen <= KMaxFileName )
-        {
-        // Check full path
-        HBufC* fullPath = HBufC::New( KMaxFileName );
-        if ( fullPath )
-            {
-            TPtr ptr( fullPath->Des() );
-            ptr.Copy( pathPtr );
-            CFileManagerUtils::EnsureFinalBackslash( ptr ); // Add backslash before name
-            ptr.Append( aName );
-            ret = iFs.IsValidName( ptr );
-            delete fullPath;
-            }
-        }
-    return ret;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::IllegalChars
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TBool CFileManagerEngine::IllegalChars( const TDesC& aName ) const
-    {
-    for ( TInt i( 0 ); KIllegalChars[ i ]; i++ )
-        {
-        if ( aName.Locate( KIllegalChars[ i ] ) != KErrNotFound )
-            {
-            return ETrue;
-            }
-        }
-    return EFalse;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::EnoughSpaceL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TBool CFileManagerEngine::EnoughSpaceL(
-        const TDesC& aToFolder, 
-        TInt64 aSize, 
-        MFileManagerProcessObserver::TFileManagerProcess aOperation ) const
-    {
-    TPtrC src( iNavigator->CurrentDirectory() );
-    TInt srcDrv( KErrNotFound );
-    if ( src.Length() )
-        {
-        User::LeaveIfError( RFs::CharToDrive( src[ 0 ], srcDrv ) );
-        }
-    TInt dstDrv( KErrNotFound );
-    if ( aToFolder.Length() )
-        {
-        User::LeaveIfError( RFs::CharToDrive( aToFolder[ 0 ], dstDrv ) );
-        }
-    else
-        {
-        return ETrue; // Invalid destination
-        }
-
-    TBool ret( EFalse );
-
-    // if operation is move and drive is same so there is always enough memory
-    if ( srcDrv == dstDrv &&
-        aOperation == MFileManagerProcessObserver::EMoveProcess )
-        {
-        ret = ETrue;
-        }
-    else
-        {
-        ret = !SysUtil::DiskSpaceBelowCriticalLevelL(
-            &iFs,  aSize , dstDrv );
-        }
-
-    return ret;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::FileSystemEvent
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::FileSystemEvent( TBool aEventOn )
-    {
-    INFO_LOG2(
-        "CFileManagerEngine::FileSystemEvent-aEventOn=%d,iFileSystemEventEnabled=%d",
-        aEventOn, iFileSystemEventEnabled )
-
-    INFO_LOG2(
-        "CFileManagerEngine::FileSystemEvent-iDriveAddedOrChangedPostponed=%d,iEmbeddedApplicationOn=%d ",
-        iDriveAddedOrChangedPostponed, iEmbeddedApplicationOn )
-
-    if ( !iFileSystemEventEnabled && aEventOn )
-        {
-        iDriveAddedOrChangedPostponed = EFalse;
-        iFileSystemEventEnabled = ETrue;
-        }
-    else if ( iFileSystemEventEnabled && !aEventOn )
-        {
-        iFileSystemEventEnabled = EFalse;
-        if ( iDriveAddedOrChangedPostponed )
-            {
-            iDriveAddedOrChangedPostponed = EFalse;
-            TRAP_IGNORE( DriveAddedOrChangedL() );
-            }
-        }
-
-    if ( iUtils->IsRemoteDrive( iNavigator->CurrentDirectory() ) )
-        {
-         // At the moment no use to have event for remote drives
-        delete iFileSystemEvent;
-        iFileSystemEvent = NULL;
-        return;
-        }
-
-    // Set event on when there is no embedded app with event
-    if ( aEventOn &&
-         !( iEmbeddedApplicationOn && iFileSystemEvent ) )
-        {
-        TInt err( KErrNone );
-        switch ( iState )
-            {
-            case ENavigation:
-                {
-                TRAP( err, SetFileSystemEventL( iNavigator->CurrentDirectory() ) );
-                break;
-                }
-            case ESearch:
-                {
-                TRAP( err, SetFileSystemEventL() );
-                break;
-                }
-            default:
-                {
-                break;
-                }
-            }
-        if ( err != KErrNone && iProcessObserver )
-            {
-            iProcessObserver->Error( err );
-            }
-        }
-    // Check event and set it off when there is no embedded app
-    else if( !iEmbeddedApplicationOn && iFileSystemEvent )
-        {
-        iFileSystemEvent->CheckFileSystemEvent();
-        delete iFileSystemEvent;
-        iFileSystemEvent = NULL;
-        }
-    }
-
-// ------------------------------------------------------------------------------
-// CFileManagerEngine::CurrentIndex
-//
-// ------------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::CurrentIndex()
-    {
-    if ( iCurrentItemName.Length() )
-        {
-        TInt count( iNavigator->MdcaCount() );
-        for( TInt i( 0 ); i < count; ++i )
-            {
-            CGflmGroupItem* item = iNavigator->Item( i );
-            if ( !item->Name().CompareF( iCurrentItemName ) )
-                {
-                iCurrentItemName.Zero();
-                return i;
-                }
-            }
-        iCurrentItemName.Zero();
-        }
-
-    // Top navigation index
-    TInt pos( iNavigationIndices.Count() - 1 );
-    if ( pos >= 0 )
-        {
-        return iNavigationIndices[ pos ];
-        }
-    return KErrNotFound;
-    }
-
-// ------------------------------------------------------------------------------
-// CFileManagerEngine::CanDelete
-//
-// ------------------------------------------------------------------------------
-//
-TBool CFileManagerEngine::CanDelete( const TDesC& aFileName ) const
-    {
-    return iUtils->CanDelete( aFileName );
-    }
-
-// ------------------------------------------------------------------------------
-// CFileManagerEngine::LocalizedName
-//
-// ------------------------------------------------------------------------------
-//
-EXPORT_C TPtrC CFileManagerEngine::LocalizedName(
-        const TDesC& aFullPath ) const
-    {
-    return iUtils->LocalizedName( aFullPath );
-    }
-
-// ------------------------------------------------------------------------------
-// CFileManagerEngine::FilesInFolderL
-//
-// ------------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::FilesInFolderL()
-    {
-    TInt ret( 0 );
-    switch ( iState )
-        {
-        case ENavigation: // Fall through
-        case ESearch:
-            {
-            TInt count( iNavigator->MdcaCount() );
-            for( TInt i( 0 ); i < count; ++i )
-                {
-                CGflmGroupItem* item = iNavigator->Item( i );
-                if ( item->Type() == CGflmGroupItem::EFile )
-                    {
-                    ++ret;
-                    }
-                }
-            break;
-            }
-        default:
-            {
-            break;
-            }
-        }
-    return ret;
-    }
-
-// ------------------------------------------------------------------------------
-// CFileManagerEngine::CancelRefresh
-//
-// ------------------------------------------------------------------------------
-//
-EXPORT_C TBool CFileManagerEngine::CancelRefresh()
-    {
-    switch ( iState )
-        {
-        case ENavigation:
-            {
-            CancelTransfer( iNavigator->CurrentDirectory() );
-            break;
-            }
-        case ESearch:
-            {
-            if ( iSearchFolder )
-                {
-                CancelTransfer( *iSearchFolder );
-                }
-            break;
-            }
-        default:
-            {
-            break;
-            }
-        }
-    return iRefresher->CancelRefresh();
-    }
-
-// ------------------------------------------------------------------------------
-// CFileManagerEngine::DriveAddedOrChangedL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerEngine::DriveAddedOrChangedL()
-    {
-    FUNC_LOG
-    
-    if( iDiskEvent )
-        {
-        iDiskEvent->Setup();
-        }
-        
-    TBool processOngoing( iRemovableDrvHandler->IsProcessOngoing() );
-
-    INFO_LOG3( "CFileManagerEngine::DriveAddedOrChangedL-event=%d,process=%d,postponed=%d ",
-        iFileSystemEventEnabled, processOngoing, iDriveAddedOrChangedPostponed )
-
-    if ( iFileSystemEventEnabled || processOngoing )
-        {
-        iDriveAddedOrChangedPostponed = ETrue;
-        }
-    else
-        {
-        iDriveAddedOrChangedPostponed = EFalse;
-        ClearDriveInfo();
-        if ( iProcessObserver &&
-             !iEmbeddedApplicationOn &&
-             !iWaitDialogOn &&
-             !iRefresher->IsActive() )
-            {
-            TPtrC dir( iNavigator->CurrentDirectory() );
-            if ( dir.Length() )
-                {
-                TBool isAvailable( CurrentDriveAvailable() );
-
-                if ( iUtils->IsRemoteDrive( dir ) )
-                    {
-                    // Notify whether remote drive has become available
-                    // So when receiving remote drive connection event,
-                    // View will be refreshed
-                    //if ( !iLastDriveAvailable && isAvailable )
-                    //    {
-                        iProcessObserver->NotifyL(
-                            MFileManagerProcessObserver::ENotifyDisksChanged, 0 );
-                    //    }
-                    }
-                else
-                    {
-                    // Notify if drive has become unavailable or
-                    // avaibility has changed
-                    if ( !isAvailable ||
-                        isAvailable != iLastDriveAvailable )
-                        {
-                        iProcessObserver->NotifyL(
-                            MFileManagerProcessObserver::ENotifyDisksChanged, 0 );
-                        }
-                    }
-                }
-            else
-                {
-                // Notify always when no folder is opened
-                iProcessObserver->NotifyL(
-                    MFileManagerProcessObserver::ENotifyDisksChanged, 0 );
-                }
-            }
-        }
-    }
-
-// ------------------------------------------------------------------------------
-// CFileManagerEngine::FolderContentChangedL
-//
-// ------------------------------------------------------------------------------
-//
-void CFileManagerEngine::FolderContentChangedL()
-    {
-    if( iProcessObserver )
-        {
-        iProcessObserver->NotifyL(
-            MFileManagerProcessObserver::ENotifyDisksChanged, 0 );
-        }
-    else
-        {
-        RefreshDirectory();
-        }
-    }
-
-// ------------------------------------------------------------------------------
-// CFileManagerEngine::IsFolder
-//
-// ------------------------------------------------------------------------------
-//
-EXPORT_C TBool CFileManagerEngine::IsFolder( const TInt aIndex ) const
-    {
-    if ( aIndex < 0 || aIndex >= iNavigator->MdcaCount() )
-        {
-        return EFalse;
-        }
-    CGflmGroupItem* item = iNavigator->Item( aIndex );
-    TBool ret( EFalse );
-    switch ( item->Type() )
-        {
-        case CGflmGroupItem::EDirectory: // Fallthrough
-        case CGflmGroupItem::EDrive: // Fallthrough
-        case CGflmGroupItem::EGlobalActionItem:
-            {
-            ret = ETrue;
-            break;
-            }
-        default:
-            {
-            break;
-            }
-        }
-    return ret;
-    }
-
-// ------------------------------------------------------------------------------
-// CFileManagerEngine::IconIdL
-//
-// ------------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::IconIdL( const TInt aIndex ) const
-    {
-    if ( aIndex < 0 || aIndex >= iNavigator->MdcaCount() )
-        {
-        User::Leave( KErrNotFound );
-        }
-    CGflmGroupItem* item = iNavigator->Item( aIndex );
-    return iUtils->ResolveIconL( *item );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::ShowWaitDialogL( MAknBackgroundProcess& aProcess )
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerEngine::ShowWaitDialogL( MAknBackgroundProcess& aProcess )
-    {
-    iWaitDialogOn = ETrue;
-    TRAPD( err, iProcessObserver->ShowWaitDialogL( aProcess ) );
-    iWaitDialogOn = EFalse;
-    User::LeaveIfError( err );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::EmbeddedAppStatus( TBool aStatus )
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerEngine::EmbeddedAppStatus( TBool aStatus )
-    {
-    iEmbeddedApplicationOn = aStatus;
-    FileSystemEvent( aStatus );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::IsSystemFolder
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TBool CFileManagerEngine::IsSystemFolder( const TDesC& aFullPath ) const
-    {
-    _LIT( KSystemFolder, "?:\\system\\*" );
-    _LIT( KSysFolder, "?:\\sys\\*" );
-    _LIT( KPrivateFolder, "?:\\private\\*" );
-    _LIT( KResourceFolder, "?:\\resource\\*" );
-
-    if ( aFullPath.MatchF( KSystemFolder ) != KErrNotFound ||
-        aFullPath.MatchF( KSysFolder ) != KErrNotFound ||
-        aFullPath.MatchF( KResourceFolder ) != KErrNotFound ||
-        aFullPath.MatchF( KPrivateFolder ) != KErrNotFound )
-        {
-        return ETrue;
-        }
-    return EFalse;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::CurrentDriveName()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TPtrC CFileManagerEngine::CurrentDriveName()
-    {
-#ifdef RD_MULTIPLE_DRIVE
-    TPtrC dir( iNavigator->CurrentDirectory() );
-    if ( dir.Length() )
-        {
-        TInt drive = TDriveUnit( dir );
-        return DriveName( drive );
-        }
-#else // RD_MULTIPLE_DRIVE
-    CGflmDriveItem* drvItem = iNavigator->CurrentDrive();
-    if ( drvItem )
-        {
-        return drvItem->Name();
-        }
-#endif // RD_MULTIPLE_DRIVE
-    return TPtrC( KNullDesC );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::GetDriveInfoL()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::GetDriveInfoL(
-        TFileManagerDriveInfo& aInfo )
-    {
-    if ( iCurrentDriveInfoRefreshed )
-        {
-        // Use cached info
-        aInfo = iCurrentDriveInfo;
-        return;
-        }
-
-    CGflmDriveItem* drvItem = iNavigator->CurrentDrive();
-    if ( drvItem )
-        {
-        GetDriveInfoL( drvItem->Drive(), aInfo );
-
-        // Store info for later use
-        iCurrentDriveInfo = aInfo;
-        iCurrentDriveInfoRefreshed = ETrue;
-        }
-    else
-        {
-        User::Leave( KErrNotFound );
-        }
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::IsDistributableFile()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::IsDistributableFile(
-        const TDesC& aFullPath, TBool& aIsProtected ) const
-    {
-    return iUtils->IsDistributableFile( aFullPath, aIsProtected );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::RenameDrive()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::RenameDrive(
-        const TInt aDrive,
-        const TDesC& aName )
-    {
-    TInt len( aName.Length( ) );
-    for( TInt i( 0 ); i < len; i++ )
-        {
-        TChar ch( aName[ i ] );
-        // If not alphadigit or space, return error
-        if( !ch.IsAlphaDigit() && !ch.IsSpace() )
-            {
-            return KErrBadName;
-            }
-        }
-    TInt err( iFs.SetVolumeLabel( aName, aDrive ) );
-    if ( err == KErrNone )
-        {
-        // Refresh drive info after rename
-        ClearDriveInfo();
-        }
-    return err;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetDrivePassword()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::SetDrivePassword(
-        const TInt aDrive,
-        const TMediaPassword& aOld,
-        const TMediaPassword& aNew )
-    {
-    ClearDriveInfo();
-    TInt err( iFs.LockDrive( aDrive, aOld, aNew, ETrue ) );
-    INFO_LOG1( "CFileManagerEngine::SetDrivePassword err %d", err );
-    return err;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::RemoveDrivePassword()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::RemoveDrivePassword(
-        const TInt aDrive,
-        const TMediaPassword& aPwd )
-    {
-    ClearDriveInfo();
-    TInt err( iFs.ClearPassword( aDrive, aPwd ) );
-    INFO_LOG1( "CFileManagerEngine::RemoveDrivePassword err %d", err );
-    return err;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::UnlockDrive()
-//
-// -----------------------------------------------------------------------------
-//    
-EXPORT_C TInt CFileManagerEngine::UnlockDrive(
-        const TInt aDrive,
-        const TMediaPassword& aPwd )
-    {
-    ClearDriveInfo();
-    TInt err( iFs.UnlockDrive( aDrive, aPwd, ETrue ) );
-    INFO_LOG1( "CFileManagerEngine::UnlockDrive err %d", err );
-    return err;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::StartFormatProcessL()
-//
-// -----------------------------------------------------------------------------
-//  
-EXPORT_C void CFileManagerEngine::StartFormatProcessL(
-        const TInt aDrive )
-    {
-    ClearDriveInfo();
-    iRemovableDrvHandler->StartFormatL( aDrive );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::StartEjectProcessL()
-//
-// -----------------------------------------------------------------------------
-//  
-EXPORT_C void CFileManagerEngine::StartEjectProcessL( const TInt /*aDrive*/ )
-    {
-    ClearDriveInfo();
-    iRemovableDrvHandler->StartEjectL();
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::StartBackupProcessL()
-//
-// -----------------------------------------------------------------------------
-//  
-EXPORT_C void CFileManagerEngine::StartBackupProcessL(
-        MFileManagerProcessObserver::TFileManagerProcess aProcess )
-    {
-    switch( aProcess )
-        {
-        case MFileManagerProcessObserver::EBackupProcess: // FALLTHROUGH
-        case MFileManagerProcessObserver::ESchBackupProcess:
-            {
-            // Make sure that there is no embedded apps open
-            delete iDocHandler;
-            iDocHandler = NULL;
-
-            ClearDriveInfo();
-            iRemovableDrvHandler->StartBackupL( aProcess );
-            break;
-            }
-        case MFileManagerProcessObserver::ERestoreProcess:
-            {
-            ClearDriveInfo();
-            iRemovableDrvHandler->StartRestoreL();
-            break;
-            }
-        default:
-            {
-            User::Leave( KErrNotSupported );
-            break;
-            }
-        }
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::CancelProcess()
-//
-// -----------------------------------------------------------------------------
-//  
-EXPORT_C void CFileManagerEngine::CancelProcess(
-        MFileManagerProcessObserver::TFileManagerProcess aProcess )
-    {
-    switch( aProcess )
-        {
-        case MFileManagerProcessObserver::EFormatProcess:
-        case MFileManagerProcessObserver::EBackupProcess: // FALLTHROUGH
-        case MFileManagerProcessObserver::ERestoreProcess: // FALLTHROUGH
-        case MFileManagerProcessObserver::ESchBackupProcess: // FALLTHROUGH
-            {
-            iRemovableDrvHandler->CancelProcess();
-            break;
-            }
-        case MFileManagerProcessObserver::EFileOpenProcess:
-            {
-            if ( iDocHandler )
-                {
-                iDocHandler->CancelFileOpen();
-                }
-            break;
-            }
-        default:
-            {
-            break;
-            }
-        }
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::GetDriveInfoL()
-//
-// -----------------------------------------------------------------------------
-// 
-void CFileManagerEngine::GetDriveInfoL(
-        const TDesC& aPath,
-        TFileManagerDriveInfo& aInfo ) const
-    {
-    if ( !aPath.Length() )
-        {
-        User::Leave( KErrNotFound );
-        }
-    TInt drv( 0 );
-    User::LeaveIfError( RFs::CharToDrive( aPath[ 0 ], drv ) );
-    GetDriveInfoL( drv, aInfo );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::DriveState()
-//
-// -----------------------------------------------------------------------------
-// 
-EXPORT_C TInt CFileManagerEngine::DriveState(
-        TUint32& aState, const TDesC& aPath ) const
-    {
-    TFileManagerDriveInfo info;
-    TRAPD( err, GetDriveInfoL( aPath, info ) );
-    if ( err == KErrNone )
-        {
-        aState = info.iState;
-        }
-    else
-        {
-        aState = 0;
-        }
-    return err;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::DriveState()
-//
-// -----------------------------------------------------------------------------
-// 
-EXPORT_C TInt CFileManagerEngine::DriveState(
-        TUint32& aState, const TInt aDrive ) const
-    {
-    TFileManagerDriveInfo info;
-    TRAPD( err, GetDriveInfoL( aDrive, info ) );
-    if ( err == KErrNone )
-        {
-        aState = info.iState;
-        }
-    else
-        {
-        aState = 0;
-        }
-    return err;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::MGXFileManagerL()
-//
-// -----------------------------------------------------------------------------
-// 
-/*CMGXFileManager& CFileManagerEngine::MGXFileManagerL()
-    {
-    // MG2 notification object
-    if ( !iMgxFileManager )
-        {
-        INFO_LOG( "CFileManagerEngine::MGXFileManagerL()-Create" )
-        iMgxFileManager = MGXFileManagerFactory::NewFileManagerL( iFs );
-        }
-    return *iMgxFileManager;
-    }*/
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::Fs()
-//
-// -----------------------------------------------------------------------------
-// 
-RFs& CFileManagerEngine::Fs() const
-    {
-    return iFs;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::IsRemoteDriveConnected()
-//
-// -----------------------------------------------------------------------------
-// 
-TBool CFileManagerEngine::IsRemoteDriveConnected( const TInt aDrive  ) const
-    {
-    return iRemoteDrvHandler->IsConnected( aDrive );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetRemoteDriveConnection()
-//
-// -----------------------------------------------------------------------------
-// 
-EXPORT_C TInt CFileManagerEngine::SetRemoteDriveConnection(
-        const TInt aDrive, TBool aConnect )
-    {
-    return iRemoteDrvHandler->SetConnection( aDrive, aConnect );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::DeleteRemoteDrive()
-//
-// -----------------------------------------------------------------------------
-// 
-EXPORT_C TInt CFileManagerEngine::DeleteRemoteDrive( const TInt aDrive )
-    {
-    return iRemoteDrvHandler->DeleteSettings( aDrive );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::BackupFileExistsL()
-//
-// -----------------------------------------------------------------------------
-// 
-#ifndef RD_FILE_MANAGER_BACKUP
-
-TBool CFileManagerEngine::BackupFileExistsL( const TInt aDrive ) const
-    {
-    return iRemovableDrvHandler->BackupFileExistsL( aDrive );
-    }
-
-#endif // RD_FILE_MANAGER_BACKUP
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::OpenFileL()
-//
-// -----------------------------------------------------------------------------
-// 
-void CFileManagerEngine::OpenFileL( const TDesC& aFullPath )
-    {
-    if ( !iDocHandler )
-        {
-        iDocHandler = CFileManagerDocHandler::NewL( *this, *iUtils );
-        }
-    iDocHandler->OpenFileL( aFullPath, iProcessObserver );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::OpenDirectoryL()
-//
-// -----------------------------------------------------------------------------
-// 
-void CFileManagerEngine::OpenDirectoryL( const TDesC& aFullPath )
-    {
-    iNavigator->GoToDirectoryL( aFullPath, ETrue );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::DriveRootDirectory()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TPtrC CFileManagerEngine::DriveRootDirectory( TInt aDrive ) const
-    {
-    CGflmDriveItem* drvItem = iNavigator->DriveFromId( aDrive );
-    if ( drvItem )
-        {
-        return drvItem->RootDirectory();
-        }
-    return TPtrC( KNullDesC );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::BackupSettingsL()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C CFileManagerBackupSettings& CFileManagerEngine::BackupSettingsL()
-    {
-    if ( !iBackupSettings )
-        {
-        INFO_LOG( "CFileManagerEngine::BackupSettingsL()-Create" )
-        iBackupSettings = CFileManagerBackupSettings::NewL( *this );
-        }
-    return *iBackupSettings;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::RestoreSettingsL()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C CFileManagerRestoreSettings& CFileManagerEngine::RestoreSettingsL()
-    {
-    if ( !iRestoreSettings )
-        {
-        INFO_LOG( "CFileManagerEngine::RestoreSettingsL()-Create" )
-        iRestoreSettings = CFileManagerRestoreSettings::NewL( *this );
-        }
-    return *iRestoreSettings;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::GetRestoreInfoArrayL()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::GetRestoreInfoArrayL(
-        RArray< CFileManagerRestoreSettings::TInfo >& aArray,
-        const TInt aDrive ) const
-    {
-    return iRemovableDrvHandler->GetRestoreInfoArrayL( aArray, aDrive );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::DriveName()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TPtrC CFileManagerEngine::DriveName( const TInt aDrive )
-    {
-    CGflmDriveItem* drvItem = iNavigator->DriveFromId( aDrive );
-    if ( drvItem )
-        {
-#ifdef RD_MULTIPLE_DRIVE
-        delete iDriveName;
-        iDriveName = NULL;
-
-        TRAPD( err, iDriveName = iUtils->GetDriveNameL(
-            drvItem->Drive(), CFileManagerUtils::ETitleLayout ) );
-        if ( err == KErrNone )
-            {
-            return iDriveName->Des();
-            }
-#else // RD_MULTIPLE_DRIVE
-        return drvItem->Name();
-#endif // RD_MULTIPLE_DRIVE
-        }
-    return TPtrC( KNullDesC );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::GetDriveInfoL()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::GetDriveInfoL(
-            const TInt aDrive, TFileManagerDriveInfo& aInfo ) const
-    {
-    aInfo.GetInfoL( *this, aDrive );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::CurrentDriveAvailable()
-//
-// -----------------------------------------------------------------------------
-//
-TBool CFileManagerEngine::CurrentDriveAvailable()
-    {
-    TFileManagerDriveInfo info;
-    TRAPD( err, GetDriveInfoL( info ) );
-    if ( err != KErrNone )
-        {
-        return EFalse;
-        }
-
-    TInt ret( ETrue );
-    if ( info.iState & (
-            TFileManagerDriveInfo::EDriveCorrupted |
-            TFileManagerDriveInfo::EDriveLocked ) )
-        {
-        ret = EFalse;
-        }
-    else if ( !( info.iState & TFileManagerDriveInfo::EDrivePresent ) )
-        {
-        ret = EFalse;
-        }
-
-    if ( ( info.iState & TFileManagerDriveInfo::EDriveRemote ) &&
-         !( info.iState & TFileManagerDriveInfo::EDriveConnected ) )
-        {
-        ret = EFalse;
-        }
-    return ret;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::ClearDriveInfo()
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerEngine::ClearDriveInfo()
-    {
-    iCurrentDriveInfoRefreshed = EFalse;
-    iNavigator->ClearDriveInfo();
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::AnyEjectableDrivePresent()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TBool CFileManagerEngine::AnyEjectableDrivePresent() const
-    {
-    RArray< TInt > drives;
-    iUtils->DriveList( drives, KDriveAttRemovable );
-    TInt ret( EFalse );
-    TInt count( drives.Count() );
-    const TInt KPresentBits(
-        TFileManagerDriveInfo::EDriveEjectable |
-        TFileManagerDriveInfo::EDrivePresent );
-    for( TInt i( 0 ); i < count; ++i )
-        {
-        TUint32 state( 0 );
-        if ( DriveState( state, drives[ i ] ) == KErrNone )
-            {
-            if ( ( state & KPresentBits ) == KPresentBits )
-                {
-                ret = ETrue;
-                break;
-                }
-            }
-        }
-    drives.Close();
-    return ret;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::ForcedRefreshDirectory()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::ForcedRefreshDirectory()
-    {
-    TPtrC ptr( iNavigator->CurrentDirectory() );
-    if ( ptr.Length() && iUtils->IsRemoteDrive( ptr ) )
-        {
-        // Ensure that remote directory is reloaded
-        iRemoteDrvHandler->RefreshDirectory( ptr );
-        }
-    RefreshDirectory();
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::HasAppRemoteDriveSupport()
-//
-// -----------------------------------------------------------------------------
-//
-TBool CFileManagerEngine::HasAppRemoteDriveSupport( TUid aUid )
-    {
-    return iRemoteDrvHandler->HasAppRemoteDriveSupport( aUid );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::GetFileSizesL()
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt64 CFileManagerEngine::GetFileSizesL(
-        const CArrayFixFlat<TInt>& aIndexList )
-    {
-    FUNC_LOG
-
-    TBool isCanceled( EFalse );
-    TInt64 size( 0 );
-    TInt count( aIndexList.Count() );
-
-    for( TInt i( 0 ); i < count; ++i )
-        {
-        CGflmGroupItem* item = iNavigator->Item( aIndexList.At( i ) );
-        switch ( item->Type() )
-            {
-            case CGflmGroupItem::EFile:
-                {
-                CGflmFileSystemItem* fsItem =
-                    static_cast< CGflmFileSystemItem* >( item );
-                size += static_cast<TUint>(fsItem->Entry().iSize);
-                break;
-                }
-            case CGflmGroupItem::EDirectory:
-                {                        
-                CGflmFileSystemItem* fsItem =
-                    static_cast< CGflmFileSystemItem* >( item );
-                HBufC* fullPath = fsItem->FullPathLC();
-
-                delete iActiveSize;
-                iActiveSize = NULL;
-
-                iActiveSize = CFileManagerActiveSize::NewL(
-                    iFs, *fullPath );
-
-                ShowWaitDialogL( *iActiveSize );
-
-                TInt64 folderSize( iActiveSize->GetFolderSize() );
-                if ( folderSize == KErrNotFound )
-                    {
-                    // Calculation was canceled by the user
-                    isCanceled = ETrue;
-                    }
-                else
-                    {
-                    size += folderSize;
-                    }
-
-                CleanupStack::PopAndDestroy( fullPath );
-                break;
-                }
-            default:
-                {
-                break;
-                }
-            }
-
-        if ( isCanceled )
-            {
-            break;
-            }
-        }
-
-    if ( isCanceled )
-        {
-        return KErrNotFound;
-        }
-    return size;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::CancelTransfer()
-//
-// -----------------------------------------------------------------------------
-//
-void CFileManagerEngine::CancelTransfer( const TDesC& aFullPath )
-    {
-    if ( iUtils->IsRemoteDrive( aFullPath ) )
-        {
-        iRemoteDrvHandler->CancelTransfer( aFullPath );
-        }
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::NavigationLevel
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt CFileManagerEngine::NavigationLevel() const
-    {
-    return iNavigator->NavigationLevel();
-    }
-
-#ifdef RD_MULTIPLE_DRIVE
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::GetFormattedDriveNameLC
-// -----------------------------------------------------------------------------
-//
-EXPORT_C HBufC* CFileManagerEngine::GetFormattedDriveNameLC(
-        const TInt aDrive,
-        const TInt aTextIdForDefaultName,
-        const TInt aTextIdForName ) const
-    {
-    return iUtils->GetFormattedDriveNameLC(
-        aDrive, aTextIdForDefaultName, aTextIdForName );
-    }
-#else // RD_MULTIPLE_DRIVE
-EXPORT_C HBufC* CFileManagerEngine::GetFormattedDriveNameLC(
-        const TInt /*aDrive*/,
-        const TInt /*aTextIdForDefaultName*/,
-        const TInt /*aTextIdForName*/  ) const
-    {
-    User::Leave( KErrNotSupported );
-    return NULL;
-    }
-#endif // RD_MULTIPLE_DRIVE
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::GetItemInfoLC
-// -----------------------------------------------------------------------------
-//
-EXPORT_C CFileManagerItemProperties* CFileManagerEngine::GetItemInfoLC(
-        const TInt aIndex )
-    {
-    CFileManagerItemProperties* ret = GetItemInfoL( aIndex );
-    CleanupStack::PushL( ret );
-    return ret;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetSearchStringL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::SetSearchStringL( const TDesC& aSearchString )
-    {
-    delete iSearchString;
-    iSearchString = NULL;
-    iSearchString = aSearchString.AllocL();
-    iNavigator->SetSearchStringL( aSearchString );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetSearchFolderL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::SetSearchFolderL( const TDesC& aSearchFolder )
-    {
-    delete iSearchFolder;
-    iSearchFolder = NULL;
-    iSearchFolder = aSearchFolder.AllocL();
-    iNavigator->SetSearchFolderL( aSearchFolder );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetDirectoryWithBackstepsL
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::SetDirectoryWithBackstepsL(
-        const TDesC& aDirectory )
-    {
-    CGflmDriveItem* drvItem = iNavigator->DriveFromPath( aDirectory );
-    if ( !drvItem )
-        {
-        return;
-        }
-    // Build backsteps
-    iNavigator->GoToDirectoryL( drvItem->RootDirectory(), aDirectory );
-
-    // Build navigation indices
-    iNavigationIndices.Reset();
-    iNavigationIndices.AppendL( KErrNotFound ); // Set initial
-    TInt count( iNavigator->NavigationLevel() ); // Set backsteps
-    for( TInt i( 0 ); i < count; ++i )
-        {
-        iNavigationIndices.AppendL( KErrNotFound );
-        }
-    iNavigationIndices.AppendL( KErrNotFound ); // Set current
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetCurrentIndex
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::SetCurrentIndex( const TInt aIndex )
-    {
-    TInt pos( iNavigationIndices.Count() - 1 );
-    if ( pos >= 0 )
-        {
-        iNavigationIndices[ pos ] = aIndex;
-        }
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetSortMethod
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::SetSortMethod( TSortMethod aSortMethod )
-    {
-    switch ( aSortMethod )
-        {
-        case EByName:          // Fallthrough
-        case EByType:          // Fallthrough
-        case EMostRecentFirst: // Fallthrough
-        case ELargestFirst:    // Fallthrough
-        case EByMatch:
-            {
-            // Make sure that the enums do match
-            iNavigator->SetSortMethod(
-                static_cast< TGflmSortMethod >( aSortMethod ) );
-            break;
-            }
-        default:
-            {
-            ERROR_LOG1(
-                "CFileManagerEngine::SetSortMethod-InvalidMethod=%d",
-                aSortMethod )
-            break;
-            }
-        }
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SortMethod
-// -----------------------------------------------------------------------------
-//
-EXPORT_C CFileManagerEngine::TSortMethod CFileManagerEngine::SortMethod() const
-    {
-    // Make sure that the enums do match
-    return static_cast< TSortMethod >( iNavigator->SortMethod() );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::RefreshSort
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::RefreshSort()
-    {
-    iRefresher->Refresh( ERefreshSort );
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::FeatureManager
-// -----------------------------------------------------------------------------
-//
-EXPORT_C CFileManagerFeatureManager& CFileManagerEngine::FeatureManager() const
-    {
-    return *iFeatureManager;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetAppExitOb
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::SetAppExitOb( MAknServerAppExitObserver* aObserver )
-    {
-    iObserver = aObserver;
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::NoticeServerAppExit
-// -----------------------------------------------------------------------------
-//
-void CFileManagerEngine::NoticeServerAppExit( TInt aReason )
-    {
-    if ( iObserver && iSisFile )
-        {
-        iUtils->FlushCache();
-        iObserver->HandleServerAppExit( aReason );
-        iSisFile = EFalse;
-        }
-    }
-
-// -----------------------------------------------------------------------------
-// CFileManagerEngine::SetSisFile
-// -----------------------------------------------------------------------------
-//
-void CFileManagerEngine::SetSisFile( TBool aSisFile )
-    {
-    iSisFile = aSisFile;
-    }
-
-// ---------------------------------------------------------------------------
-// CFileManagerEngine::LatestBackupTimeL()
-// ---------------------------------------------------------------------------
-//
-TInt CFileManagerEngine::LatestBackupTime( TTime& aBackupTime )
-    {
-    TRAPD( err, iRemovableDrvHandler->LatestBackupTimeL( aBackupTime ) );
-    return err;
-    }
-
-// ---------------------------------------------------------------------------
-// CFileManagerEngine::DeleteBackupsL()
-// ---------------------------------------------------------------------------
-//
-EXPORT_C void CFileManagerEngine::DeleteBackupsL()
-    {
-    iRemovableDrvHandler->DeleteBackupsL();
-    }
-
-
-//  End of File