/*

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

*

*

*/

#include "RMMCScBkupProgressSizer.h"

// User includes

#include "MMCScBkupLogger.h"

#include "MMCScBkupSBEUtils.h"

#include "CMMCScBkupDataOwnerInfo.h"

#include "MMMCScBkupProgressObserver.h"

#include "CMMCScBkupDriveAndOperationTypeManager.h"

// Constants

const TInt KMMCScBkupWeightingFactor = 10000;

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

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

// RMMCScBkupProgressSizer::RMMCScBkupProgressSizer()

// 

// C++ constructor.

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

RMMCScBkupProgressSizer::RMMCScBkupProgressSizer( const CMMCScBkupDriveAndOperationTypeManager& aDriveAndOperationTypes )

:   iDriveAndOperationTypes( aDriveAndOperationTypes ), iDriveFilter( aDriveAndOperationTypes.DriveList() )

    {

    }

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

// RMMCScBkupProgressSizer::BackupTotalProgressValueL()

// 

// Calculate the total amount of progress steps that a particular data owner 

// requires. This method can only be called after all of the sizing info

// has been obtained from the SBE

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

TInt64 RMMCScBkupProgressSizer::BackupTotalProgressValueL( const CMMCScBkupDataOwnerInfo& aDataOwner )

    {

    __LOG(" ");

    __LOG1("RMMCScBkupProgressSizer::BackupTotalProgressValueL() - START - DO: 0x%08x", aDataOwner.SecureId().iId);

    TInt64 totalStepCount = 0;

    //////////////////////////////////////////////////////////////////////

    // THESE ELEMENTS HAVE PSEUDO-PROGRESS - that is, the report a fixed

    // number of progress nibbles per operation. For example:

    // 

    // TYPE     DRIVE        PROGRESS

    // =======================================

    // ACTIVE   (C:)          1 x 2000

    // PASSIVE  (C:)          1 x 2000

    // SYSTEM   (C:, E:)      2 x 2000

    // JAVA     (C:)          1 x 2000

    // PUBLIC   (C: = 12k)   12 x 1024

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

    // total                 10000 + (12 x 1024)

    //

    //////////////////////////////////////////////////////////////////////

    const CDataOwnerInfo& sbeDataOwner = aDataOwner.Owner();

    // Passive data

    if  ( MMCScBkupSBEUtils::HasPassiveDataL( sbeDataOwner ) )

        {

        const TInt opsCount = NumberOfDriveOpsRequiredL( aDataOwner, EMMCScBkupOwnerDataTypePassiveData );

        __LOG2("RMMCScBkupProgressSizer::BackupTotalProgressValueL() - passive - %d of progress (%d ops)", opsCount * KMMCScBkupWeightingFactor, opsCount);

        totalStepCount += ( opsCount * KMMCScBkupWeightingFactor );

        }

    // Active data

    if  ( MMCScBkupSBEUtils::HasActiveDataL( sbeDataOwner ) )

        {

        const TInt opsCount = NumberOfDriveOpsRequiredL( aDataOwner, EMMCScBkupOwnerDataTypeActiveData );

        __LOG2("RMMCScBkupProgressSizer::BackupTotalProgressValueL() - active  - %d of progress (%d ops)", opsCount * KMMCScBkupWeightingFactor, opsCount);

        totalStepCount += ( opsCount * KMMCScBkupWeightingFactor );

        }

    // System data

    if  ( MMCScBkupSBEUtils::HasSystemDataL( sbeDataOwner ) )

        {

        const TInt opsCount = NumberOfDriveOpsRequiredL( aDataOwner, EMMCScBkupOwnerDataTypeSystemData );

        __LOG2("RMMCScBkupProgressSizer::BackupTotalProgressValueL() - system  - %d of progress (%d ops)", opsCount * KMMCScBkupWeightingFactor, opsCount);

        totalStepCount += ( opsCount * KMMCScBkupWeightingFactor );

        }

    // Java data

    if  ( MMCScBkupSBEUtils::HasJavaDataL( sbeDataOwner ) )

        {

        const TInt opsCount = NumberOfDriveOpsRequiredL( aDataOwner, EMMCScBkupOwnerDataTypeJavaData );

        __LOG2("RMMCScBkupProgressSizer::BackupTotalProgressValueL() - java    - %d of progress (%d ops)", opsCount * KMMCScBkupWeightingFactor, opsCount);

        totalStepCount += ( opsCount * KMMCScBkupWeightingFactor );

        }

    ///////////////////////////////////

    // PUBLIC REPORTS ACTUAL SIZING

    ///////////////////////////////////

    // Public data

    if  ( MMCScBkupSBEUtils::HasPublicDataL( sbeDataOwner ) )

        {

        const TInt64 size = AmountOfPublicDataToBeRestoredL( aDataOwner );

        __LOG1("RMMCScBkupProgressSizer::BackupTotalProgressValueL() - public  - %Ld of progress", size);

        totalStepCount += size;

        }

    //

    __LOG2("RMMCScBkupProgressSizer::BackupTotalProgressValueL() - END - DO: 0x%08x, totalStepCount: %8Ld", aDataOwner.SecureId().iId, totalStepCount);

    return totalStepCount;

    }

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

// RMMCScBkupProgressSizer::BackupReportFixedProgressForOpL()

// 

// 

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

void RMMCScBkupProgressSizer::BackupReportFixedProgressForOpL( MMMCScBkupProgressObserver& aProgressManager, TMMCScBkupOwnerDataType aType )

    {

    switch( aType )

        {

    case EMMCScBkupOwnerDataTypeSystemData:

    case EMMCScBkupOwnerDataTypeActiveData:

    case EMMCScBkupOwnerDataTypePassiveData:

    case EMMCScBkupOwnerDataTypeJavaData:

        __LOG2("RMMCScBkupProgressSizer::BackupReportFixedProgressForOpL() - aType: %d, amount: %d ", aType, KMMCScBkupWeightingFactor );

        aProgressManager.MMCScBkupHandleProgress( KMMCScBkupWeightingFactor );

        break;

    default:

    case EMMCScBkupOwnerDataTypeDataOwner:

    case EMMCScBkupOwnerDataTypePublicData:

        ASSERT( EFalse );

        break;

        }

    }

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

// RMMCScBkupProgressSizer::RestoreCombinedDataSizeL()

// 

// 

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

TInt64 RMMCScBkupProgressSizer::RestoreCombinedDataSizeL( const CMMCScBkupDataOwnerInfo& aOwner )

    {

    TInt64 size = 0;

    //

    iDriveFilter.Reset();

    iDriveFilter.SetSecondaryDriveFilter( aOwner.Owner().DriveList() );

    //

    TDriveNumber drive = EDriveA;

    while ( iDriveFilter.NextValidDrive( drive ) )

        {

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

            {

            const TMMCScBkupOwnerDataType dataType = static_cast< TMMCScBkupOwnerDataType > ( i );

            const TBool allowedForDrive = iDriveAndOperationTypes.IsDataTypeAllowedToAccessDrive( drive, dataType );

            //

            if  ( allowedForDrive )

                {

                // Get the amount of data for this drive

                size += aOwner.OperationalSize( dataType, drive );

                }

            }

        }

    //

    return size;

    }

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

// RMMCScBkupProgressSizer::NumberOfDriveOpsRequiredL()

// 

// 

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

TInt RMMCScBkupProgressSizer::NumberOfDriveOpsRequiredL( const CMMCScBkupDataOwnerInfo& aOwner, TMMCScBkupOwnerDataType aType )

    {

    TInt count = 0;

    //

    iDriveFilter.Reset();

    iDriveFilter.SetSecondaryDriveFilter( aOwner.Owner().DriveList() );

    //

    TDriveNumber drive = EDriveA;

    while ( iDriveFilter.NextValidDrive( drive ) )

        {

        const TBool allowedForDrive = iDriveAndOperationTypes.IsDataTypeAllowedToAccessDrive( drive, aType );

        //

        if  ( allowedForDrive )

            {

            ++count;

            }

        }

    //

    return count;

    }

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

// RMMCScBkupProgressSizer::AmountOfPublicDataToBeRestoredL()

// 

// 

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

TInt64 RMMCScBkupProgressSizer::AmountOfPublicDataToBeRestoredL( const CMMCScBkupDataOwnerInfo& aOwner )

    {

    TInt64 size = 0;

    //

    iDriveFilter.Reset();

    iDriveFilter.SetSecondaryDriveFilter( aOwner.Owner().DriveList() );

    //

    TDriveNumber drive = EDriveA;

    while ( iDriveFilter.NextValidDrive( drive ) )

        {

        const TBool allowedForDrive = iDriveAndOperationTypes.IsDataTypeAllowedToAccessDrive( drive, EMMCScBkupOwnerDataTypePublicData );

        //

        if  ( allowedForDrive )

            {

            // Get the amount of data for this drive

            size += aOwner.OperationalSize( EMMCScBkupOwnerDataTypePublicData, drive );

            }

        }

    //

    return size;

    }