/*

* 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:  Handles the copy/move operation

*

*/

#ifndef CFILEMANAGERACTIVEEXECUTE_H

#define CFILEMANAGERACTIVEEXECUTE_H

// INCLUDES

#include <e32base.h>

#include <f32file.h>

#include <badesca.h>

#include "FileManagerEngine.hrh"

#include "MFileManagerProcessObserver.h"

#include "MFileManagerThreadFunction.h"

// FORWARD DECLARATIONS

class CFileManagerEngine;

class MFileManagerItemIterator;

//class CMGXFileManager;

class CFileManagerThreadWrapper;

/**

*  CFileManagerActiveExecute

*

*  Handles the copy and move operations.

*

*  @lib FileManagerEngine.lib

*  @since 2.0

*/

NONSHARABLE_CLASS(CFileManagerActiveExecute) : public CActive,

                                               public MFileManagerThreadFunction

    {

    public:

        /**

        * Overwrite file switch

        */

        enum TFileManagerSwitch

            {

            ENoOverWrite = 1,

            EOverWrite

            };

        /**

        * Two-phased constructor.

        * @since 2.0

        * @param aEngine    reference to CFileManagerEngine instance

        * @param aOperation defines type of operation copy or move

        * @param aObserver  reference to MFileManagerProcess implemented

        *                   instance

        * @param aIndexList list of indexes from current view which needs operation

        * @param aToFolder  folder where items are moved or copied

        * @return Newly constructed CFileManagerActiveExecute

        */

        IMPORT_C static CFileManagerActiveExecute* NewL( 

            CFileManagerEngine& aEngine,

            MFileManagerProcessObserver::TFileManagerProcess aOperation,

            MFileManagerProcessObserver& aObserver,

            CArrayFixFlat<TInt>& aIndexList,

            const TDesC& aToFolder );

        /**

        * Destructor

        */

        IMPORT_C ~CFileManagerActiveExecute();

        /**

        * Executes one operation at time, one file copy/move or directory creation

        * @since 2.0

        * @param aOverWrite Over write the file or not

        */

        IMPORT_C void ExecuteL( TFileManagerSwitch aOverWrite );

        /**

        * Cancel the operation

        * @since 2.0

        */

        IMPORT_C void CancelExecution();

        /**

        * Gets destination folder

        * @since 3.2

        */

        IMPORT_C TPtrC ToFolder();

    private:

        // From CActive

        void DoCancel();

        void RunL();

        TInt RunError(TInt aError);

    private:

        /**

        * C++ default constructor.

        */

        CFileManagerActiveExecute( CFileManagerEngine& aEngine,

            MFileManagerProcessObserver::TFileManagerProcess aOperation,

            MFileManagerProcessObserver& aObserver );

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL( CArrayFixFlat<TInt>& aIndexList,

            const TDesC& aToFolder );

    private:

        /**

        * Item operation was succesfully carried on, move to next item

        */

        void KErrNoneActionL();

        /**

        * Item operation was not succesful because there was target item already

        * This function deals that situation

        */

        void KErrAlreadyExistsActionL();

        /**

        * Takes last folder name on other string and appends it to other

        * @param aResult Stores the result as full path

        * @param aSrc source full path which last folder name is taken

        * @param aDst target path where source last path is appended

        */

        void AddLastFolder( TDes& aResult, const TDesC& aSrc, const TDesC& aDst );

        /**

        * Performs a copy or move operation

        * 

        * @param aSwitch indicate destination file to be overwritten or not

        * @return system wide error code

        */

        TInt DoOperation( TInt aSwitch );

        /**

        * Checks if directory is empty

        * 

        * @param aDir Full path of the directory

        * @return ETrue if directory is empty, otherwise EFalse

        */

        TBool IsEmptyDir( const TDesC& aDir );

        /**

        * Completes operation

        * 

        * @param aError Operation result

        */

        void CompleteL( TInt aError );

        /**

        * Updates MG2 notifications

        * 

        * @param aForceFlush Indicates if notications are flushed

        * @param aError Indicates the result

        */

        void UpdateNotifications( TBool aFlush, TInt aError );

        static void AppendArrayIfNotFound(

            CDesCArray& aArray, const TDesC& aFullPath );

        void FlushArray( CDesCArray& aArray );

        void ThreadCopyOrMoveStepL();

        void ThreadFinalizeMoveStepL();

    private: // From MFileManagerThreadFunction

        void ThreadStepL();

        TBool IsThreadDone();

        void NotifyThreadClientL( TNotifyType aType, TInt aValue );

    private:

        // index to current CDir array

        TInt    iCurrentIndex;

        // Own: Source item with full path

        HBufC*  iFullPath;

        // Own: Destination item with full path

        HBufC*  iDestination;

        // Has user cancelled the operation

        TBool   iCancelled;

        // Source directory is empty so special operations are needed

        TBool   iEmptyDir;

        // Needed to get the item locations behind given index(es)

        CFileManagerEngine&             iEngine;

        // Ref: Shareable file server session

        RFs& iFs;

        // Move or copy operation

        MFileManagerProcessObserver::TFileManagerProcess    iOperation;

        // Own: Array of user selected items to be copied/moved

        CArrayFixFlat< TInt >*            iIndexList;

        // Own: user given destination folder

        HBufC*                          iToFolder;

        // Own: This is either CFileManagerIndexIterator or CFileManagerFileSystemIterator

        // depending of source item type, file or folder

        MFileManagerItemIterator*       iItemIterator;

        // Ref: File operation phases are signaled through this interface

        MFileManagerProcessObserver&    iObserver;

        // Ref: Current source item with full path

        // Needed for file already exist situations.

        HBufC* iSrc;

        // Ref: Current destination item with full path

        // Needed for file already exist situations.

        HBufC* iDst;

        // Total transferred bytes, used for progress note

        // except in same drive move operation

        TUint iBytesTransferredTotal;

        // Total transferred files, used for progress note

        // This is used if move operation is done inside drive

        TInt iFilesTransferredTotal;

        // Current error

        TInt iError;

        // Ref: MG2 update notification object

        //CMGXFileManager* iMgxFileManager;

        // Own: Thread wrapper for the operation

        CFileManagerThreadWrapper* iThreadWrapper;

        // Indicates the used operation switches

        TInt iSwitch;

        // Own: Buffer for storing changed items for MG2 notifications

        CDesCArray* iChangedSrcItems;

        // Own: Buffer for storing changed items for MG2 notifications

        CDesCArray* iChangedDstItems;

        // Indicates that the operation is done inside same drive

        TBool iOperationOnSameDrive;

        // Indicates that move operation is finalizing

        TBool iFinalizeMove;

        // Indicates that source of the operation is on remote drive

        TBool iIsSrcRemoteDrive;

        // Indicates that destination of the operation is on remote drive

        TBool iIsDstRemoteDrive;

        // Stores type of the current item

        TFileManagerTypeOfItem iItemType;

    };

#endif // CFILEMANAGERACTIVEEXECUTE_H

    // End of File