/*

* 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: CMMCScBkupStateArchiveOpPublicDataFiles implementation

*

*

*/

#include "CMMCScBkupStateArchiveOpPublicDataFiles.h"

// System includes

#include <e32std.h>

#include <s32strm.h>

#include <s32mem.h>

// User includes

#include "MMCScBkupLogger.h"

#include "MMCScBkupConfig.h"

#include "CMMCScBkupArchive.h"

#include "CMMCScBkupArchiveFooter.h"

#include "CMMCScBkupIndexPublicDataFiles.h"

#include "MMMCScBkupArchiveDataInterface.h"

#include "CMMCScBkupFileInfo.h"

#include "CMMCScBkupFileListCollection.h"

#include "CMMCScBkupDataOwnerInfo.h"

#include "CMMCScBkupDataOwnerCollection.h"

#include "MMCScBkupOperations.h"

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

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

// CMMCScBkupStateArchiveOpPublicDataFiles::CMMCScBkupStateArchiveOpPublicDataFiles()

// 

// C++ constructor.

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

CMMCScBkupStateArchiveOpPublicDataFiles::CMMCScBkupStateArchiveOpPublicDataFiles( MMMCScBkupDriver& aDriver )

:   CMMCScBkupStateOpAware( aDriver ), iIndexValueCurrent( -1 )

    {

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

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::NewL()

// 

// 

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

CMMCScBkupStateArchiveOpPublicDataFiles* CMMCScBkupStateArchiveOpPublicDataFiles::NewL( MMMCScBkupDriver& aDriver )

    {

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

    return self;

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::StateId()

// 

// 

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

TMMCScBkupStateId CMMCScBkupStateArchiveOpPublicDataFiles::StateId() const

    {

    return KMMCScBkupStateIdArchiveOpPublicDataFiles;

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::NextStateBackupId()

// 

// 

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

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

    {

    return KMMCScBkupStateIdArchiveOpSystemData;

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::NextStateRestoreId()

// 

// 

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

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

    {

    return KMMCScBkupStateIdOperationComplete;

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::PerformStateInitBackupL()

// 

// 

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

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

    {

    __DEBUG_TESTING_SKIP_BACKUP_PUB_DATA;

    CompleteSelf();

    SetState( EStateCommonKickOff );

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::PerformStateInitRestoreL()

// 

// 

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

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

    {

    __DEBUG_TESTING_SKIP_RESTORE_PUB_DATA;

    CompleteSelf();

    SetState( EStateCommonKickOff );

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousStateStepBackupL()

// 

// 

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

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

    {

    const TState justFinishedExecutingState = State();

    //

    switch( justFinishedExecutingState )

        {

    case EStateCommonKickOff:

        CompressingAndWritingFileL();

        break;

    case EStateCommonProcessingFile:

        AddIndexRecordL();

        break;

    case EStateBackupAddIndexRecord:

        SetState( EStateCommonKickOff );

        CompleteSelf();

        break;

    default:

        ASSERT( EFalse );

        break;

        }

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousStateStepRestoreL()

// 

// 

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

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

    {

    const TState justFinishedExecutingState = State();

    //

    switch( justFinishedExecutingState )

        {

    case EStateCommonKickOff:

        DecompressingAndWritingFileL();

        break;

    case EStateCommonProcessingFile:

        RestoreFileAttributesL();

        break;

    case EStateRestoreResetAttributes:

        SetState( EStateCommonKickOff );

        CompleteSelf();

        break;

    default:

        ASSERT( EFalse );

        break;

        }

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousErrorCleanupBackup()

// 

// 

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

TBool CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousErrorCleanupBackup( TBool /*aPartial*/, TInt aError )

    {

    (void) aError;

    __LOG1("CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousErrorCleanupBackup() - **** - error: %d", aError );

    TBool continueProcessing = ETrue;

    // Reset state and move to next item. Treat the current (badly behaving) item

    // as completed/processed.

    const CMMCScBkupFileListCollection& fileList = Driver().DrvFileList();

    if  ( iIndexValueCurrent < fileList.Count() )

        {

        const CMMCScBkupFileInfo& fileInfo = fileList.Entry(iIndexValueCurrent);

        (void) fileInfo;

        __LOGFILE2("CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousErrorCleanupBackup() - **** - error: %d, file: %S - public data skipped", aError, &fileInfo.FileName());

        // Ensures that asynchronous state step is called again..

        CompleteSelf();

        SetState( EStateCommonKickOff );

        }

    return continueProcessing;

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousErrorCleanupRestore()

// 

// 

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

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

    {

    (void) aError;

    __LOG1("CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousErrorCleanupRestore() - **** - error: %d", aError );

    TBool continueProcessing = ETrue;

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

    CMMCScBkupIndexPublicDataFiles& index = static_cast<CMMCScBkupIndexPublicDataFiles&>( footer.IndexByType( EMMCScBkupOwnerDataTypePublicData ) );

    const TInt count = index.Count();

    //

    if  ( iIndexValueCurrent < count )

        {

        // Get the entry to restore

        TMMCScBkupArchiveVector entryInfo;

        const CMMCScBkupFileInfo& fileInfo = index.At( iIndexValueCurrent, entryInfo );

        (void) fileInfo;

        __LOGFILE2("CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousErrorCleanupRestore() - **** - error: %d, file: %S - public data skipped", aError, &fileInfo.FileName());

        // Try to restore the next public file

        //SetState( EStateCommonKickOff );

        SetState( EStateCommonProcessingFile );

        CompleteSelf();

        }

    return continueProcessing;

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousCancellation()

// 

// 

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

void CMMCScBkupStateArchiveOpPublicDataFiles::PerformAsynchronousCancellation()

    {

    switch( State() )

        {

    case EStateCommonProcessingFile:

        // Asynchronous request issued to ADI. 

        Driver().DrvADI().ADIAsynchronousCancel();

        break;

    case EStateCommonKickOff:

    case EStateBackupAddIndexRecord:

    case EStateRestoreResetAttributes:

        // Other states complete this objects own request status => no action

        // needed.

        break;

    default:

    case EStateCommonIdle:

        ASSERT( EFalse );

        }

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::PerformLastRightsBackupL()

// 

// 

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

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

    {

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

    index.StoreL( Driver() );

    Driver().DrvADI().ADIResetResources(EMMCScBkupOperationTypeFullBackup);

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::PerformLastRightsRestoreL()

// 

// 

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

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

    {

    Driver().DrvADI().ADIResetResources(EMMCScBkupOperationTypeFullRestore);

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::CompressingAndWritingFileL()

// 

// 

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

void CMMCScBkupStateArchiveOpPublicDataFiles::CompressingAndWritingFileL()

    {

    const CMMCScBkupFileListCollection& fileList = Driver().DrvFileList();

    const TInt count = fileList.Count();

    //

    if  ( ++iIndexValueCurrent < count )

        {

        const CMMCScBkupFileInfo& fileInfo = fileList.Entry(iIndexValueCurrent);

        __LOG1("CMMCScBkupStateArchiveOpPublicDataFiles::CompressingAndWritingFileL() - BACKUP - compressing file: %S", &fileInfo.FileName());

        // Compress the file & externalise it to the archive

        Driver().DrvADI().ADIWriteFileL( fileInfo.FileName(), iStatus );

        // Indicate the state we are in

        SetActive();

        SetState( EStateCommonProcessingFile );

        }

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::DecompressingAndWritingFileL()

// 

// 

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

void CMMCScBkupStateArchiveOpPublicDataFiles::DecompressingAndWritingFileL()

    {

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

    CMMCScBkupIndexPublicDataFiles& index = static_cast<CMMCScBkupIndexPublicDataFiles&>( footer.IndexByType( EMMCScBkupOwnerDataTypePublicData ) );

    const TInt count = index.Count();

    //

    if  ( ++iIndexValueCurrent < count )

        {

        // Get the entry to restore

        TMMCScBkupArchiveVector entryInfo;

        const CMMCScBkupFileInfo& fileInfo = index.At( iIndexValueCurrent, entryInfo );

        __LOG3("CMMCScBkupStateArchiveOpPublicDataFiles::DecompressingAndWritingFileL() - RESTORE - decompressing file: %S, offset: %8d, length: %8d", &fileInfo.FileName(), entryInfo.Offset(), entryInfo.Length());

        // Restore it!

        Driver().DrvADI().ADIReadFileL( fileInfo.FileName(), entryInfo, iStatus );

        // Indicate the state we are in

        SetActive();

        SetState( EStateCommonProcessingFile );

        }

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::AddIndexRecordL()

// 

// 

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

void CMMCScBkupStateArchiveOpPublicDataFiles::AddIndexRecordL()

    {

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

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

    CMMCScBkupIndexPublicDataFiles& index = static_cast<CMMCScBkupIndexPublicDataFiles&>(footer.IndexByType(EMMCScBkupOwnerDataTypePublicData));

    const CMMCScBkupFileListCollection& fileList = Driver().DrvFileList();

    const CMMCScBkupFileInfo& fileInfo = fileList.Entry(iIndexValueCurrent);

    // Save the offset of the data owner

    const TMMCScBkupArchiveVector& info = Driver().DrvADI().ADICurrentArchiveVectorInfo();

    index.AddIndexRecordL( info, fileInfo );

    // And update the file info so that we can know how much compressed

    // data must be read during restore. This allows us to report accurate 

    // progress info. See CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL()

    // for the point when the public data size is zeroed.

    // First, find the associated data owner.

    CMMCScBkupDataOwnerInfo& owner = dataOwners.OwnerL( fileInfo.SecureId() );

    __LOG3("CMMCScBkupStateArchiveOpPublicDataFiles::AddIndexRecordL() - offset: %6d, length: %6d, file: %S", info.Offset(), info.Length(), &fileInfo.FileName());

    // Indicate the state we are in

    SetState( EStateBackupAddIndexRecord );

    CompleteSelf();

    }

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

// CMMCScBkupStateArchiveOpPublicDataFiles::RestoreFileAttributesL()

// 

// 

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

void CMMCScBkupStateArchiveOpPublicDataFiles::RestoreFileAttributesL()

    {

    RFs& fsSession = Driver().DrvADI().ADIFsSession();

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

    CMMCScBkupIndexPublicDataFiles& index = static_cast<CMMCScBkupIndexPublicDataFiles&>( footer.IndexByType( EMMCScBkupOwnerDataTypePublicData ) );

    // Get the entry who's attributes need restoring

    TMMCScBkupArchiveVector entryInfo;

    const CMMCScBkupFileInfo& fileInfo = index.At( iIndexValueCurrent, entryInfo );

    // If file is in Photo Album Thumbnail folder

    // or file in videocenter folder and its subfolders

    if  ( fileInfo.FileName().MatchF( KMMCScBkupMediaGalleryThumbnailFolder ) != KErrNotFound ) 

        {

        // Get folder path length

        const TChar backslash('\\');

        const TInt pathlength = fileInfo.FileName().LocateReverseF( backslash ) + 1;

        // Set hidden attribute for Thumbnail folder.

        // If folder does not exist, create it

        fsSession.SetAtt( fileInfo.FileName().Left( pathlength ), KEntryAttHidden, KEntryAttNormal );

        }

    if  ( fileInfo.FileName().MatchF( KMMCScBkupVideoCenterFolder ) != KErrNotFound) 

        {

        // Get folder path length

        const TChar backslash('\\');

        const TInt pathlength = fileInfo.FileName().LocateReverseF( backslash ) + 1;

        // Set hidden attribute for the video center's sub folder.

        // If foler does not exist, create it

        fsSession.SetAtt( fileInfo.FileName().Left( pathlength ), KEntryAttHidden, KEntryAttNormal );

        //Manually set the videocenter main folder to be hidden

        fsSession.SetAtt( KMMCScBkupVideoCenterFolderPath, KEntryAttHidden, KEntryAttNormal );

        }

    // Set the original attributes, clear the others

    const TInt error = fsSession.SetEntry( fileInfo.FileName(), 

                                           fileInfo.DateTime(), 

                                           fileInfo.Attributes(), 

                                          !fileInfo.Attributes() );

    (void) error;

    // Indicate the state we are in

    SetState( EStateRestoreResetAttributes );

    CompleteSelf();

    }