/*

* 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 <AknUtils.h>

#include <StringLoader.h>

#include <CDirectoryLocalizer.h>

#include <CommonContentPolicy.h>

#include <bautils.h>

#include <caf/caf.h>

#include <DcfCommon.h>

#include <filemanagerengine.rsg>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif // RD_MULTIPLE_DRIVE

#if defined( __KEEP_DRM_CONTENT_ON_PHONE ) && defined ( FILE_MANAGER_USE_DISTRIBUTABLECHECKER )

 #include <distributablechecker.h>

#endif // __KEEP_DRM_CONTENT_ON_PHONE && FILE_MANAGER_USE_DISTRIBUTABLECHECKER

#include "GflmUtils.h"

#include <drmutility.h>

#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

// 

// -----------------------------------------------------------------------------