/*
* 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: File manager for managing file copy op
*
*/

#include "cmrfilemanager.h"
#include "esmrhelper.h"
#include <f32file.h>

/// LOCAL NAMESPACE
namespace
	{
// File copying block size
const TInt KWriteBlockSize( 1024  );
	}

// ---------------------------------------------------------------------------
// CMRFileManager::NewL
// ---------------------------------------------------------------------------
//
CMRFileManager* CMRFileManager::NewL( RFs& aFs )
    {
    CMRFileManager* self = new ( ELeave ) CMRFileManager( aFs );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CMRFileManager::~CMRFileManager
// ---------------------------------------------------------------------------
//
CMRFileManager::~CMRFileManager()
    {
    delete iFileArray;
    delete iCurrentFilename;
    delete iTempFilename;
    delete iOutputFileArray;
    iReadStream.Close();
    iWriteStream.Close();
    }

// ---------------------------------------------------------------------------
// CMRFileManager::CMRFileManager
// ---------------------------------------------------------------------------
//
CMRFileManager::CMRFileManager( RFs& aFs )
: CActive( CActive::EPriorityStandard ), iFs( aFs )
    {

    }

// ---------------------------------------------------------------------------
// CMRFileManager::ConstructL
// ---------------------------------------------------------------------------
//
void CMRFileManager::ConstructL()
    {
    CActiveScheduler::Add( this );
    }

// ---------------------------------------------------------------------------
// CMRFileManager::CopyFilesL
// ---------------------------------------------------------------------------
//
void CMRFileManager::CopyFilesL( MDesC16Array& aFilenameArray )
    {
    // Take copy of the original filename array
    TInt count( aFilenameArray.MdcaCount() );
    if( iFileArray )
        {
        delete iFileArray;
        iFileArray =  NULL;
        }
    iFileArray = new (ELeave) CDesCArrayFlat( count );
    for( TInt i = 0; i < count; ++i )
        {
        iFileArray->AppendL( aFilenameArray.MdcaPoint( i ) );
        }

    if( iOutputFileArray )
        {
        delete iOutputFileArray;
        iOutputFileArray = NULL;
        }
    iOutputFileArray = new (ELeave) CDesCArrayFlat( count );
    if( iCurrentFilename )
        {
        delete iCurrentFilename;
        iCurrentFilename = NULL;
        }

    PrepareNextFileL();

    iState = ECopyFile;
    AsyncOp();
    }

// ---------------------------------------------------------------------------
// CMRFileManager::CopyFileL
// ---------------------------------------------------------------------------
//
void CMRFileManager::CopyFileL(
        const TDesC& aSourceFilename,
        const TDesC& aDestFilename )
    {
    Cancel();

    iReadStream.Close();
    iWriteStream.Close();
    iReadStream.Open( iFs, aSourceFilename, EFileShareReadersOnly );
    iWriteStream.Open( iFs, aDestFilename, EFileWrite|EFileShareAny );

    if ( iObserver )
        {
        iObserver->NotifyStartL( aSourceFilename );
        }

    iState = ECopyFile;

    AsyncOp();
    }

// ---------------------------------------------------------------------------
// CMRFileManager::CopyFileL
// ---------------------------------------------------------------------------
//
void CMRFileManager::CopyFileL( RFile& aSource, RFile& aDest )
    {
    Cancel();

    iReadStream.Close();
    iWriteStream.Close();
    iReadStream.Attach( aSource );
    iWriteStream.Attach( aDest );

    if ( iObserver )
        {
        TFileName name;

        if ( KErrNone == aSource.Name( name ) )
            {
            iObserver->NotifyStartL( name );
            }
        }

    iState = ECopyFile;
    AsyncOp();
    }

// ---------------------------------------------------------------------------
// CMRFileManager::CancelOp
// ---------------------------------------------------------------------------
//
void CMRFileManager::CancelOp()
    {
    iState = ECancelled;
    }

// ---------------------------------------------------------------------------
// CMRFileManager::PrepareNextFileL
// ---------------------------------------------------------------------------
//
void CMRFileManager::PrepareNextFileL()
    {
    // Take first item as current
    if( iCurrentFilename )
        {
        delete iCurrentFilename;
        iCurrentFilename = NULL;
        }
    iCurrentFilename = (*iFileArray)[ 0 ].AllocL();


    TParse parser;
    parser.Set( *iCurrentFilename , NULL, NULL );
    TFileName attachmentName( parser.NameAndExt() );

    User::LeaveIfError( ESMRHelper::CreateAndAppendPrivateDirToFileName( attachmentName ) );

    iReadStream.Close();
    iWriteStream.Close();
    User::LeaveIfError( iWriteStream.Replace( iFs, attachmentName, EFileWrite|EFileShareAny ) );
    iReadStream.Open( iFs, *iCurrentFilename, EFileRead );
    iOutputFileArray->AppendL( attachmentName );

    delete iTempFilename;
    iTempFilename = NULL;
    iTempFilename = attachmentName.AllocL();

    if( iObserver )
        {
        iObserver->NotifyStartL( *iCurrentFilename );
        }
    }

// ---------------------------------------------------------------------------
// CMRFileManager::SetObserver
// ---------------------------------------------------------------------------
//
void CMRFileManager::SetObserver( MMRFileManObserver& aObserver )
    {
    iObserver = &aObserver;
    }

// ---------------------------------------------------------------------------
// CMRFileManager::RunL
// ---------------------------------------------------------------------------
//
void CMRFileManager::RunL()
    {
    if( iStatus.Int() != KErrNone )
        {
        iReadStream.Close();
        iWriteStream.Close();

        if( iObserver )
            {
            iObserver->NotifyError( iStatus.Int() );
            }
        return;
        }
    switch( iState )
        {
        case ECopyFile:
            {
            CopyFileL();

            if( iObserver )
                {
                iObserver->NotifyProgress( KWriteBlockSize );
                }
            AsyncOp();
            break;
            }
        case ECancelled:
            {
            if( iObserver )
                {
                iReadStream.Close();
                iWriteStream.Close();
                // Delete last because it was cancelled
                if ( iOutputFileArray )
                    {
                    iOutputFileArray->Delete( iOutputFileArray->Count() - 1 );
                    }
                iObserver->NotifyEnd();
                iState = EDone;
                }
            break;
            }
        case EDone:
            {
            break;
            }
        }
    }

// ---------------------------------------------------------------------------
// CMRFileManager::RunError
// ---------------------------------------------------------------------------
//
TInt CMRFileManager::RunError( TInt aError )
    {
    if ( aError == KErrEof ) // File has been copied fully
        {
        aError = KErrNone;
        if( iFileArray && iFileArray->Count() > 1 )
            {
            iFileArray->Delete( 0 );

            // Start new file copy op
            TRAP( aError,
                    {
                    PrepareNextFileL();
                    AsyncOp();
                    } )
            }
        else
            {
            if( iObserver )
                {
                iReadStream.Close();
                iWriteStream.Close();

                iObserver->NotifyEnd();
                iState = EDone;
                }
            }
        }

    if ( aError )
        {
        iReadStream.Close();
        iWriteStream.Close();

        if( iObserver )
            {
            iObserver->NotifyError( aError );
            iState = EDone;
            }
        }

    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMRFileManager::DoCancel
// ---------------------------------------------------------------------------
//
void CMRFileManager::DoCancel()
    {
    iReadStream.Close();
    iWriteStream.Close();
    delete iFileArray;
    iFileArray = NULL;
    delete iOutputFileArray;
    iOutputFileArray = NULL;
    iFileIndex = KErrNotFound;
    delete iCurrentFilename;
    iCurrentFilename = NULL;
    delete iTempFilename;
    iTempFilename = NULL;
    }

// ---------------------------------------------------------------------------
// CMRFileManager::AsyncOp
// ---------------------------------------------------------------------------
//
void CMRFileManager::AsyncOp()
    {
    SetActive();
    TRequestStatus *stat = &iStatus;
    User::RequestComplete( stat, KErrNone );
    }

// ---------------------------------------------------------------------------
// CMRFileManager::CopyFileL
// ---------------------------------------------------------------------------
//
void CMRFileManager::CopyFileL()
    {
    iWriteStream.WriteL( iReadStream, KWriteBlockSize );
    }

// ---------------------------------------------------------------------------
// CMRFileManager::CopiedFiles
// ---------------------------------------------------------------------------
//
MDesC16Array& CMRFileManager::CopiedFiles() const
    {
    return *iOutputFileArray;
    }
// End of file