/*

* Copyright (c) 2004, 2005 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:  File operations, used when "Save" option is selected.

*

*/

// INCLUDE FILES

#include <flogger.h>

#include <eikenv.h>

#include <pathinfo.h>

#include <sysutil.h>

#include "SVGTViewerAppDbgFlags.hrh"

#include "SVGTFileManager.h"

#include "SVGTUISaveListener.h"

#ifdef SVGTVIEWERAPP_DBG_FLAG    

_LIT( KFileLoggingDir, "SVGTViewer" );

_LIT( KFileLog, "SaveLog.txt" );

#endif

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

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

// CSVGTFileManager::CSVGTFileManager

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CSVGTFileManager::CSVGTFileManager() : CActive(0)

    {

    }

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

// CSVGTFileManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSVGTFileManager::ConstructL()

    {

    iEikEnv = CEikonEnv::Static();    

    iFileMan = CFileMan::NewL( iEikEnv->FsSession(),this );

    iProgressUpdater =  CPeriodic::NewL( 0 );

    // Add this active object to the scheduler.

    CActiveScheduler::Add( this );    

    }

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

// CSVGTFileManager::NewL

// Two-phased constructor.

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

//

EXPORT_C CSVGTFileManager* CSVGTFileManager::NewL()

    {

    CSVGTFileManager* self = new( ELeave ) CSVGTFileManager();   

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSVGTFileManager::~CSVGTFileManager   

// Destructor

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

//

EXPORT_C CSVGTFileManager::~CSVGTFileManager()

    {

    delete iFileMan;

    delete iProgressUpdater;

    // Reset the callback implementation pointer

    iCallback = NULL;

    // Reset the environment pointer

    iEikEnv = NULL;

    }

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

// CSVGTFileManager::StartCopyOperationL

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

//

EXPORT_C TInt CSVGTFileManager::StartCopyOperationL( 

    MSVGTUISaveListener* aCallback, const TDesC& anOld, const TDesC& aNew )

    {

    if (IsActive())

        {

        return KErrInUse;

        }

    iPosition = 0;

    iCancel = EFalse;

    RFile lFile;

    TInt RetVal = KErrNone;//return value

    iCallback = aCallback;   

    RetVal = lFile.Open(iEikEnv->FsSession(),anOld, EFileRead); 

    if ( RetVal != KErrNone)

        {

        // if there was a problem opening this file then this should return here 

        //itself. Or else RTIY-6JNVHS error would occur.

        return RetVal ;

        } 

    lFile.Size(iFileSize);//get the file size into iFileSize

    lFile.Close();//no filehandle should be open while doing a "move"        

#ifdef SVGTVIEWERAPP_DBG_FLAG    

    _LIT( errorMsg2, "Size read");   

    PrintDebugMsg( errorMsg2 );

#endif

    // Check disk space

    TParsePtrC parse(aNew);

#ifndef RD_MULTIPLE_DRIVE

    if( parse.Drive().CompareF( PathInfo::MemoryCardRootPath().Left(2) ) == 0 )

        {

        if (SysUtil::MMCSpaceBelowCriticalLevelL(&(iEikEnv->FsSession()),iFileSize))

            {            

            return KErrDiskFull; // UI shows note

            }

        }

    else

        {

        if (SysUtil::FFSSpaceBelowCriticalLevelL(&(iEikEnv->FsSession()),iFileSize))

            {

            User::Leave(KErrDiskFull); // Phone memory full, Avkon shows note

            }

        }  

#else

//********************** Added the support for multiple drive ************************

    TInt intDrive;

    TChar ch = parse.Drive()[0];

    User::LeaveIfError( RFs::CharToDrive(ch,intDrive) );

    if( SysUtil::DiskSpaceBelowCriticalLevelL(&(iEikEnv->FsSession()),

                                iFileSize, intDrive ))

        {

        User::Leave( KErrDiskFull); // Disk full, Avkon shows note

        }

//************************************************************************************        

#endif    

    // start copying

    if( iMove )

        {

        User::LeaveIfError(

            iFileMan->Move(anOld,aNew,CFileMan::EOverWrite,iStatus));

        }

    if ( !iProgressUpdater->IsActive() )

        {

        // start progress updater

        iProgressUpdater->Start(KSVGTOneSecond,KSVGTOneSecond, 

                    TCallBack(CSVGTFileManager::ProgressUpdate, this));

        }    

    SetActive();

    return RetVal;

    }

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

// CSVGTFileManager::StartCopyOperationL

//   Overloaded version with RFile Input.

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

//

EXPORT_C TInt CSVGTFileManager::StartCopyOperationL( 

    MSVGTUISaveListener* aCallback, RFile& aSrcHandle, const TDesC& aNew )

    {

    TFileName sourceFileName;

    aSrcHandle.FullName( sourceFileName );

    aSrcHandle.Size(iFileSize);

    if ( iMove )

        {

        aSrcHandle.Close();

        return StartCopyOperationL( aCallback, sourceFileName, aNew );   

        }

    else

        {

        if (IsActive())

            {

            return KErrInUse;

            }

        iPosition = 0;

        iCancel = EFalse;

        iCallback = aCallback;   

        // Check disk space

        TParsePtrC parse(aNew);

#ifndef RD_MULTIPLE_DRIVE

        if( parse.Drive().CompareF( PathInfo::MemoryCardRootPath().Left(2) ) == 0 )

            {

            if (SysUtil::MMCSpaceBelowCriticalLevelL(&(iEikEnv->FsSession()),iFileSize))

                {       

                return KErrDiskFull; // UI shows note

                }

            }

        else

            {

            if (SysUtil::FFSSpaceBelowCriticalLevelL(&(iEikEnv->FsSession()),iFileSize))

                {

                User::Leave(KErrDiskFull); // Phone memory full, Avkon shows note

                }

            }  

#else

//********************** Added the support for multiple drive ************************

    TInt intDrive;

    TChar ch = parse.Drive()[0];

    User::LeaveIfError( RFs::CharToDrive(ch,intDrive) );

    if( SysUtil::DiskSpaceBelowCriticalLevelL(&(iEikEnv->FsSession()),

                                iFileSize, intDrive ))

        {

        User::Leave( KErrDiskFull); // Disk full, Avkon shows note

        }

//************************************************************************************        

#endif 

        User::LeaveIfError(

                iFileMan->Copy(aSrcHandle,aNew,CFileMan::EOverWrite,iStatus));

        if ( !iProgressUpdater->IsActive() )

            {

            // start progress updater

            iProgressUpdater->Start(KSVGTOneSecond,KSVGTOneSecond, 

                        TCallBack(CSVGTFileManager::ProgressUpdate, this));

            } 

        SetActive();

        return KErrNone;

        }       

    }

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

// CSVGTFileManager::DoCancel

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

//

EXPORT_C void CSVGTFileManager::CancelCopy()

    {

    iCancel = ETrue;

    iProgressUpdater->Cancel();

    Cancel();

    }

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

// CSVGTFileManager::SetAllowMove

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

//

EXPORT_C void CSVGTFileManager::SetAllowMove( TInt32 aValue )

    {

    iMove = aValue; 

    }

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

// CSVGTFileManager::RunL

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

//

void CSVGTFileManager::RunL() 

    {   

    iProgressUpdater->Cancel();

    if (iCallback)

        {

        if (iCancel)

            {

            iCallback->SVGTSavingDoneL(KErrCancel);

            }

        else

            {

            iCallback->SVGTSavingDoneL(iStatus.Int());

            }

        }

    }

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

// CSVGTFileManager::NotifyFileManOperation

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

//

MFileManObserver::TControl CSVGTFileManager::NotifyFileManOperation()

    {

    if (iCancel)

        {

        return MFileManObserver::ECancel;

        }

#ifdef SVGTVIEWERAPP_DBG_FLAG    

    TBuf<40> msg;

    _LIT( errorMsg, "NotifyFileManOperation %d");

    msg.Format(errorMsg, iFileMan->BytesTransferredByCopyStep() );

    PrintDebugMsg( msg );

#endif    

    iPosition += iFileMan->BytesTransferredByCopyStep();

    return MFileManObserver::EContinue;

    }

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

// CSVGTFileManager::DoCancel

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

//

void CSVGTFileManager::DoCancel()

    {

    }

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

// CSVGTFileManager::ProgressUpdate

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

//

TInt CSVGTFileManager::ProgressUpdate(TAny* aPtr)

    {

    if ( aPtr )

        {

        static_cast<CSVGTFileManager*>(aPtr)->DoProgressUpdate();        

        }

    return KErrNone;

    }

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

// CSVGTFileManager::DoProgressUpdate

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

//

void CSVGTFileManager::DoProgressUpdate()

    {

    if (iCallback)

        {    

        iCallback->SVGTPositionChanged((iPosition*KSVGTPercent)/iFileSize);

        }

    }

#ifdef SVGTVIEWERAPP_DBG_FLAG    

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

// CSVGTFileManager::PrintDebugMsg

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

//

void CSVGTFileManager::PrintDebugMsg( const TDesC&  aMsg )

    {

#ifdef _DEBUG        

    RFileLogger::Write( KFileLoggingDir, KFileLog, 

                        EFileLoggingModeAppend, aMsg );

#endif    

    }

#endif    

//  End of File