/*

* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0""

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Main class of the filemanagerengine

*

*/

// INCLUDE FILES

#include <StringLoader.h>

#include <barsread.h>

#include <sysutil.h>

#include <bautils.h>

//#include <cmgxfilemanager.h>

//#include <mgxfilemanagerfactory.h>

//#include <cmgalbummanager.h>

#include <pathinfo.h>

#include <AknServerApp.h>

#include <filemanagerengine.rsg>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif // RD_MULTIPLE_DRIVE

#include "CFileManagerEngine.h"

#include "CGflmNavigatorModel.h"

#include "CGflmGroupItem.h"

#include "CGflmFileSystemItem.h"

#include "CGflmDriveItem.h"

#include "CGflmGlobalActionItem.h"

#include "MGflmItemGroup.h"

#include "Cfilemanagerfolderarray.h"

#include "CFilemanagerMimeIconArray.h"

#include "CFileManagerActiveExecute.h"

#include "CFileManagerRefresher.h"

#include "Cfilemanagerfilesystemevent.h"

#include "Cfilemanageractivesize.h"

#include "Cfilemanageractivedelete.h"

#include "FileManagerEngine.hrh"

#include "CFileManagerCommonDefinitions.h"

#include "CFileManagerUtils.h"

#include "CFileManagerItemFilter.h"

#include "CFileManagerDocHandler.h"

#include "FileManagerDebug.h"

#include "CFileManagerItemProperties.h"

#include "CFileManagerRemovableDriveHandler.h"

#include "CFileManagerRemoteDriveHandler.h"

#include "CFileManagerBackupSettings.h"

#include "CFileManagerRestoreSettings.h"

#include "CFileManagerActiveRename.h"

#include "CFileManagerFeatureManager.h"

// CONSTANTS

const TUint16 KIllegalChars[] = {

    '<', '>', '"', '/', '\\', '|', ':', '*', '?',

    0xFF02, // Full width quote

    0xFF0A, // Full width asterisk

    0xFF0F, // Full width slash

    0xFF1A, // Full width colon

    0xFF1C, // Full width left arrow

    0xFF1E, // Full width right arrow

    0xFF1F, // Full width question mark

    0xFF3C, // Full width back slash

    0xFF5C, // Full width pipe

    0x201C, // Left quote

    0x201D, // Right quote

    0x201F, // Reversed quote

    0x21B2, // Downwards arrow with tip leftwards

    0, // Array terminator

};

const TUint KDiskEventCheckInterval = 100000; // microseconds

// ============================ 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 ),iDelayedDiskEventNotify( NULL )

    {

    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;

    if( iDelayedDiskEventNotify != NULL )

        {

        iDelayedDiskEventNotify->Cancel();

        delete iDelayedDiskEventNotify;

        }

    }

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

// 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 ];

        }