/*

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

*

*

*/

#include "CMMCScBkupStateRequestSizeOfBackupData.h"

// System includes

#include <e32std.h>

// User includes

#include "MMCScBkupLogger.h"

#include "MMCScBkupSBEUtils.h"

#include "TMMCScBkupOwnerDataType.h"

#include "CMMCScBkupDataOwnerInfo.h"

#include "MMMCScBkupProgressObserver.h"

#include "CMMCScBkupDataOwnerCollection.h"

#include "CMMCScBkupDriveAndOperationTypeManager.h"

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

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

// CMMCScBkupStateRequestSizeOfBackupData::CMMCScBkupStateRequestSizeOfBackupData()

// 

// C++ constructor.

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

CMMCScBkupStateRequestSizeOfBackupData::CMMCScBkupStateRequestSizeOfBackupData( MMMCScBkupDriver& aDriver )

:   CMMCScBkupState( aDriver )

    {

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

    }

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

// CMMCScBkupStateRequestSizeOfBackupData::~CMMCScBkupStateRequestSizeOfBackupData()

// 

// C++ destructor.

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

CMMCScBkupStateRequestSizeOfBackupData::~CMMCScBkupStateRequestSizeOfBackupData()

    {

    Cancel();

    //

    delete iRequestObject;

    }

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

// CMMCScBkupStateRequestSizeOfBackupData::ConstructL()

// 

// 

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

void CMMCScBkupStateRequestSizeOfBackupData::ConstructL()

    {

    iRequestObject = CMMCScBkupStateRequestSizeOfDataOwner::NewL( Driver() );

    }

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

// CMMCScBkupStateRequestSizeOfBackupData::NewL()

// 

// 

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

CMMCScBkupStateRequestSizeOfBackupData* CMMCScBkupStateRequestSizeOfBackupData::NewL( MMMCScBkupDriver& aDriver )

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CMMCScBkupStateRequestSizeOfBackupData::StateId()

// 

// 

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

TMMCScBkupStateId CMMCScBkupStateRequestSizeOfBackupData::StateId() const

    {

    return KMMCScBkupStateIdRequestSizeOfBackupData;

    }

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

// CMMCScBkupStateRequestSizeOfBackupData::NextStateId()

// 

// 

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

TMMCScBkupStateId CMMCScBkupStateRequestSizeOfBackupData::NextStateId() const

    {

    return KMMCScBkupStateIdRequestListOfPublicFiles;

    }

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

// CMMCScBkupStateRequestSizeOfBackupData::PerformStateInitL()

// 

// 

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

void CMMCScBkupStateRequestSizeOfBackupData::PerformStateInitL()

    {

    // Set to -1 so that the first time RunL is called, we start with

    // the data owner at index 0.

    iCurrentDataOwnerIndex = -1;

    CompleteSelf(KErrNone);

    }

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

// CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousStateStepL()

// 

// 

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

void CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousStateStepL()

    {

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

    const TInt count = dataOwners.Count();

    //

    if  ( ++iCurrentDataOwnerIndex < dataOwners.Count() )

        {

        CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner(iCurrentDataOwnerIndex);

        // Request all the public files (on all supported drives) for this

        // particular data owner

        __ASSERT_ALWAYS(iRequestObject->IsActive() == EFalse, User::Invariant());

        //

        __LOG3("CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousStateStepL() - START - owner[%3d/%3d], sid: 0x%08x", iCurrentDataOwnerIndex, count, owner.SecureId().iId);

        iRequestObject->RequestL(owner, iStatus);

        SetActive();

        }

    else

        {

        __LOG("CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousStateStepL() - END");

        }

    }

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

// CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousErrorCleanup()

// 

// 

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

TBool CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousErrorCleanup( TInt aError )

    {

    (void) aError;

    __LOG1("CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousErrorCleanup() - **** - error: %d", aError );

    TBool continueProcessing = ETrue;

    // Cancel requester. Its probably already inactive, but just in case...

    PerformAsynchronousCancellation();

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

    // as completed/processed.

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

    if  ( iCurrentDataOwnerIndex < dataOwners.Count() )

        {

        CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( iCurrentDataOwnerIndex );

        (void) owner;

        __LOGFILE2("CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousErrorCleanup() - **** - error: %d, SID: 0x%08x - SIZE OF DATA skipped for DO", aError, owner.SecureId().iId );

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

        CompleteSelf();

        }

    else

        {

        continueProcessing = EFalse;

        }

    //

    __LOG1("CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousErrorCleanup() - END - continueProcessing: %d", continueProcessing );

    return continueProcessing;

    }

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

// CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousCancellation()

// 

// 

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

void CMMCScBkupStateRequestSizeOfBackupData::PerformAsynchronousCancellation()

    {

    if  ( iRequestObject )

        {

        iRequestObject->Cancel();

        }

    }

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

// CMMCScBkupStateRequestSizeOfDataOwner::CMMCScBkupStateRequestSizeOfDataOwner()

// 

// 

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

CMMCScBkupStateRequestSizeOfDataOwner::CMMCScBkupStateRequestSizeOfDataOwner( MMMCScBkupDriver& aDriver )

:   CMMCScBkupDriveSpecificRequest( aDriver.DrvParamsBase().DriveAndOperations(), EMMCScBkupOwnerDataTypeAny ), iDriver(aDriver)

    {

    }

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

// CMMCScBkupStateRequestSizeOfDataOwner::NewL()

// 

// 

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

CMMCScBkupStateRequestSizeOfDataOwner* CMMCScBkupStateRequestSizeOfDataOwner::NewL( MMMCScBkupDriver& aDriver )

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CMMCScBkupStateRequestSizeOfDataOwner::RequestL()

// 

// 

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

void CMMCScBkupStateRequestSizeOfDataOwner::RequestL( CMMCScBkupDataOwnerInfo& aOwner, TRequestStatus& aObserver )

    {

    iOwner = &aOwner;

    CMMCScBkupDriveSpecificRequest::RequestL( aObserver );

    // Start the asynchronous request. 

    CompleteSelf(KErrNone);

    }

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

// CMMCScBkupStateRequestSizeOfDataOwner::RunL()

// 

// 

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

void CMMCScBkupStateRequestSizeOfDataOwner::RunL()

    {

    __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::RunL() - START - iStatus: %d, sid: 0x%08x", iStatus.Int(), iOwner->SecureId().iId);

    User::LeaveIfError(iStatus.Int());

    //

    TDriveNumber drive = EDriveA;

    const TDriveList& ownerDrives = iOwner->Owner().DriveList();

    const TBool driveAvailable = NextValidDrive(drive, ownerDrives);

    //

    if  (driveAvailable)

        {

        CDataOwnerInfo& owner = iOwner->Owner();

        CSBGenericDataType& identifier = owner.Identifier();

        // Size any active and passive data

        GetActiveAndPassiveDataSizesL( owner, identifier, drive );

        // Size any system package data

        GetSystemDataSizesL( owner, identifier, drive );

        // Size any java data

        GetJavaDataSizesL( owner, identifier, drive );

        // Complete ourself to try the next drive

        CompleteSelf(KErrNone);

        __LOG1("CMMCScBkupStateRequestSizeOfDataOwner::RunL() - END - sid: 0x%08x, checking next drive...", iOwner->SecureId().iId);

        }

    else

        {

        __LOG1("CMMCScBkupStateRequestSizeOfDataOwner::RunL() - END - sid: 0x%08x, last drive scanned => notifying observer", iOwner->SecureId().iId);

        CompleteObserverRequest(KErrNone);

        }

    }

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

// CMMCScBkupStateRequestSizeOfDataOwner::DoCancel()

// 

// 

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

void CMMCScBkupStateRequestSizeOfDataOwner::DoCancel()

    {

    CompleteObserverRequest( KErrCancel );

    }

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

// CMMCScBkupStateRequestSizeOfDataOwner::GetActiveAndPassiveDataSizesL()

// 

// 

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

TUint CMMCScBkupStateRequestSizeOfDataOwner::GetActiveAndPassiveDataSizesL( const CDataOwnerInfo& aOwner, 

    CSBGenericDataType& /*aIdentifier*/, TDriveNumber aDrive )

    {

    // Passive Data

    const TBool passiveBURSupported = MMCScBkupSBEUtils::HasPassiveDataL( aOwner );

    const TBool passiveDataTransferAllowedForDrive = DriveAndOperations().IsDataTypeAllowedToAccessDrive( aDrive, EMMCScBkupOwnerDataTypePassiveData );

    __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::GetSIDSizesL() - passiveBURSupported: %d, passiveDataTransferAllowedForDrive: %d", passiveBURSupported, passiveDataTransferAllowedForDrive );

    TUint ret = 0;

    TUint itemSize = 0;

    if  ( passiveBURSupported && passiveDataTransferAllowedForDrive )

        {

        const TSecureId secureId = iOwner->SecureId();

        const TTransferDataType type = Driver().DrvParamsBase().PassiveTransferType();

        __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::GetSIDSizesL() - sid: 0x%08x claims PASSIVE Data... type: %d", iOwner->SecureId().iId, type);

        itemSize = GetSIDSpecificSizeL( secureId, aDrive, type );

        iOwner->AddToOperationalSizeL( EMMCScBkupOwnerDataTypePassiveData, aDrive, itemSize );

        ret += itemSize;

        __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::GetSIDSizesL() - sid: 0x%08x, passive size: %8d", secureId.iId, itemSize);

        }

    // Active Data

    const TBool activeBURSupported = MMCScBkupSBEUtils::HasActiveDataL( aOwner );

    const TBool activeDataTransferAllowedForDrive = DriveAndOperations().IsDataTypeAllowedToAccessDrive( aDrive, EMMCScBkupOwnerDataTypeActiveData );

    __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::GetSIDSizesL() - activeBURSupported: %d, activeDataTransferAllowedForDrive: %d", activeBURSupported, activeDataTransferAllowedForDrive );

    if  ( activeBURSupported && activeDataTransferAllowedForDrive )

        {

        const TSecureId secureId = iOwner->SecureId();

        const TTransferDataType type = Driver().DrvParamsBase().ActiveTransferType();

        __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::GetSIDSizesL() - sid: 0x%08x claims ACTIVE Data... type: %d", iOwner->SecureId().iId, type);

        // Technically, we should wait for an active data owner to become ready before we ask

        // for its sizing information. If we don't wait, we might receive KErrNotReady back

        // from our SBE request. 

        //

        // Currently, the MMC engine doesn't actually make any use of the active data sizing

        // info, so we trap (and ignore) the error in this situation. In the future, we will

        // have to change the state machine in order to request the active data statuses

        // before the sizing can be requested.

        itemSize = 0;

        TRAPD(err, GetSIDSpecificSizeL( secureId, aDrive, type ));

        __LOG3("CMMCScBkupStateRequestSizeOfDataOwner::GetSIDSizesL() - sid: 0x%08x, active size: %8d, fetchError: %d", secureId.iId, itemSize, err);

        if  ( err == KErrNone || err == KErrNotReady )

            {

            err = KErrNone;

            }

        else

            {

            User::LeaveIfError( err );

            }

        iOwner->AddToOperationalSizeL( EMMCScBkupOwnerDataTypeActiveData, aDrive, itemSize );

        ret += itemSize;

        __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::GetSIDSizesL() - sid: 0x%08x, active size: %8d", secureId.iId, itemSize);

        }

    return ret;

    }

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

// CMMCScBkupStateRequestSizeOfDataOwner::GetSIDSpecificSizeL()

// 

// 

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

TUint CMMCScBkupStateRequestSizeOfDataOwner::GetSIDSpecificSizeL( TSecureId aSecureID, TDriveNumber aDrive, TTransferDataType aDataType )

    {

    CSBSIDTransferType* transferType = CSBSIDTransferType::NewL( aSecureID,

                                                                 aDrive,

                                                                 aDataType

                                                                );

    CleanupStack::PushL( transferType );

    const TUint size = Driver().DrvSecureBackupClient().ExpectedDataSizeL( *transferType );

    CleanupStack::PopAndDestroy( transferType );

    return size;

    }

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

// CMMCScBkupStateRequestSizeOfDataOwner::GetSystemDataSizesL()

// 

// 

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

TUint CMMCScBkupStateRequestSizeOfDataOwner::GetSystemDataSizesL( const CDataOwnerInfo& aOwner, CSBGenericDataType& aIdentifier, TDriveNumber aDrive )

    {

    TUint size = 0;

    //

    const TBool systemBURSupported = MMCScBkupSBEUtils::HasSystemDataL( aOwner );

    const TBool systemDataTransferAllowedForDrive = DriveAndOperations().IsDataTypeAllowedToAccessDrive( aDrive, EMMCScBkupOwnerDataTypeSystemData );

    __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::GetSystemDataSizesL() - systemBURSupported: %d, systemDataTransferAllowedForDrive: %d", systemBURSupported, systemDataTransferAllowedForDrive );

    if  ( systemBURSupported && systemDataTransferAllowedForDrive )

        {

        __LOG1("CMMCScBkupStateRequestSizeOfDataOwner::GetSystemDataSizesL() - sid: 0x%08x claims SYSTEM Data...", iOwner->SecureId().iId);

        // Again we have to create a temporary in order to actually retrieve the info...

        CSBPackageId* packageGeneric = static_cast<CSBPackageId*>( MMCScBkupSBEUtils::CopyLC( aIdentifier ) );

        const TUid packageId = packageGeneric->PackageIdL();

        //

        const TPackageDataType type = Driver().DrvParamsBase().PackageTransferType();

        CSBPackageTransferType* transferType = CSBPackageTransferType::NewL( packageId,

                                                                             aDrive,

                                                                             type

                                                                            );

        CleanupStack::PushL( transferType );

        size = Driver().DrvSecureBackupClient().ExpectedDataSizeL( *transferType );

        __LOG3("CMMCScBkupStateRequestSizeOfDataOwner::GetSystemDataSizesL() - packageId: 0x%08x, sid: 0x%08x, package size: %8d", packageId.iUid, iOwner->SecureId().iId, size);

        CleanupStack::PopAndDestroy( transferType );

        //

        iOwner->AddToOperationalSizeL( EMMCScBkupOwnerDataTypeSystemData, aDrive, size );

        CleanupStack::PopAndDestroy( packageGeneric );

        }

    return size;

    }

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

// CMMCScBkupStateRequestSizeOfDataOwner::GetJavaDataSizesL()

// 

// 

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

TUint CMMCScBkupStateRequestSizeOfDataOwner::GetJavaDataSizesL( const CDataOwnerInfo& aOwner, CSBGenericDataType& aIdentifier, TDriveNumber aDrive )

    {

    TUint size = 0;

    //

    const TBool javaBURSupported = MMCScBkupSBEUtils::HasJavaDataL( aOwner );

    const TBool javaDataTransferAllowedForDrive = DriveAndOperations().IsDataTypeAllowedToAccessDrive( aDrive, EMMCScBkupOwnerDataTypeJavaData );

    __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::GetJavaSizesL() - javaBURSupported: %d, javaDataTransferAllowedForDrive: %d", javaBURSupported, javaDataTransferAllowedForDrive );

    if  ( javaBURSupported && javaDataTransferAllowedForDrive )

        {

        // Again we have to create a temporary in order to actually retrieve the info...

        CSBJavaId* packageGeneric = static_cast<CSBJavaId*>(MMCScBkupSBEUtils::CopyLC( aIdentifier ));

        const TPtrC pHash(packageGeneric->SuiteHashL());

        __LOG1("CMMCScBkupStateRequestSizeOfDataOwner::GetJavaSizesL() - midlet hash: %S", &pHash );

        const TUint midletSize = GetJavaSpecificSizeL( pHash, aDrive, EJavaMIDlet);

        __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::GetJavaSizesL() - EJavaMIDlet,     sid: 0x%08x, size: %8d", iOwner->SecureId().iId, midletSize);

        const TUint midletDataSize = GetJavaSpecificSizeL( pHash, aDrive, EJavaMIDletData);

        __LOG2("CMMCScBkupStateRequestSizeOfDataOwner::GetJavaSizesL() - EJavaMIDletData, sid: 0x%08x, size: %8d", iOwner->SecureId().iId, midletDataSize);

        // We put the midlet itself in the special 'java data' category (the 'system data' equivalent for

        // java midlets).

        iOwner->AddToOperationalSizeL( EMMCScBkupOwnerDataTypeJavaData, aDrive, midletSize );

        // We put the midlet's data (e.g. any data files that it created) inside

        // the 'passive data' bucket.

        iOwner->AddToOperationalSizeL( EMMCScBkupOwnerDataTypePassiveData, aDrive, midletDataSize );

        // Java abuses the passive data slot. We would've initially set passive data's completion status

        // to ETrue inside CMMCScBkupDataOwnerInfo::ConstructL() as a result of receiving a Java

        // transfer type... but we can reset it back to "not yet completed" if the midlet

        // does indeed have some 'passive data'.

        iOwner->SetCompletionStatus( EMMCScBkupOwnerDataTypePassiveData, ( midletDataSize == 0 ) );

        CleanupStack::PopAndDestroy( packageGeneric );

        //

        size = midletSize + midletDataSize;

        }

    return size;

    }

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

// CMMCScBkupStateRequestSizeOfDataOwner::GetJavaSpecificSizeL()

// 

// 

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

TUint CMMCScBkupStateRequestSizeOfDataOwner::GetJavaSpecificSizeL( const TDesC& aHash, TDriveNumber aDrive, TJavaTransferType aDataType )

    {

    CSBJavaTransferType* transferType = CSBJavaTransferType::NewL( aHash,

                                                                   aDrive,

                                                                   aDataType

                                                                  );

    CleanupStack::PushL( transferType );

    const TUint size = Driver().DrvSecureBackupClient().ExpectedDataSizeL( *transferType );

    CleanupStack::PopAndDestroy( transferType );

    return size;

    }