--- /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 <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;
+ }