/*

* Copyright (c) 2005-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: CMMCScBkupStateArchiveOpDataOwners implementation

*

*

*/

#include "CMMCScBkupStateArchiveOpDataOwners.h"

// System includes

#include <e32std.h>

#include <s32strm.h>

#include <s32mem.h>

// User includes

#include "MMCScBkupLogger.h"

#include "CMMCScBkupArchive.h"

#include "RMMCScBkupProgressSizer.h"

#include "CMMCScBkupArchiveFooter.h"

#include "CMMCScBkupDataOwnerInfo.h"

#include "CMMCScBkupIndexDataOwners.h"

#include "MMMCScBkupProgressObserver.h"

#include "CMMCScBkupDataOwnerCollection.h"

#include "MMMCScBkupArchiveDataInterface.h"

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

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

// CMMCScBkupStateArchiveOpDataOwners::CMMCScBkupStateArchiveOpDataOwners()

// 

// C++ constructor.

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

CMMCScBkupStateArchiveOpDataOwners::CMMCScBkupStateArchiveOpDataOwners( MMMCScBkupDriver& aDriver )

:   CMMCScBkupStateOpAware( aDriver ), iIndexValueCurrent( -1 )

    {

    __LOG1("CMMCScBkupStateArchiveOpDataOwners::CMMCScBkupStateArchiveOpDataOwners() - 0x%08x", StateId().iUid );

    }

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

// CMMCScBkupStateArchiveOpDataOwners::~CMMCScBkupStateArchiveOpDataOwners()

// 

// Destructor.

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

CMMCScBkupStateArchiveOpDataOwners::~CMMCScBkupStateArchiveOpDataOwners()

    {

    Cancel();

    }

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

// CMMCScBkupStateArchiveOpDataOwners::NewL()

// 

// 

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

CMMCScBkupStateArchiveOpDataOwners* CMMCScBkupStateArchiveOpDataOwners::NewL( MMMCScBkupDriver& aDriver )

    {

    CMMCScBkupStateArchiveOpDataOwners* self = new(ELeave) CMMCScBkupStateArchiveOpDataOwners( aDriver );

    return self;

    }

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

// CMMCScBkupStateArchiveOpDataOwners::StateId()

// 

// 

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

TMMCScBkupStateId CMMCScBkupStateArchiveOpDataOwners::StateId() const

    {

    return KMMCScBkupStateIdArchiveOpDataOwners;

    }

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

// CMMCScBkupStateArchiveOpDataOwners::NextStateBackupId()

// 

// 

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

TMMCScBkupStateId CMMCScBkupStateArchiveOpDataOwners::NextStateBackupId( TBool /*aPartial*/ ) const

    {

    return KMMCScBkupStateIdArchiveOpArchiveFooter;

    }

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

// CMMCScBkupStateArchiveOpDataOwners::NextStateRestoreId()

// 

// 

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

TMMCScBkupStateId CMMCScBkupStateArchiveOpDataOwners::NextStateRestoreId( TBool /*aPartial*/ ) const

    {

    return KMMCScBkupStateIdValidateDiskSpace;

    }

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

// CMMCScBkupStateArchiveOpDataOwners::PerformStateInitBackupL()

// 

// 

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

void CMMCScBkupStateArchiveOpDataOwners::PerformStateInitBackupL( TBool /*aPartial*/ )

    {

    // Work is carried out inside asynchronous step

    CompleteSelf();

    }

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

// CMMCScBkupStateArchiveOpDataOwners::PerformStateInitRestoreL()

// 

// 

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

void CMMCScBkupStateArchiveOpDataOwners::PerformStateInitRestoreL( TBool /*aPartial*/ )

    {

    // Restore each data owner asynchronously

    CompleteSelf();

    }

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

// CMMCScBkupStateArchiveOpDataOwners::PerformAsynchronousStateStepBackupL()

// 

// 

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

void CMMCScBkupStateArchiveOpDataOwners::PerformAsynchronousStateStepBackupL( TBool /*aPartial*/ )

    {

    CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();

    CMMCScBkupArchiveFooter& footer = Driver().DrvArchive().Footer();

    CMMCScBkupIndexBase& indexBase = footer.IndexByType(EMMCScBkupOwnerDataTypeDataOwner);

    CMMCScBkupIndexDataOwners& index = static_cast< CMMCScBkupIndexDataOwners& >( indexBase );

    const TInt count = dataOwners.Count();

    //

    if  ( ++iIndexValueCurrent < count )

        {

        CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( iIndexValueCurrent );

        // Externalise 

        MMMCScBkupArchiveDataInterface& archiveDataInterface = ADI();

        RWriteStream stream( archiveDataInterface.ADIWriteStreamUncompressedLC() );

        stream << owner;

        stream.CommitL();

        CleanupStack::PopAndDestroy(); // stream

        // Save the offset of the data owner

        const TMMCScBkupArchiveVector& info = archiveDataInterface.ADICurrentArchiveVectorInfo();

        index.AddIndexRecordL( info );

        // Now move on to the next data owner

        CompleteSelf();

        }

    }

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

// CMMCScBkupStateArchiveOpDataOwners::PerformAsynchronousStateStepRestoreL()

// 

// 

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

void CMMCScBkupStateArchiveOpDataOwners::PerformAsynchronousStateStepRestoreL( TBool /*aPartial*/ )

    {

    CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();

    CMMCScBkupArchiveFooter& footer = Driver().DrvArchive().Footer();

    CMMCScBkupIndexBase& indexBase = footer.IndexByType( EMMCScBkupOwnerDataTypeDataOwner );

    CMMCScBkupIndexDataOwners& index = static_cast< CMMCScBkupIndexDataOwners& >( indexBase );

    const TInt count = index.Count();

    __LOG1( "CMMCScBkupStateArchiveOpDataOwners::PerformAsynchronousStateStepRestoreL() - %d data owner index records...", count );

    //

    if  ( ++iIndexValueCurrent < count )

        {

        const TMMCScBkupArchiveVector& entry = index.At( iIndexValueCurrent );

        __LOG3( "CMMCScBkupStateArchiveOpDataOwners::PerformAsynchronousStateStepRestoreL() - entry[%03d] at offset: 0x%08x, length: %4d", iIndexValueCurrent, entry.Offset(), entry.Length() );

        MMMCScBkupArchiveDataInterface& archiveDataInterface = ADI();

        RReadStream stream( archiveDataInterface.ADIReadStreamUncompressedLC( entry.Offset() ) );

        // Internalize a new entry and add it to the data owner collection

        CMMCScBkupDataOwnerInfo* dataOwner = CMMCScBkupDataOwnerInfo::NewLC( stream );

        dataOwners.AppendL( dataOwner );

        CleanupStack::Pop( dataOwner );

        // Tidy up & check that we didn't read too much - oops

        const TMMCScBkupArchiveVector& readInfo = archiveDataInterface.ADICurrentArchiveVectorInfo();

        if  ( readInfo.Length() > entry.Length() )

            {

            __LOG( "CMMCScBkupStateArchiveOpDataOwners::PerformAsynchronousStateStepRestoreL() - ERROR - Read too much data! -> leave with KErrCorrupt" );

            User::Leave( KErrCorrupt );

            }

        CleanupStack::PopAndDestroy(); // stream

        // Continue to next entry

        CompleteSelf();

        }

    }

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

// CMMCScBkupStateArchiveOpDataOwners::PerformLastRightsBackupL()

// 

// 

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

void CMMCScBkupStateArchiveOpDataOwners::PerformLastRightsBackupL( TBool /*aPartial*/ )

    {

    CMMCScBkupIndexBase& index = Driver().DrvArchive().Footer().IndexByType( EMMCScBkupOwnerDataTypeDataOwner );

    index.StoreL( Driver() );

    }

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

// CMMCScBkupStateArchiveOpDataOwners::PerformLastRightsRestoreL()

// 

// 

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

void CMMCScBkupStateArchiveOpDataOwners::PerformLastRightsRestoreL( TBool /*aPartial*/ )

    {

    // Calculate restore byte size (for all drives)

    CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();

    const TInt64 totalDataRestoreSize = dataOwners.TotalOperationalSizeL();

    // Inform progress manager

    if(Driver().DrvLastCategory())

        {

        __LOG2("CMMCScBkupStateArchiveOpDataOwners::PerformLastRightsRestoreL() - report progress understood (%Ld + %Ld)", 

            totalDataRestoreSize, Driver().DrvTotalProgress());

        Driver().DrvProgressHandler().MMCScBkupHandleProgressDomainUnderstood( totalDataRestoreSize + Driver().DrvTotalProgress());

        }

    else

        {

        __LOG2("CMMCScBkupStateArchiveOpDataOwners::PerformLastRightsRestoreL() - adding progress amount %Ld to existing %Ld)", 

            totalDataRestoreSize, Driver().DrvTotalProgress());

        Driver().DrvStoreTotalProgress( totalDataRestoreSize );

        }

    }

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

// CMMCScBkupStateArchiveOpDataOwners::PerformAsynchronousErrorCleanupRestore()

// 

// 

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

TBool CMMCScBkupStateArchiveOpDataOwners::PerformAsynchronousErrorCleanupRestore( TBool /*aPartial*/, TInt aError )

    {

    (void) aError;

    __LOGFILE1("CMMCScBkupStateArchiveOpDataOwners::PerformAsynchronousErrorCleanupRestore() - **** - error: %d", aError );

    // Just try to skip the data owner. 

    CompleteSelf();

    return ETrue;

    }