diff -r 000000000000 -r 6a9f87576119 filemanager/Engine/src/CFileManagerEngine.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/filemanager/Engine/src/CFileManagerEngine.cpp Mon Jan 18 20:09:41 2010 +0200 @@ -0,0 +1,2221 @@ +/* +* 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 +#include +#include +#include +//#include +//#include +//#include +#include +#include +#include +#ifdef RD_MULTIPLE_DRIVE +#include +#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& 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(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