/*

* Copyright (c) 2009 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:  

*

*/

// INCLUDE FILES

#include "FBFileUtils.h"

#include "FBFileOps.h"

#include "FBModel.h"

#include "FBFileDlgs.h"

#include "FBFileEditor.h"

#include "FBFileListContainer.h"

#include "FB.hrh"

#include <filebrowser.rsg>

#include <textresolver.h> 

#include <AknWaitDialog.h>

#include <AknProgressDialog.h>

#include <eikprogi.h>

#include <f32file.h>

#include <eikfutil.h>

#include <apparc.h>

#include <eikenv.h>

#include <bautils.h>

#include <AknIconArray.h>

#include <gulicon.h>

#include <AknsUtils.h>

#include <AknsItemID.h>

#include <aknconsts.h>

#include <aknnotewrappers.h>

#include <AknProgressDialog.h> 

#include <aknPopup.h>

#include <aknmessagequerydialog.h>

#include <AknGlobalNote.h>

#include <babackup.h> 

#include <avkon.mbg>

#include <aknmemorycardui.mbg>

#include <sendui.h>

#include <CMessageData.h>

#include <ezgzip.h>

#include <e32hal.h>

#include <pathinfo.h>

#include <apgcli.h>

#include <apmstd.h>

#include <apgtask.h>

#include <apacmdln.h>

#include <DocumentHandler.h>

#include <AknOpenFileService.h>

#include <msvapi.h>

#include <msvids.h>

#include <msvstd.h>

#include <msvstore.h>

#include <mmsvattachmentmanager.h>

#include <cmsvattachment.h>

#include <hash.h>

#include <connect/sbeclient.h>

#include <e32property.h>

#if (!defined __SERIES60_30__ && !defined __SERIES60_31__) 

#include <driveinfo.h>

#endif // !defined __SERIES60_30__ && !defined __SERIES60_31__

#ifndef __SERIES60_30__

  #include <akniconconfig.h>

#endif

_LIT(KGZipExt, ".gz");

_LIT8(KFileNewLine, "\r\n");

const TInt KForcedFormatTimeout = 1000000;

// copied from coreapplicationuisdomainpskeys.h

const TUid KPSUidCoreApplicationUIs = { 0x101F8767 };

const TUint32 KCoreAppUIsMmcRemovedWithoutEject = 0x00000109;

enum TCoreAppUIsMmcRemovedWithoutEject

    {

    ECoreAppUIsEjectCommandUsedUninitialized = 0,

    ECoreAppUIsEjectCommandNotUsed,

    ECoreAppUIsEjectCommandUsed,

    ECoreAppUIsEjectCommandUsedToDrive // Low 16-bits contain this value and high 16-bits TDriveNumber to eject

    };

const TInt KDriveLetterStringLength = 3; // e.g. C:\

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

CFileBrowserFileUtils* CFileBrowserFileUtils::NewL(CFileBrowserModel* aModel)

	{

	CFileBrowserFileUtils* self = new(ELeave) CFileBrowserFileUtils(aModel);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

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

CFileBrowserFileUtils::CFileBrowserFileUtils(CFileBrowserModel* aModel) : CActive(EPriorityStandard), iModel(aModel)

	{

	}

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

void CFileBrowserFileUtils::ConstructL()

	{

    User::LeaveIfError(iTimer.CreateLocal());

    User::LeaveIfError(iFs.Connect());

    User::LeaveIfError(iTz.Connect());

    iState = EIdle;

    iListingMode = ENormalEntries;

    iSortMode = EFileBrowserCmdViewSortByName;

    iOrderMode = EFileBrowserCmdViewOrderAscending;

    iCurrentPath = KNullDesC;

    iFileOps = CFileBrowserFileOps::NewL(iModel);

    iDriveEntryList = new(ELeave) CDriveEntryList(8);

    iFileEntryList = new(ELeave) CFileEntryList(64);

    iFindFileEntryList = new(ELeave) CFileEntryList(64);

    iAppIconList = new(ELeave) CAppIconList(16);

    iClipBoardList = new(ELeave) CFileEntryList(64);

    iDocHandler = CDocumentHandler::NewL();

    iDocHandler->SetExitObserver(this);

    // set defaults to the search settings

    iSearchAttributes.iSearchDir = KNullDesC;

    iSearchAttributes.iWildCards = _L("*.jpg");

    iSearchAttributes.iTextInFile = KNullDesC;

    iSearchAttributes.iMinSize = 0;

    iSearchAttributes.iMaxSize = 999999999;

    iSearchAttributes.iMinDate = TDateTime(1980, EJanuary,   0,0,0,0,0);

    iSearchAttributes.iMaxDate = TDateTime(2060, EDecember, 30,0,0,0,0);

    iSearchAttributes.iRecurse = ETrue;

    // init the command array

    iCommandArray = new(ELeave) CCommandArray(64);

    // get current path from settings

    if (iModel->Settings().iRememberLastPath)

        {

        TFileName settingPath = iModel->Settings().iLastPath;

        if (BaflUtils::PathExists(iFs, settingPath))

            iCurrentPath = settingPath;

        if (iCurrentPath != KNullDesC)

            GetDriveListL();

        }

	CActiveScheduler::Add(this);

	}

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

CFileBrowserFileUtils::~CFileBrowserFileUtils()

	{

	Cancel();

	// save current path from settings

    if (iModel->Settings().iRememberLastPath)

        {

        iModel->Settings().iLastPath = iCurrentPath;

        TRAP_IGNORE(iModel->SaveSettingsL(EFalse));

        }

    if (iWaitDialog)

        TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); 

    if (iProgressDialog)

        TRAP_IGNORE(iProgressDialog->ProcessFinishedL());

    delete iFileOps;    

	delete iDocHandler;

	if (iOpenFileService)

	    delete iOpenFileService;

	delete iClipBoardList;

	delete iAppIconList;

	delete iFindFileEntryList;

    delete iFileEntryList;

    delete iDriveEntryList;

    delete iFileMan;

    if (iCommandArray)

        {

        ResetCommandArray();

        delete iCommandArray;

        }

    iTz.Close();

	iFs.Close();

	iTimer.Close();

    }

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

void CFileBrowserFileUtils::DoCancel()

	{

    iTimer.Cancel();

	}

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

void CFileBrowserFileUtils::StartExecutingCommandsL(const TDesC& aLabel)

    {

    if (iCommandArray->Count() >= 2)

        {

        // init progress bar

        iProgressDialog = new(ELeave) CAknProgressDialog((reinterpret_cast<CEikDialog**>(&iProgressDialog)), ETrue);

        iProgressDialog->SetCallback(this);

        iProgressDialog->PrepareLC(R_GENERAL_PROGRESS_NOTE);

        iProgressDialog->SetCurrentLabelL( EAknCtNote, aLabel );

        iProgressInfo = iProgressDialog->GetProgressInfoL();

        iProgressInfo->SetFinalValue( CommandArrayCount() );

        iProgressDialog->RunLD();

        iProgressDialog->MakeVisible( ETrue );        

        }

    else if (iCommandArray->Count() >= 1)

        {

        // init wait dialog

        iWaitDialog = new(ELeave) CAknWaitDialog((reinterpret_cast<CEikDialog**>(&iWaitDialog)), ETrue);

        iWaitDialog->SetCallback(this);

        iWaitDialog->PrepareLC(R_GENERAL_WAIT_NOTE);

        iWaitDialog->SetTextL( aLabel );

        iWaitDialog->RunLD();

        }

    else

        {

        // no commands, just do nothing

        return;

        }

    // start with the first operation

    iCurrentEntry = 0;

    iSucceededOperations = 0;

    iFailedOperations = 0;

    // starts executing commands

    ExecuteCommand();

    }

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

void CFileBrowserFileUtils::ExecuteCommand()

    {

    // make sure the engine isn't active, should never happen

    __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("FileUtils:IsActive"), 333));

    // execute a command after a very short delay (25ms)

    iTimer.After(iStatus, 25);

    SetActive();

    }

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

void CFileBrowserFileUtils::RunL()

    {

    TInt err(KErrNone);

    TInt currentCommand = iCommandArray->At(iCurrentEntry).iCommandId;

    // execute a command from the queue

    switch(currentCommand)

        {

        case EFileBrowserFileOpCommandAttribs:

            {

            CCommandParamsAttribs* params = static_cast<CCommandParamsAttribs*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->Attribs(params->iSourceEntry, params->iSetMask, params->iClearMask, params->iTime, params->iSwitch);

            }

            break;

        case EFileBrowserFileOpCommandCopy:

            {

            CCommandParamsCopyOrMove* params = static_cast<CCommandParamsCopyOrMove*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->Copy(params->iSourceEntry, params->iTargetPath, params->iSwitch);

            }

            break;

        case EFileBrowserFileOpCommandMove:

            {

            CCommandParamsCopyOrMove* params = static_cast<CCommandParamsCopyOrMove*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->Copy(params->iSourceEntry, params->iTargetPath, params->iSwitch, ETrue);

            }

            break;

        case EFileBrowserFileOpCommandRename:

            {

            CCommandParamsRename* params = static_cast<CCommandParamsRename*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->Rename(params->iSourceEntry, params->iTargetPath, params->iSwitch);

            }

            break;

        case EFileBrowserFileOpCommandDelete:

            {

            CCommandParamsDelete* params = static_cast<CCommandParamsDelete*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->Delete(params->iSourceEntry, params->iSwitch);

            }

            break;

        case EFileBrowserFileOpCommandDriveSnapShot:

            {

            CCommandParamsDriveSnapShot* params = static_cast<CCommandParamsDriveSnapShot*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->DriveSnapShot(params->iSourceDriveLetter, params->iTargetDriveLetter);

            }

            break;

        default:

            User::Panic (_L("Unknown command"), 400);

            break;

        }

    if (err == KErrNone)

        {

        iSucceededOperations++;

        }

    else if ( err != KErrCancel )

        {

        iFailedOperations++;

        }

    iLastError = err;            

    // check for more commands in queue

    TRAP_IGNORE( CheckForMoreCommandsL() );

    }

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

TInt CFileBrowserFileUtils::RunError(TInt aError)

    {

    _LIT(KMessage, "Command error %d");

    TBuf<128> noteMsg;

    noteMsg.Format(KMessage, aError);

    iModel->EikonEnv()->InfoMsg(noteMsg);

    TRAP_IGNORE( CheckForMoreCommandsL() );

    return KErrNone;

    }

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

void CFileBrowserFileUtils::CheckForMoreCommandsL()

    {

    //LOGSTRING("Creator: CCreatorEngine::CheckForMoreCommandsL");

    // update the progress bar

    if (iProgressInfo)

        iProgressInfo->IncrementAndDraw(1);

	// check if we have more commands to be executed

	if (iCurrentEntry >= CommandArrayCount() - 1)

		{

        //LOGSTRING("Creator: CCreatorEngine::CheckForMoreCommandsL all done");

        // all done, free resources

        ResetCommandArray();

        // deactive secure backup if it was activated by a file command

        iFileOps->DeActivateSecureBackUpViaFileOp();

        // dismiss any wait/progress dialogs        

        if (iWaitDialog)

            {

            TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); 

            iWaitDialog = NULL;

            }

        if (iProgressDialog)

            {

            TRAP_IGNORE(iProgressDialog->ProcessFinishedL());

            iProgressDialog = NULL;

            }

        // show result note

        if ( iSucceededOperations == 0 && iFailedOperations == 0 )

            {

            // single operation cancelled -> show nothing

            }

        else if (iSucceededOperations == 1 && iFailedOperations == 0)    

            {

            _LIT(KMessage, "Operation succeeded");

    		CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote;

    		note->ExecuteLD(KMessage);

            }

        else if (iSucceededOperations > 0 && iFailedOperations == 0)    

            {

            _LIT(KMessage, "%d operations succeeded");

            TBuf<128> noteMsg;

            noteMsg.Format(KMessage, iSucceededOperations);

    		CAknConfirmationNote* note = new(ELeave) CAknConfirmationNote;

    		note->ExecuteLD(noteMsg);

            }

        else if (iSucceededOperations == 0 && iFailedOperations > 1)    

            {

            _LIT(KMessage, "%d operations failed");

            TBuf<128> noteMsg;

            noteMsg.Format(KMessage, iFailedOperations);

    		CAknErrorNote* note = new(ELeave) CAknErrorNote;

    		note->ExecuteLD(noteMsg);

            }

        else if (iSucceededOperations > 0 && iFailedOperations > 0)    

            {

            _LIT(KMessage, "%d operations succeeded, %d failed");

            TBuf<128> noteMsg;

            noteMsg.Format(KMessage, iSucceededOperations, iFailedOperations);

    		CAknInformationNote* note = new(ELeave) CAknInformationNote;

    		note->ExecuteLD(noteMsg);

            }

        else    

            {

            CTextResolver* textResolver = CTextResolver::NewLC(*iModel->EikonEnv());     

            CAknErrorNote* note = new(ELeave) CAknErrorNote;

            note->ExecuteLD( textResolver->ResolveErrorString(iLastError, CTextResolver::ECtxNoCtxNoSeparator) );    

            CleanupStack::PopAndDestroy();  //textResolver    

            }

        RefreshViewL();

		}

	else

		{

		// maintain requests

		iCurrentEntry++;

        //LOGSTRING2("Creator: CCreatorEngine::CheckForMoreCommandsL iCurrentEntry=%d", iCurrentEntry);

        ExecuteCommand();

		}

    }    

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

// This callback function is called when cancel button of the progress bar was pressed

void CFileBrowserFileUtils::DialogDismissedL(TInt aButtonId)

    {

    iProgressDialog = NULL;

    iProgressInfo = NULL;

    iWaitDialog = NULL;

    // check if cancel button was pressed

    if (aButtonId == EAknSoftkeyCancel)

        {

        // cancel the active object, command executer 

        Cancel();

        iFileOps->CancelOp();

        ResetCommandArray();

	    CAknInformationNote* note = new (ELeave) CAknInformationNote;

	    note->ExecuteLD(_L("Cancelled"));

        }

    }

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

void CFileBrowserFileUtils::AppendToCommandArrayL(TInt aCommand, CCommandParamsBase* aParameters)

    {

    if (iCommandArray)

        iCommandArray->AppendL( TCommand(aCommand, aParameters) );

    else

        User::Leave(KErrNotReady);

    }

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

TInt CFileBrowserFileUtils::CommandArrayCount() const

    {

    TInt count(0);

    if (iCommandArray)

        count = iCommandArray->Count();

    return count;

    }

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

void CFileBrowserFileUtils::ResetCommandArray()

    {

    // delete params first

    for (TInt i=0; i<CommandArrayCount(); i++)

        {

        if ( iCommandArray->At(i).iParameters )

            {

            delete iCommandArray->At(i).iParameters;

            iCommandArray->At(i).iParameters = NULL;

            }

        }

    // reset the entries

    iCommandArray->Reset();

    }

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

void CFileBrowserFileUtils::HandleSettingsChangeL()

    {

    if (iModel->FileListContainer())

        {

        iModel->FileListContainer()->SetScreenLayoutL(iModel->Settings().iDisplayMode); 

        iModel->FileListContainer()->CreateListBoxL(iModel->Settings().iFileViewMode);

        //iModel->FileListContainer()->SetNaviPaneTextL(iCurrentPath);

        RefreshViewL();

        }

    }