/*
* 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:  Deletes files
*
*/


// INCLUDE FILES
#include "Cfilemanageractivedelete.h"
#include "MFileManagerProcessObserver.h"
#include "CFileManagerEngine.h"
#include "CFileManagerCommonDefinitions.h"
#include "CFileManagerUtils.h"
#include "FileManagerDebug.h"
//#include <cmgxfilemanager.h>

// CONSTANTS
const TInt KFileManagerDeletionPerStep = 20;
const TInt64 KFileManagerMaxStepTime = 1000000; // 1s
const TInt KFileManagerNotificationArrayGranularity = 64;


// ============================ LOCAL FUNCTIONS ================================
// -----------------------------------------------------------------------------
// GetTimeStamp
// -----------------------------------------------------------------------------
//
static TInt64 GetTimeStamp()
    {
    TTime time;
    time.UniversalTime();
    return time.Int64();
    }

// -----------------------------------------------------------------------------
// IsTimedOut
// -----------------------------------------------------------------------------
//
static TBool IsTimedOut( const TInt64& aStartTime )
    {
    TInt64 time( GetTimeStamp() );
    TBool ret( time - aStartTime > KFileManagerMaxStepTime );
    if ( ret )
        {
        INFO_LOG("CFileManagerActiveDelete-TimedOut");
        }
    return ret;
    }


// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::CFileManagerActiveDelete
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CFileManagerActiveDelete::CFileManagerActiveDelete(
        RFs& aFs,
        CArrayFixFlat< TInt >& aIndexList,
        CFileManagerEngine& aEngine,
        CFileManagerUtils& aUtils ) :
    iFs( aFs ),
    iIndexList( aIndexList ),
    iError( KErrNone ),
    iEngine( aEngine ),
    iUtils( aUtils )
    {
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CFileManagerActiveDelete* CFileManagerActiveDelete::NewL(
        CArrayFixFlat< TInt >& aIndexList,
        CFileManagerEngine& aEngine,
        CFileManagerUtils& aUtils )
    {
    CFileManagerActiveDelete* self = new( ELeave ) CFileManagerActiveDelete(
        aEngine.Fs(), aIndexList, aEngine, aUtils );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::ConstructL
// 
// -----------------------------------------------------------------------------
// 
void CFileManagerActiveDelete::ConstructL()
    {
    iStringBuffer = HBufC::NewL( KMaxFileName );
    //MG2 notification object
    //iMgxFileManager = &iEngine.MGXFileManagerL();
    iRemovedItems = new( ELeave ) CDesCArrayFlat(
        KFileManagerNotificationArrayGranularity );
    iIsRemoteDrive = iUtils.IsRemoteDrive( iEngine.CurrentDirectory() );
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::~CFileManagerActiveDelete
// Destructor
// -----------------------------------------------------------------------------
// 
EXPORT_C CFileManagerActiveDelete::~CFileManagerActiveDelete()
    {
    delete iStringBuffer;
    delete iFullPath;
    delete iDirScan;
    delete iDir;
    delete iRemovedItems;
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::IsProcessDone
// 
// -----------------------------------------------------------------------------
// 
TBool CFileManagerActiveDelete::IsProcessDone() const
    {
    return iProcessDone;
    }

// -----------------------------------------------------------------------------
// CFileManagerEngine::DeleteItemsInDirectoryL
// -----------------------------------------------------------------------------
//
TBool CFileManagerActiveDelete::DeleteItemsInDirectoryL()
    {
    if ( !iDirScan )
        {
        iDirScan = CDirScan::NewL( iFs );
        // Set scanning from current directory, take all files
        // No sorting needed
        iDirScan->SetScanDataL( *iFullPath,
            KEntryAttNormal | KEntryAttHidden | KEntryAttSystem,
            ESortNone );
        }

    if ( iDir && iFileIndex < iDir->Count() )
        {
        // Delete file item
        const TEntry& item = ( *iDir )[ iFileIndex ];
        TPtr ptr( iStringBuffer->Des() );
        CFileManagerUtils::GetFullPath(
            iDirScan->FullPath(), item, ptr );
        CFileManagerUtils::RemoveReadOnlyAttribute( iFs, ptr, item );
        DeleteFileL( ptr, ETrue );
        ++iFileIndex;
        }
    else
        {
        // Fetch next directory
        delete iDir;
        iDir = NULL;
        iDirScan->NextL( iDir );
        iFileIndex = 0;

        if ( iDir )
            {
            CFileManagerUtils::RemoveReadOnlyAttribute(
                iFs, iDirScan->FullPath() );
            }
        }

    if ( !iDir )
        {
        // Items are deleted now, report done
        if ( !iNotDeletedItems )
            {
            // Delete all directories
            CFileMan* fileMan = CFileMan::NewL( iFs );
            SetError( fileMan->RmDir( *iFullPath ), *iFullPath );
            delete fileMan;
            }
        return ETrue;
        }
    return EFalse; // Still items left
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::StepL
// 
// -----------------------------------------------------------------------------
// 
void CFileManagerActiveDelete::StepL()
    {
    FUNC_LOG

    TInt64 startTime( GetTimeStamp() );
    TInt indexCount( iIndexList.Count() );
    TInt i( KFileManagerDeletionPerStep );
    TBool timedOut( EFalse );

    while ( iCurrentIndex < indexCount && i && !timedOut )
        {
        TBool isItemDone( EFalse );

        // Fetch item path if missing
        if ( !iFullPath )
            {
            iFullPath = iEngine.IndexToFullPathL(
                iIndexList.At( iCurrentIndex ) );
            if ( IsDir( *iFullPath ) )
                {
                // Ignore default folders
                if ( iUtils.DefaultFolder( *iFullPath ) )
                    {
                    SetError( KErrFmgrDefaultFolder, *iFullPath );
                    isItemDone = ETrue;
                    }
                }
            }
        // Delete item
        if ( !isItemDone )
            {
            if ( IsDir( *iFullPath ) )
                {
                // Delete directory item
                while ( iCurrentIndex < indexCount && i && !isItemDone && !timedOut )
                    {
                    isItemDone = DeleteItemsInDirectoryL();
                    --i;

                    // Adjust amount of deleted files per step by consumed time. 
                    // This is an attempt to avoid long periods of time, 
                    // where the UI does not respond to user activity.
                    timedOut = IsTimedOut( startTime );
                    }
                }
            else
                {
                // Delete file item
                DeleteFileL( *iFullPath );
                isItemDone = ETrue;
                --i;

                // Adjust amount of deleted files per step by consumed time. 
                // This is an attempt to avoid long periods of time, 
                // where the UI does not respond to user activity.
                timedOut = IsTimedOut( startTime );
                }
            }

        // Move to next item if done
        if ( isItemDone )
            {
            delete iFullPath;
            iFullPath = NULL;
            ++iCurrentIndex;
            }
        }

    if ( iCurrentIndex >= indexCount )
        {
        iProcessDone = ETrue;
        FlushNotifications();
        }
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::DialogDismissedL
//
// -----------------------------------------------------------------------------
//
void CFileManagerActiveDelete::DialogDismissedL( TInt aButtonId )
    {
    if ( aButtonId == EAknSoftkeyCancel )
        {
        FlushNotifications();
        }
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::GetError
// 
// -----------------------------------------------------------------------------
// 
EXPORT_C TInt CFileManagerActiveDelete::GetError( TDes& aFileName )
    {
    if( iFileName.Length() > 0)
        {
        aFileName.Zero();
        aFileName.Append( iFileName );
        }
    if ( iOpenFiles > 1 )
        {
        iError = KErrFmgrSeveralFilesInUse;
        }
    return iError;
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::DeletedDrmItems
// 
// -----------------------------------------------------------------------------
// 
EXPORT_C TInt CFileManagerActiveDelete::DeletedDrmItems(TInt& aTotalCount )
    {
    aTotalCount = iDeletedItems;
    return iDeletedDrmItems;
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::DeleteFileL
// 
// -----------------------------------------------------------------------------
// 
void CFileManagerActiveDelete::DeleteFileL(
        const TDesC& aFullPath, const TBool aReadOnlyChecked )
    {
#ifndef RD_DRM_RIGHTS_MANAGER_REMOVAL
    TBool isLocalDataFile( EFalse );
    TBool isDrmProtected( EFalse );
    if ( !iIsRemoteDrive )
        {
        // Check DRM protection
        isDrmProtected = iUtils.IsDrmProtectedFile( aFullPath );
        if ( isDrmProtected )
            {
            isLocalDataFile = iUtils.IsDrmLocalDataFile( aFullPath );
            }
        }
#endif // RD_DRM_RIGHTS_MANAGER_REMOVAL

    TInt err( iFs.Delete( aFullPath ) );
    if ( err == KErrAccessDenied && !aReadOnlyChecked )
        {
        // Remove readonly and retry
        TEntry entry;
        if( iFs.Entry( aFullPath, entry ) == KErrNone )
            {
            CFileManagerUtils::RemoveReadOnlyAttribute(
                iFs, aFullPath, entry );
            err = iFs.Delete( aFullPath );
            }
        }
    if ( !IsError( err ) )
        {
        ++iDeletedItems;
        // Notification is relevant only for local drives
        if ( !iIsRemoteDrive )
            {
            TRAPD( err2, iRemovedItems->AppendL( aFullPath ) );
            if ( err2 != KErrNone )
                {
                ERROR_LOG1(
                    "CFileManagerActiveExecute::DeleteFileL-NotificationAppend-err=%d",
                    err2 )
                }
            }
#ifndef RD_DRM_RIGHTS_MANAGER_REMOVAL
        // Inform deletion of DRM protected files except local data files
        if( isDrmProtected && !isLocalDataFile )
            {
            ++iDeletedDrmItems;
            SetName( aFullPath );
            }
#endif // RD_DRM_RIGHTS_MANAGER_REMOVAL
        }
    else
        {
        // Delete failed, update error info
        SetError( err, aFullPath );
        if ( err == KErrInUse )
            {
            ++iOpenFiles;
            }
        ++iNotDeletedItems;
        }
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::IsDir
// 
// -----------------------------------------------------------------------------
// 
TBool CFileManagerActiveDelete::IsDir( const TDesC& aFullPath )
    {
    return CFileManagerUtils::HasFinalBackslash( aFullPath );
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::SetName
// 
// -----------------------------------------------------------------------------
// 
void CFileManagerActiveDelete::SetName( const TDesC& aFullPath,
        TBool aOverWrite )
    {
    if ( !aOverWrite && iFileName.Length() )
        {
        return;
        }
    iFileName.Zero();
    if ( aFullPath.Length() )
        {
        if ( IsDir( aFullPath ) )
            {
            TParsePtrC parse( aFullPath.Left( aFullPath.Length() - 1 ) );
            iFileName.Append( parse.Name() );
            }
        else
            {
            TParsePtrC parse( aFullPath );
            iFileName.Append( parse.NameAndExt() );
            }
        }
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::IsError
// 
// -----------------------------------------------------------------------------
// 
TBool CFileManagerActiveDelete::IsError( TInt aErr )
    {
    return ( aErr != KErrNone &&
            aErr != KErrCorrupt &&
            aErr != KErrNotFound &&
            aErr != KErrPathNotFound );
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::SetError
// 
// -----------------------------------------------------------------------------
// 
void CFileManagerActiveDelete::SetError( TInt aErr, const TDesC& aFullPath )
    {
    if ( iError == KErrNone && IsError( aErr ) )
        {
        iError = aErr;
        SetName( aFullPath, ETrue );
        }
    }

// -----------------------------------------------------------------------------
// CFileManagerActiveDelete::FlushNotifications
// -----------------------------------------------------------------------------
//
void CFileManagerActiveDelete::FlushNotifications()
    {
    if ( iRemovedItems->MdcaCount() > 0 )
        {
        //TRAP_IGNORE( iMgxFileManager->UpdateL( *iRemovedItems ) );
        iRemovedItems->Reset();
        }
    }

// End of file