diff -r 95243422089a -r 491b3ed49290 filemanager/Engine/src/CFileManagerUtils.cpp --- a/filemanager/Engine/src/CFileManagerUtils.cpp Thu Aug 19 09:42:45 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1127 +0,0 @@ -/* -* Copyright (c) 2002-2007 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: Util methods for File Manager -* -*/ - - - -// INCLUDE FILES -#include -#include -#include -#include -#include -#include -#include -#include -#ifdef RD_MULTIPLE_DRIVE -#include -#endif // RD_MULTIPLE_DRIVE -#if defined( __KEEP_DRM_CONTENT_ON_PHONE ) && defined ( FILE_MANAGER_USE_DISTRIBUTABLECHECKER ) - #include -#endif // __KEEP_DRM_CONTENT_ON_PHONE && FILE_MANAGER_USE_DISTRIBUTABLECHECKER -#include "GflmUtils.h" -#include -#include "CFileManagerUtils.h" -#include "CFilemanagerMimeIconArray.h" -#include "Cfilemanagerfolderarray.h" -#include "CGflmNavigatorModel.h" -#include "CFileManagerItemProperties.h" -#include "CFileManagerCommonDefinitions.h" -#include "CGflmGroupItem.h" -#include "CGflmFileSystemItem.h" -#include "CGflmDriveItem.h" -#include "CFileManagerFeatureManager.h" - -// CONSTANTS -_LIT( KFlk, "flk:" ); -_LIT( KLdf, "ldf:" ); - -#ifdef RD_MULTIPLE_DRIVE -const TInt KDriveNameArrayLen = 2; -const TInt KDriveLetterIndex = 0; -const TInt KDriveNameIndex = 1; -enum TFmgrDriveNameType - { - EFmgrDeviceMemory = 0, - EFmgrMassStorage, - EFmgrNamedMemoryCard, - EFmgrDefaultMemoryCard, - EFmgrDefaultUsbMemory, - EFmgrDriveNameTypeCount // Must be the last - }; - -typedef TInt TFmgrDriveNameLayoutText[ EFmgrDriveNameTypeCount ]; -const TFmgrDriveNameLayoutText KFmgrDriveNames[] = -{ - { // CFileManagerUtils::EMainLayout - R_QTN_FMGR_MAIN_DEVICE_MEMORY, // EFmgrDeviceMemory - R_QTN_FMGR_MAIN_MASS_STORAGE, // EFmgrMassStorage - R_QTN_FMGR_MAIN_NAMED_MEMORY_CARD, // EFmgrNamedMemoryCard - R_QTN_FMGR_MAIN_MEMORY_CARD_DEFAULT, // EFmgrDefaultMemoryCard - R_QTN_FMGR_MAIN_USB_DEFAULT // EFmgrDefaultUsbMemory - }, - { // CFileManagerUtils::ETitleLayout - R_QTN_FMGR_TITLE_DEVICE_MEMORY, // EFmgrDeviceMemory - R_QTN_FMGR_TITLE_MASS_STORAGE, // EFmgrMassStorage - R_QTN_FMGR_TITLE_NAMED_MEMORY_CARD, // EFmgrNamedMemoryCard - R_QTN_FMGR_TITLE_MEMORY_CARD_DEFAULT, // EFmgrDefaultMemoryCard - R_QTN_FMGR_TITLE_USB_DEFAULT, // EFmgrDefaultUsbMemory - } -}; -#endif // RD_MULTIPLE_DRIVE - - -// ============================ MEMBER FUNCTIONS =============================== - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::CFileManagerUtils -// C++ default constructor can NOT contain any code, that -// might leave. -// ----------------------------------------------------------------------------- -// -CFileManagerUtils::CFileManagerUtils( - RFs& aFs, - CGflmNavigatorModel& aNavigator, - CFileManagerFeatureManager& aFeatureManager ) : - iFs( aFs ), - iNavigator( aNavigator ), - iFeatureManager( aFeatureManager ) - { - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::ConstructL -// Symbian 2nd phase constructor can leave. -// ----------------------------------------------------------------------------- -// -void CFileManagerUtils::ConstructL() - { - // Check and set value to indicate if the feature is supported - iDrmFullSupported = iFeatureManager.IsDrmFullSupported(); - - iMimeIconMapper = CFileManagerMimeIconArray::NewL( - R_FILEMANAGER_MIME_ICON_MAPPER, iNavigator ); - -#ifdef RD_MULTIPLE_DRIVE - iDefaultFolders = CFileManagerFolderArray::NewL( *this ); -#else // RD_MULTIPLE_DRIVE - iDefaultFolders = CFileManagerFolderArray::NewL( - R_FILEMANAGER_DEFAULT_FOLDERS, *this ); - iDefaultFolders->CreateFolders(); -#endif // RD_MULTIPLE_DRIVE - - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::NewL -// Two-phased constructor. -// ----------------------------------------------------------------------------- -// -CFileManagerUtils* CFileManagerUtils::NewL( - RFs& aFs, - CGflmNavigatorModel& aNavigator, - CFileManagerFeatureManager& aFeatureManager ) - { - CFileManagerUtils* self = - new( ELeave ) CFileManagerUtils( aFs, aNavigator, aFeatureManager ); - - CleanupStack::PushL( self ); - self->ConstructL(); - CleanupStack::Pop( self ); - - return self; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::~CFileManagerUtils -// -// ----------------------------------------------------------------------------- -// -CFileManagerUtils::~CFileManagerUtils() - { -#if defined( __KEEP_DRM_CONTENT_ON_PHONE ) && defined ( FILE_MANAGER_USE_DISTRIBUTABLECHECKER ) - delete iDistributableChecker; -#endif // __KEEP_DRM_CONTENT_ON_PHONE && FILE_MANAGER_USE_DISTRIBUTABLECHECKER - delete iMimeIconMapper; - delete iDefaultFolders; - delete iCommonContentPolicy; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::Fs() const -// -// ----------------------------------------------------------------------------- -// -RFs& CFileManagerUtils::Fs() const - { - return iFs; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsForwardLockedFile -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::IsForwardLockedFile( const TDesC& aFullPath ) - { - if ( iDrmFullSupported ) - { - return EFalse; // Full DRM is used - } - TBool ret( EFalse ); - - if ( !iCommonContentPolicy ) - { - TRAPD( err, iCommonContentPolicy = CCommonContentPolicy::NewL() ); - if ( err != KErrNone ) - { - _LIT( KReason, "No Common Content Policy" ); - User::Panic( KReason, err ); - } - } - - if( iCommonContentPolicy ) - { - TRAPD( err, ret = iCommonContentPolicy->IsClosedFileL( aFullPath ) ); - if ( err != KErrNone ) - { - ret = EFalse; - } - } - - return ret; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsDrmProtectedFile -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::IsDrmProtectedFileL( const TDesC& aFullPath ) const - { - if ( !iDrmFullSupported ) - { - return EFalse; // Partial DRM is used - } -#if 0 - // Check from file extension, this is the fastest possible check - _LIT( KOdfExt, ".odf" ); - _LIT( KDcfExt, ".dcf" ); - TParsePtrC parse( aFullPath ); - TPtrC ext( parse.Ext() ); - return ( !ext.CompareF( KOdfExt ) || !ext.CompareF( KDcfExt ) ); -#else - // Do similar quick check than in old DRMCommon - - RFile64 drmFile; - - TInt err = drmFile.Open( - iFs, aFullPath, EFileRead | EFileShareReadersOrWriters ); - if( err != KErrNone ) - { - // Just assume it is not protected when we fail to open it. - drmFile.Close(); - return EFalse; - } - CleanupClosePushL( drmFile ); - DRM::CDrmUtility *drmCheck = DRM::CDrmUtility::NewLC(); - - TBool isProtected( EFalse ); - TRAP_IGNORE( isProtected = drmCheck->IsProtectedL( drmFile ) ); - - CleanupStack::PopAndDestroy( drmCheck ); - CleanupStack::PopAndDestroy( &drmFile ); - - return isProtected; -#endif - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::ResolveIconL -// -// ----------------------------------------------------------------------------- -// -TInt CFileManagerUtils::ResolveIconL( const TDesC& aFullPath ) const - { - TInt iconId( EFileManagerOtherFileIcon ); - if ( HasFinalBackslash( aFullPath ) ) - { - // Do not check for subfolders for remote drives - iconId = EFileManagerFolderIcon; - if ( !IsRemoteDrive( aFullPath ) ) - { - if ( HasSubFolders( aFullPath ) ) - { - iconId = EFileManagerFolderSubIcon; - } - else if ( !HasFiles( aFullPath ) ) - { - iconId = EFileManagerFolderEmptyIcon; - } - } - } - else - { - iconId = iMimeIconMapper->ResolveIconL( aFullPath ); - } - return iconId; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::DefaultFolder -// -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::DefaultFolder( const TDesC& aFullPath ) const - { - return iDefaultFolders->Contains( aFullPath ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsDrmLocalDataFile -// -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::IsDrmLocalDataFile( const TDesC& aFullPath ) const - { - if ( !iDrmFullSupported ) - { - return EFalse; // Partial DRM is used - } - - TBool isFlk( EFalse ); - TBool isLdf( EFalse ); - TRAP_IGNORE( IsFlkOrLdfFileL( aFullPath, isFlk, isLdf ) ); - return isLdf; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::CanDelete -// -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::CanDelete( const TDesC& aFileName ) const - { - TEntry entry; - TBool ret( EFalse ); - TBool fileOpen( EFalse ); - if ( KErrNone == iFs.Entry( aFileName, entry ) && - KErrNone == iFs.IsFileOpen( aFileName, fileOpen ) ) - { - if ( !entry.IsReadOnly() && !entry.IsSystem() && !fileOpen ) - { - ret = ETrue; - } - } - return ret; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::FileTypeL -// -// ----------------------------------------------------------------------------- -// -TUint32 CFileManagerUtils::FileTypeL( const TDesC& aFullPath ) - { - TUint32 fileType( CFileManagerItemProperties::ENotDefined ); - - _LIT( KRootFolder, "?:\\" ); - if ( !aFullPath.MatchF( KRootFolder ) ) - { - // RFs::Entry cannot be used for root folders - fileType |= CFileManagerItemProperties::EFolder; - } - else if ( !IsRemoteDrive( aFullPath ) ) - { - // Full check for local and removable drives - TEntry entry; - User::LeaveIfError( iFs.Entry( aFullPath, entry ) ); - - if ( HasFinalBackslash( aFullPath ) || entry.IsDir() ) - { - fileType |= CFileManagerItemProperties::EFolder; - - if ( DefaultFolder( aFullPath ) ) - { - fileType |= CFileManagerItemProperties::EDefault; - } - } - else - { - fileType |= CFileManagerItemProperties::EFile; - - if ( IsDrmProtectedFileL( aFullPath) ) - { - fileType |= CFileManagerItemProperties::EDrmProtected; - if ( IsDrmLocalDataFile( aFullPath ) ) - { - fileType |= CFileManagerItemProperties::EDrmLocalDataFile; - } - } - if ( IsForwardLockedFile( aFullPath ) ) - { - fileType |= CFileManagerItemProperties::EForwardLocked; - } - // MimeIcon mapper knowledge is used to determine file type - TInt id( iMimeIconMapper->ResolveIconL( aFullPath ) ); - if ( id == EFileManagerLinkFileIcon ) - { - fileType |= CFileManagerItemProperties::ELink; - } - if ( id == EFileManagerPlaylistFileIcon ) - { - fileType |= CFileManagerItemProperties::EPlaylist; - } - - TBool fileOpen( EFalse ); - if ( iFs.IsFileOpen( aFullPath, fileOpen ) == KErrNone ) - { - if ( fileOpen ) - { - fileType |= CFileManagerItemProperties::EOpen; - } - } - if ( fileOpen || entry.IsReadOnly() || entry.IsSystem() ) - { - fileType |= CFileManagerItemProperties::EReadOnly; - } - } - } - else - { - // Simple check for remote drives - if ( HasFinalBackslash( aFullPath ) ) - { - fileType |= CFileManagerItemProperties::EFolder; - } - else - { - fileType |= CFileManagerItemProperties::EFile; - } - } - - return fileType; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::ResolveIconL -// -// ----------------------------------------------------------------------------- -// -TInt CFileManagerUtils::ResolveIconL( CGflmGroupItem& aItem ) const - { - TInt iconId( EFileManagerOtherFileIcon ); - if ( aItem.GetIconId( iconId ) == KErrNone ) - { - // Use already mapped icon - return iconId; - } - - // Map icon - switch ( aItem.Type() ) - { - case CGflmGroupItem::EFile: - { - CGflmFileSystemItem& fsItem = - static_cast< CGflmFileSystemItem& >( aItem ); - HBufC* fullPath = fsItem.FullPathLC(); - iconId = iMimeIconMapper->ResolveIconL( *fullPath ); - fsItem.SetIconId( iconId ); - CleanupStack::PopAndDestroy( fullPath ); - break; - } - case CGflmGroupItem::EDirectory: - { - CGflmFileSystemItem& fsItem = - static_cast< CGflmFileSystemItem& >( aItem ); - HBufC* fullPath = fsItem.FullPathLC(); - - // Do not check for subfolders for remote drives - iconId = EFileManagerFolderIcon; - if ( !IsRemoteDrive( *fullPath ) ) - { - if ( HasSubFolders( *fullPath ) ) - { - iconId = EFileManagerFolderSubIcon; - } - else if ( !HasFiles( *fullPath ) ) - { - iconId = EFileManagerFolderEmptyIcon; - } - } - fsItem.SetIconId( iconId ); - CleanupStack::PopAndDestroy( fullPath ); - break; - } - case CGflmGroupItem::EDrive: // Fall through - case CGflmGroupItem::EGlobalActionItem: - { - break; - } - default: - { - User::Leave( KErrNotFound ); - break; - } - } - - return iconId; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::HasAny -// -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::HasAny( - RFs& aFs, const TDesC& aFullPath, TUint aAttMask ) - { - RDir dir; - TBool ret( EFalse ); - if ( dir.Open( aFs, aFullPath, aAttMask ) != KErrNone ) - { - return EFalse; - } - TEntry entry; - if ( dir.Read( entry ) == KErrNone ) - { - ret = ETrue; - } - dir.Close(); - return ret; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::HasSubFolders -// -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::HasSubFolders( const TDesC& aFullPath ) const - { - return HasAny( iFs, aFullPath, KEntryAttDir | KEntryAttMatchExclusive ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::HasFiles -// -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::HasFiles( const TDesC& aFullPath ) const - { - return HasAny( iFs, aFullPath, KEntryAttNormal ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsRemoteDrive -// -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::IsRemoteDrive( const TDesC& aPath ) const - { - TBool ret( EFalse ); - - if ( aPath.Length() ) - { - CGflmDriveItem* drvItem = iNavigator.DriveFromPath( aPath ); - if ( drvItem ) - { - const TVolumeInfo& vol( drvItem->VolumeInfo() ); - if ( vol.iDrive.iDriveAtt & KDriveAttRemote ) - { - ret = ETrue; - } - } - } - return ret; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::CreateDefaultFolders -// -// ----------------------------------------------------------------------------- -// -void CFileManagerUtils::CreateDefaultFolders( - const TInt aDrive, const TBool aForced ) const - { - iDefaultFolders->CreateFolders( aDrive, aForced ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsDistributableFile -// -// ----------------------------------------------------------------------------- -// -TInt CFileManagerUtils::IsDistributableFile( - const TDesC& aFullPath, TBool& aIsProtected ) - { -#if defined( __KEEP_DRM_CONTENT_ON_PHONE ) && defined ( FILE_MANAGER_USE_DISTRIBUTABLECHECKER ) - if ( !iDistributableChecker ) - { - TRAPD( err, iDistributableChecker = CDistributableChecker::NewL() ); - if ( err != KErrNone ) - { - _LIT( KReason, "No Distributablechecker" ); - User::Panic( KReason, err ); - } - } - return iDistributableChecker->Check( aFullPath, aIsProtected ); -#else // __KEEP_DRM_CONTENT_ON_PHONE && FILE_MANAGER_USE_DISTRIBUTABLECHECKER - aIsProtected = EFalse; - TBool isFlk( EFalse ); - TBool isLdf( EFalse ); - TRAPD( err, IsFlkOrLdfFileL( aFullPath, isFlk, isLdf ) ); - // Do similar check than in old DRMCommon - aIsProtected = ( isFlk || isLdf ); - return err; -#endif // __KEEP_DRM_CONTENT_ON_PHONE && FILE_MANAGER_USE_DISTRIBUTABLECHECKER - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::MimeTypeL -// -// ----------------------------------------------------------------------------- -// -TPtrC CFileManagerUtils::MimeTypeL( const TDesC& aFullPath ) const - { - return iNavigator.ResolveMimeTypeL( aFullPath ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::DriveList -// -// ----------------------------------------------------------------------------- -// -void CFileManagerUtils::DriveList( - RArray< TInt >& aDrives, const TInt aAttMask ) const - { - aDrives.Reset(); - TDriveList drivesList; - if ( iFs.DriveList( drivesList ) != KErrNone ) - { - return; - } - for ( TInt i( 0 ); i < KMaxDrives; i++ ) - { - if ( drivesList[ i ] ) - { - TBool append( EFalse ); - TDriveInfo drvInfo; - if ( iFs.Drive( drvInfo, i ) == KErrNone ) - { - if ( drvInfo.iDriveAtt & aAttMask ) - { - append = ETrue; - } - } - if ( append ) - { - aDrives.Append( i ); - } - } - } - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsRemovableDrive -// -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::IsRemovableDrive( const TDesC& aPath ) const - { - return IsDrive( iFs, aPath, KDriveAttRemovable ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::GetFullPath -// ----------------------------------------------------------------------------- -// -void CFileManagerUtils::GetFullPath( - const TDesC& aDir, const TEntry& aEntry, TDes& aFullPath ) - { - GflmUtils::GetFullPath( aDir, aEntry, aFullPath ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::StripFinalBackslash -// ----------------------------------------------------------------------------- -// -EXPORT_C TPtrC CFileManagerUtils::StripFinalBackslash( const TDesC& aPath ) - { - return GflmUtils::StripFinalBackslash( aPath ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::EnsureFinalBackslash -// ----------------------------------------------------------------------------- -// -EXPORT_C void CFileManagerUtils::EnsureFinalBackslash( TDes& aPath ) - { - GflmUtils::EnsureFinalBackslash( aPath ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::StripDirectionalCharsLC -// ----------------------------------------------------------------------------- -// -HBufC* CFileManagerUtils::StripDirectionalCharsLC( const TDesC& aText ) - { - HBufC* text = aText.AllocLC(); - TPtr ptr( text->Des() ); - AknTextUtils::StripCharacters( ptr, KFmgrDirectionalChars ); - return text; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsFlkOrLdfFileL -// ----------------------------------------------------------------------------- -// -void CFileManagerUtils::IsFlkOrLdfFileL( - const TDesC& aFullPath, TBool& aIsFlk, TBool& aIsLdf ) - { - aIsFlk = EFalse; - aIsLdf = EFalse; - ContentAccess::CContent* content = - ContentAccess::CContent::CContent::NewLC( - aFullPath, EContentShareReadOnly ); - HBufC* contentId = HBufC::NewLC( KMaxFileName ); - TPtr ptrContentId( contentId->Des() ); - TInt err( content->GetStringAttribute( - ContentAccess::EContentID, ptrContentId ) ); - if ( err != KErrNone && err != KErrCANotSupported ) - { - User::Leave( err ); - } - if ( !ptrContentId.Left( KFlk().Length() ).Compare( KFlk ) ) - { - aIsFlk = ETrue; - } - else if ( !ptrContentId.Left( KLdf().Length() ).Compare( KLdf ) ) - { - aIsLdf = ETrue; - } - CleanupStack::PopAndDestroy( contentId ); - CleanupStack::PopAndDestroy( content ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::HasFinalBackslash -// ----------------------------------------------------------------------------- -// -EXPORT_C TBool CFileManagerUtils::HasFinalBackslash( const TDesC& aPath ) - { - return GflmUtils::HasFinalBackslash( aPath ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsInternalDrive -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::IsInternalDrive( RFs& aFs, const TInt aDrive ) - { - return IsDrive( aFs, aDrive, KDriveAttInternal ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsFromInternalToRemovableDrive -// ----------------------------------------------------------------------------- -// -EXPORT_C TBool CFileManagerUtils::IsFromInternalToRemovableDrive( - RFs& aFs, const TDesC& aSrcPath, const TDesC& aDstPath ) - { - TInt srcDrv = TDriveUnit( aSrcPath ); - TInt dstDrv = TDriveUnit( aDstPath ); - if ( srcDrv == dstDrv ) - { - return EFalse; - } - return ( IsInternalDrive( aFs, srcDrv ) && - !IsInternalDrive( aFs, dstDrv ) ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::RemoveReadOnlyAttribute -// ----------------------------------------------------------------------------- -// -TInt CFileManagerUtils::RemoveReadOnlyAttribute( - RFs& aFs, const TDesC& aFullPath, const TEntry& aEntry ) - { - TInt ret( KErrNone ); - if( aEntry.IsReadOnly() ) - { - ret = aFs.SetEntry( - aFullPath, aEntry.iModified, 0, KEntryAttReadOnly ); - } - return ret; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::RemoveReadOnlyAttribute -// ----------------------------------------------------------------------------- -// -TInt CFileManagerUtils::RemoveReadOnlyAttribute( - RFs& aFs, const TDesC& aFullPath ) - { - TEntry entry; - TInt ret( aFs.Entry( aFullPath, entry ) ); - if ( ret == KErrNone ) - { - ret = RemoveReadOnlyAttribute( aFs, aFullPath, entry ); - } - return ret; - } - -#ifdef RD_MULTIPLE_DRIVE -// ----------------------------------------------------------------------------- -// CFileManagerUtils::GetDriveNameArrayLC -// ----------------------------------------------------------------------------- -// -CDesCArray* CFileManagerUtils::GetDriveNameArrayLC( - const TInt aDrive, TUint& aDriveStatus ) const - { - CGflmDriveItem* drvItem = iNavigator.DriveFromId( aDrive ); - if ( !drvItem ) - { - User::Leave( KErrNotFound ); - } - aDriveStatus = drvItem->DriveStatus(); - CDesCArray* ret = new( ELeave ) CDesCArrayFlat( KDriveNameArrayLen ); - CleanupStack::PushL( ret ); - ret->AppendL( TDriveUnit( aDrive ).Name() ); - - if ( aDriveStatus & DriveInfo::EDriveInternal ) - { - // Device memory and mass storage drives - return ret; - } - // Other drives - TPtrC drvName( drvItem->Name() ); - if ( drvName.Length() ) - { - ret->AppendL( drvName ); - } - return ret; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::GetDriveNameL -// ----------------------------------------------------------------------------- -// -HBufC* CFileManagerUtils::GetDriveNameL( - const TInt aDrive, const TDriveNameLayout aLayout ) const - { - if ( aLayout < 0 || aLayout >= ELayoutCount ) - { - User::Leave( KErrArgument ); - } - TUint driveStatus( 0 ); - CDesCArray* array = GetDriveNameArrayLC( aDrive, driveStatus ); - HBufC* ret = NULL; - if ( driveStatus & DriveInfo::EDriveInternal ) - { - // Device memory and mass storage drives - if ( driveStatus & DriveInfo::EDriveExternallyMountable ) - { - ret = StringLoader::LoadL( - KFmgrDriveNames[ aLayout ][ EFmgrMassStorage ], - array->MdcaPoint( KDriveLetterIndex ) ); - } - else - { - ret = StringLoader::LoadL( - KFmgrDriveNames[ aLayout ][ EFmgrDeviceMemory ], - array->MdcaPoint( KDriveLetterIndex ) ); - } - } - else if ( driveStatus & DriveInfo::EDriveRemovable ) - { - // Physically removable drives - if ( array->MdcaCount() > 1 ) - { - ret = StringLoader::LoadL( - KFmgrDriveNames[ aLayout ][ EFmgrNamedMemoryCard ], - *array ); - } - else - { - TInt driveType( EFmgrDefaultMemoryCard ); - if ( driveStatus & DriveInfo::EDriveUsbMemory ) - { - driveType = EFmgrDefaultUsbMemory; - } - ret = StringLoader::LoadL( - KFmgrDriveNames[ aLayout ][ driveType ], - array->MdcaPoint( KDriveLetterIndex ) ); - } - } - else if ( array->MdcaCount() > 1 ) - { - // Other drives - ret = array->MdcaPoint( KDriveNameIndex ).AllocL(); - } - else - { - User::Leave( KErrNotFound ); - } - CleanupStack::PopAndDestroy( array ); - return ret; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::GetFormattedDriveNameLC -// ----------------------------------------------------------------------------- -// -HBufC* CFileManagerUtils::GetFormattedDriveNameLC( - const TInt aDrive, - const TInt aTextIdForDefaultName, - const TInt aTextIdForName ) const - { - TUint driveStatus( 0 ); - HBufC* ret = NULL; - CDesCArray* array = GetDriveNameArrayLC( aDrive, driveStatus ); - if ( aTextIdForName && array->MdcaCount() > 1 ) - { - ret = StringLoader::LoadL( - aTextIdForName, - *array ); - } - else if ( aTextIdForDefaultName ) - { - if( driveStatus & DriveInfo::EDriveUsbMemory ) - { - CDesCArray* usbLetterName = new ( ELeave ) CDesCArrayFlat( KDriveNameArrayLen ); - CleanupStack::PushL( usbLetterName ); - - TPtrC16 driveletter=array->MdcaPoint( KDriveLetterIndex ); - usbLetterName->AppendL( driveletter ); - HBufC* usbDriveDefaultName = NULL; - if(array->MdcaCount() > 1 ) - { - TPtrC16 drivename=array->MdcaPoint( KDriveNameIndex ); - usbLetterName->AppendL( drivename ); - } - else - { - usbDriveDefaultName = StringLoader::LoadLC( R_QTN_FMGR_USB_MEMORY_DEFAULT_NAME ); - TPtrC16 drivename = usbDriveDefaultName->Des(); - usbLetterName->AppendL( drivename ); - } - - - ret = StringLoader::LoadL( - aTextIdForDefaultName,*usbLetterName ); - - CleanupStack::PopAndDestroy( usbLetterName ); - if ( usbDriveDefaultName ) - { - CleanupStack::PopAndDestroy( usbDriveDefaultName ); - } - } - else - { - ret = StringLoader::LoadL(aTextIdForDefaultName, array->MdcaPoint( - KDriveLetterIndex)); - } - } - else if ( array->MdcaCount() > 1 ) - { - ret = array->MdcaPoint( KDriveNameIndex ).AllocL(); - } - else - { - User::Leave( KErrNotFound ); - } - CleanupStack::PopAndDestroy( array ); - CleanupStack::PushL( ret ); - return ret; - } - -#endif // RD_MULTIPLE_DRIVE - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsRemoteDrive -// ----------------------------------------------------------------------------- -EXPORT_C TBool CFileManagerUtils::IsRemoteDrive( - RFs& aFs, const TDesC& aPath ) - { - return IsDrive( aFs, aPath, KDriveAttRemote ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsDrive -// ----------------------------------------------------------------------------- -TBool CFileManagerUtils::IsDrive( - RFs& aFs, const TDesC& aPath, const TUint aAttMask ) - { - TInt drv( 0 ); - if ( aPath.Length() && - RFs::CharToDrive( aPath[ 0 ], drv ) == KErrNone ) - { - return IsDrive( aFs, drv, aAttMask ); - } - return EFalse; - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsDrive -// ----------------------------------------------------------------------------- -TBool CFileManagerUtils::IsDrive( - RFs& aFs, const TInt aDrive, const TUint aAttMask ) - { - TDriveInfo drvInfo; - if ( aFs.Drive( drvInfo, aDrive ) == KErrNone ) - { - if ( drvInfo.iDriveAtt & aAttMask ) - { - return ETrue; - } - } - return EFalse; - } - -// ------------------------------------------------------------------------------ -// CFileManagerUtils::LocalizedName -// -// ------------------------------------------------------------------------------ -// -TPtrC CFileManagerUtils::LocalizedName( const TDesC& aFullPath ) const - { - return iNavigator.LocalizedName( aFullPath ); - } - -// ----------------------------------------------------------------------------- -// CFileManagerUtils::IsNameFoundL -// ----------------------------------------------------------------------------- -// -TBool CFileManagerUtils::IsNameFoundL( const TDesC& aFullPath ) const - { - TParsePtrC parse( CFileManagerUtils::StripFinalBackslash( aFullPath ) ); - TPtrC baseDir( parse.DriveAndPath() ); - TPtrC currentDir( iNavigator.CurrentDirectory() ); - TBool ret( EFalse ); - HBufC* name1 = CFileManagerUtils::StripDirectionalCharsLC( parse.NameAndExt() ); - // Remove white spaces from end, file server also ignores those - name1->Des().TrimRight(); - if ( !parse.PathPresent() || - ( currentDir.Length() && !currentDir.CompareF( baseDir ) ) ) - { - TBool searchmode = iNavigator.SearchMode(); - iNavigator.EnableSearchMode( EFalse ); - // Do check from current directory, all items are cached - TInt count( iNavigator.MdcaCount() ); - for( TInt i( 0 ); i < count; ++i ) - { - CGflmGroupItem* item = iNavigator.Item( i ); - TInt itemType( item->Type() ); - switch (itemType ) - { - case CGflmGroupItem::EFile: // FALLTHROUGH - case CGflmGroupItem::EDirectory: - { - // Compare with file system name - CGflmFileSystemItem* fsItem = - static_cast< CGflmFileSystemItem* >( item ); - HBufC* name2 = CFileManagerUtils::StripDirectionalCharsLC( - fsItem->Entry().iName ); - ret = !( name1->CompareF( *name2 ) ); - CleanupStack::PopAndDestroy( name2 ); - if ( !ret && itemType == CGflmGroupItem::EDirectory ) - { - // Compare with localized name - name2 = CFileManagerUtils::StripDirectionalCharsLC( - fsItem->Name() ); - if ( name2->Length() ) - { - ret = !( name1->CompareF( *name2 ) ); - } - CleanupStack::PopAndDestroy( name2 ); - } - break; - } - default: - { - break; - } - } - if ( ret ) - { - break; - } - } - iNavigator.EnableSearchMode( searchmode ); - } - else - { - // Do check from any directory - HBufC* buffer = HBufC::NewLC( - Max( KMaxFileName, aFullPath.Length() + KFmgrBackslashSpace ) ); - TPtr ptr( buffer->Des() ); - ptr.Copy( aFullPath ); - CFileManagerUtils::EnsureFinalBackslash( ptr ); - ret = ( BaflUtils::FolderExists( iFs, ptr ) || - BaflUtils::FileExists( iFs, - CFileManagerUtils::StripFinalBackslash( aFullPath ) ) ); - if ( !ret && - !IsRemoteDrive( aFullPath ) && - BaflUtils::PathExists( iFs, baseDir ) ) - { - // Check directory for localized items on local drives - CDir* dir = NULL; - User::LeaveIfError( iFs.GetDir( - baseDir, KEntryAttMatchMask | KEntryAttNormal, ESortNone, dir ) ); - CleanupStack::PushL( dir ); - ptr.Zero(); - TInt count( dir->Count() ); - for ( TInt i ( 0 ); i < count; ++i ) - { - HBufC* name2 = NULL; - const TEntry& entry( ( *dir )[ i ] ); - if( entry.IsDir() ) - { - // Compare with localized name - CFileManagerUtils::GetFullPath( baseDir, entry, ptr ); - TPtrC ptr2( iNavigator.LocalizedName( ptr ) ); - if ( ptr2.Length() ) - { - name2 = CFileManagerUtils::StripDirectionalCharsLC( ptr2 ); - } - } - if ( !name2 ) - { - // Compare with file system name - name2 = CFileManagerUtils::StripDirectionalCharsLC( entry.iName ); - } - ret = !( name1->CompareF( *name2 ) ); - CleanupStack::PopAndDestroy( name2 ); - if ( ret ) - { - break; - } - } - CleanupStack::PopAndDestroy( dir ); - } - CleanupStack::PopAndDestroy( buffer ); - } - CleanupStack::PopAndDestroy( name1 ); - return ret; - } -// ----------------------------------------------------------------------------- -// CFileManagerUtils::FlushCache -// ----------------------------------------------------------------------------- -// -void CFileManagerUtils::FlushCache() const - { - iNavigator.FlushCache(); - } - -// End of File