/*
* 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: CMMCScBkupStateArchiveOpSystemData implementation
*
*
*/

#include "CMMCScBkupStateArchiveOpSystemData.h"

// User includes
#include "MMCScBkupLogger.h"
#include "CMMCScBkupDataOwnerCollection.h"
#include "CMMCScBkupDataOwnerInfo.h"
#include "MMCScBkupSBEUtils.h"
#include "CMMCScBkupArchive.h"
#include "CMMCScBkupArchiveFooter.h"
#include "CMMCScBkupIndexWithIdentifier.h"
#include "MMMCScBkupArchiveDataInterface.h"



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

// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::CMMCScBkupStateArchiveOpSystemData()
// 
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupStateArchiveOpSystemData::CMMCScBkupStateArchiveOpSystemData( MMMCScBkupDriver& aDriver )
:   CMMCScBkupStateOpAware( aDriver ), iIndexValueCurrent( -1 )
    {
    __LOG1("CMMCScBkupStateArchiveOpSystemData::CMMCScBkupStateArchiveOpSystemData() - 0x%08x", StateId().iUid );
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::~CMMCScBkupStateArchiveOpSystemData()
// 
// Destructor.
// ---------------------------------------------------------------------------
CMMCScBkupStateArchiveOpSystemData::~CMMCScBkupStateArchiveOpSystemData()
    {
    Cancel();
    //
    delete iBackupTransferObject;
    delete iRestoreTransferObject;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::NewL()
// 
// 
// ---------------------------------------------------------------------------
CMMCScBkupStateArchiveOpSystemData* CMMCScBkupStateArchiveOpSystemData::NewL( MMMCScBkupDriver& aDriver )
    {
    CMMCScBkupStateArchiveOpSystemData* self = new(ELeave) CMMCScBkupStateArchiveOpSystemData( aDriver );
    return self;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::StateId()
// 
// 
// ---------------------------------------------------------------------------
TMMCScBkupStateId CMMCScBkupStateArchiveOpSystemData::StateId() const
    {
    return KMMCScBkupStateIdArchiveOpSystemData;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::NextStateBackupId()
// 
// 
// ---------------------------------------------------------------------------
TMMCScBkupStateId CMMCScBkupStateArchiveOpSystemData::NextStateBackupId( TBool /*aPartial*/ ) const
    {
    return KMMCScBkupStateIdArchiveOpJavaData;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::NextStateRestoreId()
// 
// 
// ---------------------------------------------------------------------------
TMMCScBkupStateId CMMCScBkupStateArchiveOpSystemData::NextStateRestoreId( TBool /*aPartial*/ ) const
    {
    return KMMCScBkupStateIdArchiveOpJavaData;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::PerformStateInitBackupL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateArchiveOpSystemData::PerformStateInitBackupL( TBool /*aPartial*/ )
    {
    __DEBUG_TESTING_SKIP_BACKUP_SYS_DATA;

    iBackupTransferObject = CMMCScBkupWriteDataTransferRequest< TPackageDataType >::NewL(
                                    Driver(), 
                                    *this,
                                    EMMCScBkupOwnerDataTypeSystemData,
                                    EPackageTransferDerivedType,
                                    ESystemData
                                    );
    CompleteSelf();
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::PerformStateInitRestoreL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateArchiveOpSystemData::PerformStateInitRestoreL( TBool /*aPartial*/ )
    {
    __LOG("CMMCScBkupStateArchiveOpSystemData::PerformStateInitRestoreL() - START" );
    __DEBUG_TESTING_SKIP_RESTORE_SYS_DATA;

    iRestoreTransferObject = CMMCScBkupReadDataTransferRequest< TPackageDataType >::NewL(
                                    Driver(),
                                    EMMCScBkupOwnerDataTypeSystemData,
                                    ESystemData
                                    );

    CompleteSelf();
    __LOG("CMMCScBkupStateArchiveOpSystemData::PerformStateInitRestoreL() - END" );
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepBackupL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepBackupL( TBool /*aPartial*/ )
    {
    CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();
    const TInt count = dataOwners.Count();
    //
    while ( ++iIndexValueCurrent < count )
        {
        CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( iIndexValueCurrent );
        //
        if  ( owner.CompletionStatus( EMMCScBkupOwnerDataTypeSystemData ) == EFalse )
            {
            // Request all the system data (on all supported drives) for this
            // particular data owner
            __ASSERT_ALWAYS( iBackupTransferObject->IsActive() == EFalse, User::Invariant() );
            iBackupTransferObject->RequestL( owner, 
                                             iStatus,
                                             Driver().DrvParamsBase().DriveAndOperations() );
            SetActive();
            break; // while loop
            }
        }
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepRestoreL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepRestoreL( TBool /*aPartial*/ )
    {
    CMMCScBkupIndexBase& indexBase = Driver().DrvArchive().Footer().IndexByType( EMMCScBkupOwnerDataTypeSystemData );
    CMMCScBkupIndexWithIdentifier<  TInt32 >& index = static_cast< CMMCScBkupIndexWithIdentifier< TInt32 >& >( indexBase );
    const TInt count = index.Count();
    __LOG1("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepRestoreL() - START - %d data owners...", count );
    //
    if  ( ++iIndexValueCurrent < count )
        {
        __LOG2("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepRestoreL() - getting system data index record [%03d/%03d]", iIndexValueCurrent + 1, count);
        const CMMCScBkupIndexEntry< TInt32 >& entry = index.At( iIndexValueCurrent );
        iSecureId = entry.Identifier();

        __LOG("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepRestoreL() - getting sub-entries for index record...");
        const RArray< TMMCScBkupArchiveDriveAndVector >& subEntries = entry.Entries();
        __LOG1("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepRestoreL() - got %d sub-entries for index record", subEntries.Count());
#ifdef __MMCSCBKUPLOGGING_ENABLED__
        for(TInt i=0; i<subEntries.Count(); i++)
            {
            const TMMCScBkupArchiveDriveAndVector& item = subEntries[i];
            __LOG4("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepRestoreL() - subentry[%2d] = %c:\\ [Offset: %8d, Length: %d] ", i, item.iDrive + 'A', item.iVector.Offset(), item.iVector.Length() );
            }
#endif
        
        // Get the associated data owner
        CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();

        __LOG1("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepRestoreL() - trying to supply system data for SID: 0x%08x", entry.Identifier() );

        // The owner in question should be a package type object. 
        CMMCScBkupDataOwnerInfo& owner = dataOwners.OwnerL( entry.Identifier() );

        if  ( owner.CompletionStatus( EMMCScBkupOwnerDataTypeSystemData ) == EFalse )
            {
            // The owner in question should be a package type object. 
            const TSBDerivedType ownersDerivedType = owner.Owner().Identifier().DerivedTypeL();
            __ASSERT_ALWAYS( ownersDerivedType == EPackageDerivedType || ownersDerivedType == EPackageTransferDerivedType, User::Invariant() );

#ifdef __MMCSCBKUPLOGGING_ENABLED__
            const TUid packageUid = MMCScBkupSBEUtils::PackageIdFromGenericL( owner.Owner().Identifier() );
            __LOG2("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousStateStepRestoreL() - trying to restore SYSTEM DATA for SID: 0x%08x, packageUID: 0x%08x", entry.Identifier(), packageUid.iUid );
#endif

            // Safety check
            __ASSERT_ALWAYS( iRestoreTransferObject->IsActive() == EFalse, User::Invariant() );

            // Request all the system data (on all supported drives) for this
            // particular data owner
            iRestoreTransferObject->RequestL( owner, 
                                              iStatus,
                                              subEntries );
            SetActive();
            }
        else
            {
            CompleteSelf();
            }
        }
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousErrorCleanupBackup()
// 
// 
// ---------------------------------------------------------------------------
TBool CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousErrorCleanupBackup( TBool /*aPartial*/, TInt aError )
    {
    (void) aError;
    __LOG1("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousErrorCleanupBackup() - error: %d", aError );

    // Reset state and move to next item. Treat the current (badly behaving) item
    // as completed/processed.
    CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();
    if  ( iIndexValueCurrent < dataOwners.Count() )
        {
        CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( iIndexValueCurrent );
        owner.SetCompletionStatus( EMMCScBkupOwnerDataTypeSystemData, ETrue );

        __LOGFILE2("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousErrorCleanupBackup() - **** - error: %d, SID: 0x%08x - system data skipped for DO", aError, owner.SecureId().iId );
        }

    CompleteSelf();
    return ETrue;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousErrorCleanupRestore()
// 
// 
// ---------------------------------------------------------------------------
TBool CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousErrorCleanupRestore( TBool /*aPartial*/, TInt aError )
    {
    (void) aError;
    __LOGFILE1("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousErrorCleanupRestore() - **** - error: %d", aError );

    // If system data restore phase returns "not supported", let's treat it as 
    // such an error, that other data types for this data owner are not
    // allowed to restore either.
    
    if( aError == KErrNotSupported || aError == KErrAlreadyExists )
        {
        CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();
        CMMCScBkupDataOwnerInfo* owner = NULL;
        TRAPD( err, owner = &dataOwners.OwnerL( iSecureId ) );
        if( err == KErrNone && owner )
            {
            owner->SetCompletionStatus( EMMCScBkupOwnerDataTypeJavaData, ETrue );
            owner->SetCompletionStatus( EMMCScBkupOwnerDataTypePublicData, ETrue );
            owner->SetCompletionStatus( EMMCScBkupOwnerDataTypeSystemData, ETrue );
            owner->SetCompletionStatus( EMMCScBkupOwnerDataTypeActiveData, ETrue );
            owner->SetCompletionStatus( EMMCScBkupOwnerDataTypePassiveData, ETrue );

            __LOGFILE2("CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousErrorCleanupRestore() - **** - error: %d, SID: 0x%08x - all data types skipped for DO", aError, owner->SecureId().iId );
            }
        }
    
    CompleteSelf();
    return ETrue;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousCancellation()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateArchiveOpSystemData::PerformAsynchronousCancellation()
    {
    if  (iBackupTransferObject)
        {
        iBackupTransferObject->Cancel();
        }
    if  (iRestoreTransferObject)
        {
        iRestoreTransferObject->Cancel();
        }
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::PerformLastRightsBackupL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateArchiveOpSystemData::PerformLastRightsBackupL( TBool /*aPartial*/ )
    {
    CMMCScBkupIndexBase& index = Driver().DrvArchive().Footer().IndexByType( EMMCScBkupOwnerDataTypeSystemData );
    index.StoreL( Driver() );
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::PerformLastRightsRestoreL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateArchiveOpSystemData::PerformLastRightsRestoreL( TBool /*aPartial*/ )
    {
    Driver().DrvSecureBackupClient().AllSystemFilesRestored();
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateArchiveOpSystemData::AddIndexRecordL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateArchiveOpSystemData::AddIndexRecordL( CMMCScBkupArchiveFooter& aFooter, CMMCScBkupDataOwnerInfo& aDataOwner, const TMMCScBkupArchiveVector& aInfo, TDriveNumber aDrive )
    {
    CMMCScBkupIndexBase& indexBase = aFooter.IndexByType( EMMCScBkupOwnerDataTypeSystemData );
    CMMCScBkupIndexWithIdentifier< TInt32 >& index = static_cast< CMMCScBkupIndexWithIdentifier< TInt32 >& >( indexBase );
    index.AddIndexRecordL( aInfo, aDrive, aDataOwner.SecureId().iId );
    }