/*

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

*

*

*/

#include "CMMCScBkupArchiveDataManager.h"

// System includes

#include <ezcompressor.h>

#include <ezdecompressor.h>

// User includes

#include "MMCScBkupLogger.h"

#include "RMMCScBkupArchiveStreams.h"

#include "MMCScBkupOperations.h"

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

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

// CMMCScBkupArchiveDataManager::CMMCScBkupArchiveDataManager()

// 

// C++ constructor.

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

CMMCScBkupArchiveDataManager::CMMCScBkupArchiveDataManager( RFs& aFsSession, RFile64& aFile, MMMCScBkupProgressObserver& aProgressManager )

:   CActive( CActive::EPriorityIdle ), iFsSession( aFsSession ), iFile( aFile ), iProgressManager( aProgressManager )

    {

    __LOG1("CMMCScBkupArchiveDataManager::CMMCScBkupArchiveDataManager() - START - aFile: 0x%08x", aFile.SubSessionHandle() );

    CActiveScheduler::Add(this);

    }

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

// CMMCScBkupArchiveDataManager::~CMMCScBkupArchiveDataManager()

// 

// Destructor.

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

CMMCScBkupArchiveDataManager::~CMMCScBkupArchiveDataManager()

    {

    Cancel();

    //

    iWriteStream.Close();

    //

    delete iCompressor;

    delete iDecompressor;

    delete iBufferManager;

    }

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

// CMMCScBkupArchiveDataManager::ConstructL()

// 

// 

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

void CMMCScBkupArchiveDataManager::ConstructL()

    {

    TInt64 size = 0;

    User::LeaveIfError( iFile.Size( size ) );

    //

    iOverallArchiveVectorInfo.SetOffset( 0 );

    iOverallArchiveVectorInfo.SetLength( size );

    }

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

// CMMCScBkupArchiveDataManager::NewL()

// 

// 

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

CMMCScBkupArchiveDataManager* CMMCScBkupArchiveDataManager::NewL( RFs& aFsSession, RFile64& aFile, MMMCScBkupProgressObserver& aProgressManager )

    {

    CMMCScBkupArchiveDataManager* self = new(ELeave) CMMCScBkupArchiveDataManager( aFsSession, aFile, aProgressManager );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CMMCScBkupArchiveDataManager::CurrentOffsetL()

// 

// 

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

TInt CMMCScBkupArchiveDataManager::CurrentOffsetL() const

    {

    TInt offset = CurrentOffset();

    User::LeaveIfError(offset);

    return offset;

    }

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

// CMMCScBkupArchiveDataManager::CurrentOffset()

// 

// 

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

TInt CMMCScBkupArchiveDataManager::CurrentOffset() const

    {

    TInt64 offsetOrError = 0;

    TInt error = iFile.Seek( ESeekCurrent, offsetOrError );

    //

    if  (error != KErrNone)

        {

        offsetOrError = error;

        }

    //

    return offsetOrError;

    }

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

// CMMCScBkupArchiveDataManager::SetCurrentVector()

// 

// 

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

void CMMCScBkupArchiveDataManager::SetCurrentVector( const TMMCScBkupArchiveVector& aVector )

    {

    iCurrentVectorInfo = aVector;

    }

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

// CMMCScBkupArchiveDataManager::ADIFsSession()

// 

// 

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

RFs& CMMCScBkupArchiveDataManager::ADIFsSession() const

    {

    return iFsSession;

    }

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

// CMMCScBkupArchiveDataManager::ADIRawArchiveFile()

// 

// 

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

RFile64& CMMCScBkupArchiveDataManager::ADIRawArchiveFile() const

    {

    return iFile;

    }

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

// CMMCScBkupArchiveDataManager::ADICurrentArchiveVectorInfo()

// 

// 

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

const TMMCScBkupArchiveVector& CMMCScBkupArchiveDataManager::ADICurrentArchiveVectorInfo() const

    {

    return iCurrentVectorInfo;

    }

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

// CMMCScBkupArchiveDataManager::ADIOverallArchiveVectorInfo()

// 

// 

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

const TMMCScBkupArchiveVector& CMMCScBkupArchiveDataManager::ADIOverallArchiveVectorInfo() const

    {

    return iOverallArchiveVectorInfo;

    }

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

// CMMCScBkupArchiveDataManager::ADIWriteStreamUncompressedLC()

// 

// 

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

RWriteStream& CMMCScBkupArchiveDataManager::ADIWriteStreamUncompressedLC( TInt aPos )

    {

    __LOG1("CMMCScBkupArchiveDataManager::ADIWriteStreamUncompressedLC() - START - aPos: %d", aPos );

    //

    __ASSERT_ALWAYS( !iWriteStream.IsOpen(), User::Invariant() );

    TInt offset = aPos;

    if  (offset == KMMCScBkupArchiveWriteStreamCurrentPos)

        {

        offset = CurrentOffsetL();

        __LOG1("CMMCScBkupArchiveDataManager::ADIWriteStreamUncompressedLC() - current offset is: %d", offset );

        }

    //

    iWriteStream.OpenLC(*this, iFile, offset);

    __LOG("CMMCScBkupArchiveDataManager::ADIWriteStreamUncompressedLC() - END - stream opened and pushed");

    iCurrentVectorInfo.Reset();

    return iWriteStream;

    }

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

// CMMCScBkupArchiveDataManager::ADIReadStreamUncompressedLC()

// 

// 

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

RReadStream& CMMCScBkupArchiveDataManager::ADIReadStreamUncompressedLC( TInt aPos )

    {

    __ASSERT_ALWAYS( !iReadStream.IsOpen(), User::Invariant() );

    TInt offset = aPos;

    if  (offset == KMMCScBkupArchiveReadStreamCurrentPos)

        {

        offset = CurrentOffsetL();

        }

    //

    iReadStream.OpenLC(*this, iFile, offset);

    iCurrentVectorInfo.Reset();

    return iReadStream;

    }

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

// CMMCScBkupArchiveDataManager::ADIWriteL()

// 

// 

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

const TMMCScBkupArchiveVector& CMMCScBkupArchiveDataManager::ADIWriteL( const TDesC8& aData )

    {

    const TInt offset = CurrentOffsetL();

    const TInt error = iFile.Write( aData );

    User::LeaveIfError(error);

#ifdef RD_FILE_MANAGER_BACKUP

    CalculateCrc(aData.Ptr(), aData.Length());

#endif

    //

    iCurrentVectorInfo.SetOffset( offset );

    iCurrentVectorInfo.SetLength( aData.Length() );

    //

    return iCurrentVectorInfo;

    }

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

// CMMCScBkupArchiveDataManager::ADIReadL()

// 

// 

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

const TMMCScBkupArchiveVector& CMMCScBkupArchiveDataManager::ADIReadL( TDes8& aSink, const TMMCScBkupArchiveVector& aInfo )

    {

    TMMCScBkupArchiveVector readInfo(aInfo);

    // Read straight into aSink.

    const TInt maxLength = aSink.MaxLength();

    if  (aInfo.Length() > maxLength)

        {

        readInfo.SetLength( maxLength );

        }

    aSink.Zero();

    const TInt error = iFile.Read( static_cast<TInt64>(readInfo.Offset()), aSink, readInfo.Length() );

    User::LeaveIfError( error );

    //

    iCurrentVectorInfo.SetOffset( readInfo.Offset() );

    iCurrentVectorInfo.SetLength( aSink.Length() );

    //

    return iCurrentVectorInfo;

    }

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

// CMMCScBkupArchiveDataManager::ADIWriteFileL()

// 

// 

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

void CMMCScBkupArchiveDataManager::ADIWriteFileL( const TDesC& aSourceFileName, TRequestStatus& aStatus )

    {

    __LOG1("CMMCScBkupArchiveDataManager::ADIWriteFileL() - START - file: %S", &aSourceFileName);

    if  (!iBufferManager || iBufferManager->Type() != CMMCScBkupBufferManagerBase::ETypeFileToArchive)

        {

        CMMCScBkupBufferManagerBase* bm = 

            CMMCScBkupBufferManagerBase::NewByTypeL(

                    CMMCScBkupBufferManagerBase::ETypeFileToArchive, 

                    iProgressManager,

                    *this, 

                    (TAny*) &aSourceFileName);

        //

        delete iBufferManager;

        iBufferManager = bm;

        }

    else

        {

        iBufferManager->InitializeL( (TAny*) &aSourceFileName );

        }

    // Setup our observer & op

    SetOperation(EOperationCompressing);

    SetObserver(aStatus);

    // Compressing aData to the archive file

    EnsureCompressorExistsL(*iBufferManager);

    // Do the compression asynchronously

    CompleteSelf();

    __LOG("CMMCScBkupArchiveDataManager::ADIWriteFileL() - END");

    }

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

// CMMCScBkupArchiveDataManager::ADIReadFileL()

// 

// 

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

void CMMCScBkupArchiveDataManager::ADIReadFileL( const TDesC& aDestinationFileName, const TMMCScBkupArchiveVector& aInfo, TRequestStatus& aStatus )

    {

    __LOG3("CMMCScBkupArchiveDataManager::ADIReadFileL() - START - file: %S, offset: %8d, length: %8d", &aDestinationFileName, aInfo.Offset(), aInfo.Length());

    if  (!iBufferManager || iBufferManager->Type() != CMMCScBkupBufferManagerBase::ETypeArchiveToFile)

        {

        CMMCScBkupBufferManagerBase* bm = 

            CMMCScBkupBufferManagerBase::NewByTypeL(

                    CMMCScBkupBufferManagerBase::ETypeArchiveToFile, 

                    iProgressManager,

                    *this, 

                    (TAny*) &aDestinationFileName,

                    (TAny*) &aInfo );

        //

        delete iBufferManager;

        iBufferManager = bm;

        }

    else

        {

        iBufferManager->InitializeL( (TAny*) &aDestinationFileName, (TAny*) &aInfo );

        }

    // Setup our observer & op

    SetOperation(EOperationDecompressing);

    SetObserver(aStatus);

    // Compressing aData to the archive file

    EnsureDecompressorExistsL(*iBufferManager);

    // Do the compression asynchronously

    CompleteSelf();

    __LOG("CMMCScBkupArchiveDataManager::ADIReadFileL() - END");

    }

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

// CMMCScBkupArchiveDataManager::ADIWriteCompressedL()

// 

// 

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

void CMMCScBkupArchiveDataManager::ADIWriteCompressedL( const TDesC8& aData, TRequestStatus& aStatus )

    {

    if  (!iBufferManager || iBufferManager->Type() != CMMCScBkupBufferManagerBase::ETypeDescriptorToArchive)

        {

        CMMCScBkupBufferManagerBase* bm = 

            CMMCScBkupBufferManagerBase::NewByTypeL(

                    CMMCScBkupBufferManagerBase::ETypeDescriptorToArchive, 

                    iProgressManager,

                    *this, 

                    (TAny*) &aData );

        //

        delete iBufferManager;

        iBufferManager = bm;

        }

    else

        {

        iBufferManager->InitializeL( (TAny*) &aData );

        }

    // Setup our observer & op

    SetOperation(EOperationCompressing);

    SetObserver(aStatus);

    // Compressing aData to the archive file

    EnsureCompressorExistsL(*iBufferManager);

    // Do the compression asynchronously

    CompleteSelf();

    }

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

// CMMCScBkupArchiveDataManager::ADIReadDecompressedL()

// 

// 

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

void CMMCScBkupArchiveDataManager::ADIReadDecompressedL( TDes8& aSink, const TMMCScBkupArchiveVector& aInfo, TRequestStatus& aStatus )

    {

    if  (!iBufferManager || iBufferManager->Type() != CMMCScBkupBufferManagerBase::ETypeArchiveToDescriptor)

        {

        CMMCScBkupBufferManagerBase* bm = 

            CMMCScBkupBufferManagerBase::NewByTypeL(

                    CMMCScBkupBufferManagerBase::ETypeArchiveToDescriptor, 

                    iProgressManager,

                    *this, 

                    (TAny*) &aSink,

                    (TAny*) &aInfo  );

        //

        delete iBufferManager;

        iBufferManager = bm;

        }

    else

        {

        iBufferManager->InitializeL( (TAny*) &aSink, (TAny*) &aInfo );

        }

    // Setup our observer & op

    SetOperation(EOperationDecompressing);

    SetObserver(aStatus);

    // Compressing aData to the archive file

    EnsureDecompressorExistsL(*iBufferManager);

    // Do the compression asynchronously

    CompleteSelf();

    }

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

// CMMCScBkupArchiveDataManager::ADIAsynchronousCancel()

// 

// 

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

void CMMCScBkupArchiveDataManager::ADIAsynchronousCancel()

    {

    Cancel();

    }

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

// CMMCScBkupArchiveDataManager::ADIResetResources()

// 

// 

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

void CMMCScBkupArchiveDataManager::ADIResetResources(TMMCScBkupOperationType /* aType */)

    {

    __LOG("CMMCScBkupArchiveDataManager::ADIResetResources()");

    delete iCompressor;

    iCompressor = NULL;

    delete iDecompressor;

    iDecompressor = NULL;

    delete iBufferManager;

    iBufferManager = NULL;

    }

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

// CMMCScBkupArchiveDataManager::EnsureCompressorExistsL()

// 

// 

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

void CMMCScBkupArchiveDataManager::EnsureCompressorExistsL( MEZBufferManager& aBufferManager )

    {

    delete iDecompressor;

    iDecompressor = NULL;

    //

    if  (iCompressor == NULL)

        {

        iCompressor = CEZCompressor::NewL( aBufferManager );

        }

    else

        {

        iCompressor->ResetL(aBufferManager);

        }

    }

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

// CMMCScBkupArchiveDataManager::EnsureDecompressorExistsL()

// 

// 

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

void CMMCScBkupArchiveDataManager::EnsureDecompressorExistsL( MEZBufferManager& aBufferManager )

    {

    delete iCompressor;

    iCompressor = NULL;

    //

    if  (iDecompressor == NULL)

        {

        iDecompressor = CEZDecompressor::NewL( aBufferManager );

        }

    else

        {

        iDecompressor->ResetL(aBufferManager);

        }

    }

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

// CMMCScBkupArchiveDataManager::SetObserver()

// 

// 

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

void CMMCScBkupArchiveDataManager::SetObserver( TRequestStatus& aStatus )

    {

    __ASSERT_DEBUG(iObserverStatus == NULL, User::Invariant());

    iObserverStatus = &aStatus;

    *iObserverStatus = KRequestPending;

    }

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

// CMMCScBkupArchiveDataManager::CompleteSelf()

// 

// 

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

void CMMCScBkupArchiveDataManager::CompleteSelf( TInt aCompletionCode )

    {

    SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, aCompletionCode);

    }

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

// CMMCScBkupArchiveDataManager::CompleteObserver(()