/*

* 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: CMMCScBkupArchiveFooter Implementation

*

*

*/

#include "CMMCScBkupArchiveFooter.h"

// User includes

#include "CMMCScBkupIndexPublicDataFiles.h"

#include "CMMCScBkupIndexDataOwners.h"

#include "CMMCScBkupIndexJavaData.h"

#include "CMMCScBkupIndexSystemData.h"

#include "CMMCScBkupIndexActiveData.h"

#include "CMMCScBkupIndexJavaData.h"

#include "CMMCScBkupIndexPassiveData.h"

#include "MMMCScBkupArchiveDataInterface.h"

#include "CMMCScBkupDataOwnerInfo.h"

#include "MMCScBkupArchiveUtils.h"

#include "CMMCScBkupDataOwnerCollection.h"

/**

    UNDERSTANDING ARCHIVE FOOTER

    ============================

    // Indicies are:

    //

    // EMMCScBkupOwnerDataTypeDataOwner

    // EMMCScBkupOwnerDataTypeJavaData

    // EMMCScBkupOwnerDataTypePublicData

    // EMMCScBkupOwnerDataTypeSystemData

    // EMMCScBkupOwnerDataTypeActiveData

    // EMMCScBkupOwnerDataTypePassiveData

    //

    //  6 (index objects) *

    //  ( 1 byte for object type + TMMCScBkupArchiveVector::ExternalizedSize() )

    //

    // THIS IS THE SIZE OF AN INDIVIDUAL "INDEX RECORD POINTER"

    const TInt indexDataSize = 1 // index type

        + TMMCScBkupArchiveVector::ExternalizedSize() // vector

        + 4 // spare1

        + 4 // spare2

        ;

    // THIS IS THE TOTAL SIZE OF ALL "INDEX RECORD POINTERS"

    const TInt sizeOfAllIndicies = 

          4 // stream format version

        + 4 // spare1

        + 4 // spare2

        + 4 // spare3

        + 4 // spare4

        + 4 // index object count

        + ( EMMCScBkupOwnerDataTypeCount * indexDataSize);

    // WE ALSO WRITE THE AMOUNT OF DISK SPACE REQUIRED FOR EACH DRIVE

    // IN ORDER TO RESTORE THE ARCHIVE

    (not included here)

*/

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

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

// CMMCScBkupArchiveFooter::CMMCScBkupArchiveFooter()

// 

// C++ constructor.

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

CMMCScBkupArchiveFooter::CMMCScBkupArchiveFooter( MMMCScBkupArchiveDataInterface& aDataInterface, MMMCScBkupDriver& aDriver )

:   iDataInterface( aDataInterface ), iDriver( aDriver )

    {

    }

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

// CMMCScBkupArchiveFooter::~CMMCScBkupArchiveFooter()

// 

// Destructor.

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

CMMCScBkupArchiveFooter::~CMMCScBkupArchiveFooter()

    {

    iIndicies.Close();

    }

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

// CMMCScBkupArchiveFooter::ConstructL()

// 

// 

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

void CMMCScBkupArchiveFooter::ConstructL()

    {

    CMMCScBkupIndexBase* index = NULL;

    //

    index = CMMCScBkupIndexDataOwners::NewLC();

    iIndicies.AppendL(index);

    CleanupStack::Pop(index);

    //

    index = CMMCScBkupIndexPublicDataFiles::NewLC();

    iIndicies.AppendL(index);

    CleanupStack::Pop(index);

    //

    index = CMMCScBkupIndexSystemData::NewLC();

    iIndicies.AppendL(index);

    CleanupStack::Pop(index);

    //

    index = CMMCScBkupIndexJavaData::NewLC();

    iIndicies.AppendL(index);

    CleanupStack::Pop(index);

    //

    index = CMMCScBkupIndexActiveData::NewLC();

    iIndicies.AppendL(index);

    CleanupStack::Pop(index);

    //

    index = CMMCScBkupIndexPassiveData::NewLC();

    iIndicies.AppendL(index);

    CleanupStack::Pop(index);

    }

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

// CMMCScBkupArchiveFooter::NewL()

// 

// 

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

CMMCScBkupArchiveFooter* CMMCScBkupArchiveFooter::NewL( MMMCScBkupArchiveDataInterface& aDataInterface, MMMCScBkupDriver& aDriver )

    {

    CMMCScBkupArchiveFooter* self = new(ELeave) CMMCScBkupArchiveFooter( aDataInterface, aDriver );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CMMCScBkupArchiveFooter::IndexByType()

// 

// 

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

CMMCScBkupIndexBase& CMMCScBkupArchiveFooter::IndexByType( TMMCScBkupOwnerDataType aType )

    {

    CMMCScBkupIndexBase* ret = IndexByTypeOrNull( aType );

    __ASSERT_ALWAYS(ret != NULL, User::Invariant());

    return *ret;

    }

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

// CMMCScBkupArchiveFooter::IndexByTypeOrNull()

// 

// 

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

CMMCScBkupIndexBase* CMMCScBkupArchiveFooter::IndexByTypeOrNull( TMMCScBkupOwnerDataType aType )

    {

    CMMCScBkupIndexBase* ret = NULL;

    //

    const TInt count = iIndicies.Count();

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

        {

        CMMCScBkupIndexBase* entry = iIndicies[i];

        if  (entry->Type() == aType)

            {

            ret = entry;

            break;

            }

        }

    //

    return ret;

    }

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

// CMMCScBkupArchiveFooter::StoreL()

// 

// 

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

void CMMCScBkupArchiveFooter::StoreL()

    {

    RWriteStream stream( iDataInterface.ADIWriteStreamUncompressedLC() );

    //    

    const TInt count = iIndicies.Count();

    __ASSERT_DEBUG( count == EMMCScBkupOwnerDataTypeCount, User::Invariant());

    // NEW: write index version

    stream.WriteInt32L( EStreamFormatVersion1 );

    // NEW: spare1, spare2, spare3, spare4

    stream.WriteInt32L( 0 );

    stream.WriteInt32L( 0 );

    stream.WriteInt32L( 0 );

    stream.WriteInt32L( 0 );

    // NEW: write the number of indicies...

    stream.WriteInt32L( count );

    // ...then write each index in turn...

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

        {

        // First write the index type...

        const CMMCScBkupIndexBase& index = *iIndicies[i];

        stream.WriteInt8L( index.Type() );

        // Then write its offset (and length)

        const TMMCScBkupArchiveVector& vector = index.Vector();

        stream << vector;

        // NEW: Then write spare bytes for each index record

        stream.WriteInt32L( 0 ); // per-index spare1

        stream.WriteInt32L( 0 ); // per-index spare2

        }

    // NEW: write the amount of disk space required for each drive as

    // part of the footer information

    CMMCScBkupDataOwnerCollection& dataOwners = iDriver.DrvDataOwners();

    dataOwners.CalculateDiskSpaceRequiredForRestoreL();

    stream << dataOwners;

    // Tidy up...

    stream.CommitL();

    CleanupStack::PopAndDestroy(); // stream

#ifdef RD_FILE_MANAGER_BACKUP

    // Disable crc-calculation for header data. Header crc'd separately

    iDataInterface.ADIActivateCrcCalculation(EFalse);

#endif

    // We can now update the header with the total length of the footer, validation bits and crcs

    const TMMCScBkupArchiveVector& finalWriteInfo = iDataInterface.ADICurrentArchiveVectorInfo();

    MMCScBkupArchiveUtils::SetFooterLengthL( iDataInterface.ADIRawArchiveFile(), finalWriteInfo.Length() );

    MMCScBkupArchiveUtils::SetArchiveContentAsValidL( iDataInterface.ADIRawArchiveFile() );

#ifdef RD_FILE_MANAGER_BACKUP

    MMCScBkupArchiveUtils::SetArchiveCrcsL( iDataInterface.ADIRawArchiveFile(), iDataInterface.ADIArchiveCrc() );

#endif

    }

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

// CMMCScBkupArchiveFooter::RestoreL()

// 

// 

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

void CMMCScBkupArchiveFooter::RestoreL( TInt aCalculatedFooterOffsetWithinArchive )

    {

    RReadStream stream( iDataInterface.ADIReadStreamUncompressedLC( aCalculatedFooterOffsetWithinArchive ) );

    // NEW: Read stream format

    stream.ReadInt32L(); // EStreamFormatVersion1 

    // NEW: spare1, spare2, spare3, spare4

    stream.ReadInt32L();

    stream.ReadInt32L();

    stream.ReadInt32L();

    stream.ReadInt32L();

    // NEW: Read written index count

    const TInt inMemoryIndexCount = iIndicies.Count();

    const TInt archiveIndexCount = stream.ReadInt32L();

    if  ( archiveIndexCount > inMemoryIndexCount )

        {

        // Something wrong with file format version info?

        User::Leave( KErrCorrupt );

        }

    // Read index offsets

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

        {

        // We only read the offset & length information. 

        // The actual respective index restoration is done by other

        // objects as a result of other states

        const TMMCScBkupOwnerDataType type = static_cast< TMMCScBkupOwnerDataType >( stream.ReadInt8L() );

        //

        if  ( type < 0 || type >= EMMCScBkupOwnerDataTypeCount )

            {

            User::Leave( KErrCorrupt );

            }

        else

            {

            // Always read the vector info (in order to keep the stream

            // position inline with the externalised representation)

            TMMCScBkupArchiveVector vector;

            stream >> vector;

            // NEW: Then read spare bytes for each index record

            stream.ReadInt32L(); // per-index spare1

            stream.ReadInt32L(); // per-index spare2

            // But only prepare the index if we have a similar type..

            CMMCScBkupIndexBase* index = IndexByTypeOrNull( type );

            //

            if  ( index )

                {

                index->SetVector( vector );

                }

            }

        }

    // NEW: read the amount of disk space required for each drive as

    // part of the footer information

    CMMCScBkupDataOwnerCollection& dataOwners = iDriver.DrvDataOwners();

    stream >> dataOwners;

    //

    CleanupStack::PopAndDestroy(); // stream

    }