diff -r 491b3ed49290 -r 65326cf895ed filemanager/bkupengine/src/CMMCScBkupStateRequestListOfPublicFiles.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/filemanager/bkupengine/src/CMMCScBkupStateRequestListOfPublicFiles.cpp Wed Sep 01 12:31:07 2010 +0100 @@ -0,0 +1,447 @@ +/* +* 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: CMMCScBkupStateRequestListOfPublicFiles implementation +* +* +*/ + +#include "CMMCScBkupStateRequestListOfPublicFiles.h" + +// System includes +#include + +// User includes +#include "MMCScBkupLogger.h" +#include "MMCScBkupSBEUtils.h" +#include "CMMCScBkupDataOwnerInfo.h" +#include "RMMCScBkupProgressSizer.h" +#include "CMMCScBkupDataOwnerInfo.h" +#include "MMMCScBkupProgressObserver.h" +#include "CMMCScBkupFileListCollection.h" +#include "CMMCScBkupDataOwnerCollection.h" + + + + +// ========================= MEMBER FUNCTIONS ================================ + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::CMMCScBkupStateRequestListOfPublicFiles() +// +// C++ constructor. +// --------------------------------------------------------------------------- +CMMCScBkupStateRequestListOfPublicFiles::CMMCScBkupStateRequestListOfPublicFiles( MMMCScBkupDriver& aDriver ) +: CMMCScBkupState( aDriver ) + { + __LOG1("CMMCScBkupStateRequestListOfPublicFiles::CMMCScBkupStateRequestListOfPublicFiles() - 0x%08x", StateId().iUid ); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::~CMMCScBkupStateRequestListOfPublicFiles() +// +// Destructor. +// --------------------------------------------------------------------------- +CMMCScBkupStateRequestListOfPublicFiles::~CMMCScBkupStateRequestListOfPublicFiles() + { + Cancel(); + // + delete iRequestObject; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::ConstructL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateRequestListOfPublicFiles::ConstructL() + { + iRequestObject = CMMCScBkupStateRequestSpecificPublicFileInfo::NewL(Driver()); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::NewL() +// +// +// --------------------------------------------------------------------------- +CMMCScBkupStateRequestListOfPublicFiles* CMMCScBkupStateRequestListOfPublicFiles::NewL( MMMCScBkupDriver& aDriver ) + { + CMMCScBkupStateRequestListOfPublicFiles* self = new(ELeave) CMMCScBkupStateRequestListOfPublicFiles( aDriver ); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::StateId() +// +// +// --------------------------------------------------------------------------- +TMMCScBkupStateId CMMCScBkupStateRequestListOfPublicFiles::StateId() const + { + return KMMCScBkupStateIdRequestListOfPublicFiles; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::NextStateId() +// +// +// --------------------------------------------------------------------------- +TMMCScBkupStateId CMMCScBkupStateRequestListOfPublicFiles::NextStateId() const + { + return KMMCScBkupStateIdValidateDiskSpace; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::PerformStateInitL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateRequestListOfPublicFiles::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); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousStateStepL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousStateStepL() + { + CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners(); + if (++iCurrentDataOwnerIndex < dataOwners.Count()) + { + CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner(iCurrentDataOwnerIndex); + + const TBool hasPublicFiles = (owner.Owner().PassiveSettings() & EHasPublicFiles); + if (hasPublicFiles) + { + // Request all the public files (on all supported drives) for this + // particular data owner + __ASSERT_ALWAYS(iRequestObject->IsActive() == EFalse, User::Invariant()); + // + iRequestObject->RequestL(owner, iStatus); + SetActive(); + } + else + { + // Try next data owner + CompleteSelf(); + } + } + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousErrorCleanup() +// +// +// --------------------------------------------------------------------------- +TBool CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousErrorCleanup(TInt aError) + { + (void) aError; + __LOG1("CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousErrorCleanup() - **** - error: %d", aError ); + + // 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("CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousErrorCleanup() - **** - error: %d, SID: 0x%08x - PUBLIC data skipped for DO", aError, owner.SecureId().iId ); + + // Ensures that asynchronous state step is called again.. + CompleteSelf(); + } + + return ETrue; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousCancellation() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousCancellation() + { + if ( iRequestObject ) + { + iRequestObject->Cancel(); + } + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL() + { + // Now we can calculate the progress + TInt64 totalProgressAmount = 0; + + // Calculate the total progress required for the entire backup operation + CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners(); + const TInt count = dataOwners.Count(); + // + RMMCScBkupProgressSizer sizer( Driver().DrvParamsBase().DriveAndOperations() ); + for(TInt i=0; i KMaxTInt ) + { + __LOG1("CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL() - leaving with KErrNotSupported due amount of data (%Ld)", + Driver().DrvTotalProgress()); + Driver().DrvProgressHandler().MMCScBkupStartBackuping( EFalse ); + User::Leave( KErrNotSupported ); + } + else + { + Driver().DrvProgressHandler().MMCScBkupHandleProgressDomainUnderstood( Driver().DrvTotalProgress() ); + } + } + else + { + __LOG2("CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL() - adding progress amount %Ld to existing %Ld)", + totalProgressAmount, Driver().DrvTotalProgress()); + + if( (totalProgressAmount + Driver().DrvTotalProgress()) > KMaxTInt ) + { + __LOG1("CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL() - leaving due amount of data (%Ld)", + totalProgressAmount + Driver().DrvTotalProgress()); + User::Leave(KErrNotSupported); + } + else + { + Driver().DrvStoreTotalProgress( totalProgressAmount ); + } + } + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestSpecificPublicFileInfo::CMMCScBkupStateRequestSpecificPublicFileInfo() +// +// +// --------------------------------------------------------------------------- +CMMCScBkupStateRequestSpecificPublicFileInfo::CMMCScBkupStateRequestSpecificPublicFileInfo( MMMCScBkupDriver& aDriver ) +: CMMCScBkupDriveSpecificRequest( aDriver.DrvParamsBase().DriveAndOperations(), EMMCScBkupOwnerDataTypePublicData ), iDriver(aDriver) + { + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestSpecificPublicFileInfo::NewL() +// +// +// --------------------------------------------------------------------------- +CMMCScBkupStateRequestSpecificPublicFileInfo* CMMCScBkupStateRequestSpecificPublicFileInfo::NewL( MMMCScBkupDriver& aDriver ) + { + CMMCScBkupStateRequestSpecificPublicFileInfo* self = new (ELeave) CMMCScBkupStateRequestSpecificPublicFileInfo(aDriver); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestSpecificPublicFileInfo::RequestL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateRequestSpecificPublicFileInfo::RequestL( CMMCScBkupDataOwnerInfo& aOwner, TRequestStatus& aObserver ) + { + iOwner = &aOwner; + CMMCScBkupDriveSpecificRequest::RequestL( aObserver ); + + // Start the asynchronous request. + CompleteSelf(KErrNone); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() + { + __LOG1("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - START - iStatus: %d", iStatus.Int()); + User::LeaveIfError(iStatus.Int()); + // + CDataOwnerInfo& owner = iOwner->Owner(); + const TDriveList& ownerDrives = owner.DriveList(); + TDriveNumber drive = EDriveA; + const TBool driveAvailable = NextValidDrive(drive, ownerDrives); + const TSecureId secureId = iOwner->SecureId(); + + __LOG3("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - secureId: 0x%08x, driveAvailable: %d, drive: %c", secureId.iId, driveAvailable, drive + 'A'); + + if (driveAvailable) + { + // This drive needs to be scanned... + TInt err( KErrNone ); + RFileArray files; + CleanupClosePushL(files); + + // Get a copy of the generic data type for which we are + // requesting file listings... + CSBGenericDataType* genericDataType = CSBSecureId::NewL( secureId ); + CleanupStack::PushL( genericDataType ); + TRAP( err, Driver().DrvSecureBackupClient().PublicFileListL( drive, *genericDataType, files ) ); + if( err != KErrNone && err != KErrNotFound ) + { + User::Leave( err ); + } + CleanupStack::PopAndDestroy( genericDataType ); + // Additionally we need to request list of public files registered for packages. + if( MMCScBkupSBEUtils::HasSystemDataL( owner ) ) + { + RFileArray pkgFiles; + CleanupClosePushL( pkgFiles ); + __LOG2("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - have %d files before package listing for DO, err %d", files.Count(), err); + TRAP( err, Driver().DrvSecureBackupClient().PublicFileListL( drive, owner.Identifier(), pkgFiles ) ); + __LOG2("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - have %d package files for DO, err %d", files.Count(), err); + const TInt pkgCount = pkgFiles.Count(); + for(TInt i = 0; i < pkgCount; i++) + { + files.AppendL( pkgFiles[i] ); + } + CleanupStack::PopAndDestroy( &pkgFiles ); + } + + // Add to the file list + __LOG1("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - have %d files for DO", files.Count()); + if (files.Count()) + { + + // We want to be told by the public file collection exactly which files + // it added... We need to do this in order to report progress as accurately + // as possible during the backup operation. + RArray< const CMMCScBkupFileInfo* > addedItems; + CleanupClosePushL(addedItems); + + // Add them to the public data file collection + Driver().DrvFileList().AppendL( files, addedItems, secureId ); + + // For each identified file, update the data owner with the size of public data + const TInt count = addedItems.Count(); + for(TInt i=0; iAddToOperationalSizeL( EMMCScBkupOwnerDataTypePublicData, drive, size ); + } + // + CleanupStack::PopAndDestroy( &addedItems ); + } + // + CleanupStack::PopAndDestroy( &files ); + + // Complete ourself to try the next drive + CompleteSelf( KErrNone ); + } + else + { + CompleteObserverRequest( KErrNone ); + } + + __LOG("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - END"); + } + + +// --------------------------------------------------------------------------- +// CMMCScBkupStateRequestSpecificPublicFileInfo::DoCancel() +// +// +// --------------------------------------------------------------------------- +void CMMCScBkupStateRequestSpecificPublicFileInfo::DoCancel() + { + } + + + +