diff -r 491b3ed49290 -r 65326cf895ed filemanager/Engine/src/CFileManagerUtils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/filemanager/Engine/src/CFileManagerUtils.cpp Wed Sep 01 12:31:07 2010 +0100 @@ -0,0 +1,1127 @@ +/* +* 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