diff -r 491b3ed49290 -r 65326cf895ed filemanager/bkupengine/src/CMMCScBkupStateRequestSizeOfBackupData.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/filemanager/bkupengine/src/CMMCScBkupStateRequestSizeOfBackupData.cpp Wed Sep 01 12:31:07 2010 +0100 @@ -0,0 +1,515 @@ +/* +* 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 + +// 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( 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(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; + }