--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/filemanager/src/fmbkupengine/src/CMMCScBkupStateValidateDiskSpace.cpp Tue Aug 31 15:06:05 2010 +0300
@@ -0,0 +1,393 @@
+/*
+* 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: CMMCScBkupStateValidateDiskSpace implementation
+*
+*
+*/
+
+#include "CMMCScBkupStateValidateDiskSpace.h"
+
+// System includes
+#include <e32std.h>
+#include <s32strm.h>
+#include <s32mem.h>
+
+// User includes
+#include "MMCScBkupLogger.h"
+#include "CMMCScBkupFileInfo.h"
+#include "CMMCScBkupArchive.h"
+#include "CMMCScBkupArchiveFooter.h"
+#include "CMMCScBkupArchiveHeader.h"
+#include "CMMCScBkupDataOwnerInfo.h"
+#include "RMMCScBkupProgressSizer.h"
+#include "MMMCScBkupProgressObserver.h"
+#include "CMMCScBkupFileListCollection.h"
+#include "CMMCScBkupDataOwnerCollection.h"
+#include "CMMCScBkupIndexPublicDataFiles.h"
+#include "CMMCScBkupDataStrategies.h"
+#include "MMCScBkupSBEUtils.h"
+
+// ========================= MEMBER FUNCTIONS ================================
+
+// ---------------------------------------------------------------------------
+// CMMCScBkupStateValidateDiskSpace::~CMMCScBkupStateValidateDiskSpace()
+//
+// Destructor.
+// ---------------------------------------------------------------------------
+CMMCScBkupStateValidateDiskSpace::~CMMCScBkupStateValidateDiskSpace()
+ {
+ iDriveSizes.Close();
+ iDriveMaxFileSizes.Close();
+ }
+
+// ---------------------------------------------------------------------------
+// CMMCScBkupStateValidateDiskSpace::CMMCScBkupStateValidateDiskSpace()
+//
+// C++ constructor.
+// ---------------------------------------------------------------------------
+CMMCScBkupStateValidateDiskSpace::CMMCScBkupStateValidateDiskSpace( MMMCScBkupDriver& aDriver )
+: CMMCScBkupState( aDriver ), iCumulatedSize(0)
+ {
+ __LOG1("CMMCScBkupStateValidateDiskSpace::CMMCScBkupStateValidateDiskSpace() - 0x%08x", StateId().iUid );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CMMCScBkupStateValidateDiskSpace::NewL()
+//
+//
+// ---------------------------------------------------------------------------
+CMMCScBkupStateValidateDiskSpace* CMMCScBkupStateValidateDiskSpace::NewL( MMMCScBkupDriver& aDriver )
+ {
+ CMMCScBkupStateValidateDiskSpace* self = new(ELeave) CMMCScBkupStateValidateDiskSpace( aDriver );
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CMMCScBkupStateValidateDiskSpace::ConstructL()
+//
+//
+// ---------------------------------------------------------------------------
+void CMMCScBkupStateValidateDiskSpace::ConstructL( )
+ {
+ for( TInt i = EDriveA; i<=EDriveZ; i++ )
+ {
+ const TDriveNumber drive = static_cast< TDriveNumber >( i );
+
+ // Zero-initialize max. file sizing info arrays
+ TMMCScBkupDriveAndSize newEntry( drive, 0 );
+ iDriveSizes.AppendL( newEntry );
+ TMMCScBkupDriveAndSize maxEntry( drive, 0 );
+ iDriveMaxFileSizes.AppendL( maxEntry );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CMMCScBkupStateValidateDiskSpace::StateId()
+//
+//
+// ---------------------------------------------------------------------------
+TMMCScBkupStateId CMMCScBkupStateValidateDiskSpace::StateId() const
+ {
+ return KMMCScBkupStateIdValidateDiskSpace;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CMMCScBkupStateValidateDiskSpace::NextStateId()
+//
+//
+// ---------------------------------------------------------------------------
+TMMCScBkupStateId CMMCScBkupStateValidateDiskSpace::NextStateId() const
+ {
+ TMMCScBkupStateId nextState = KMMCScBkupStateIdOperationComplete;
+ //
+ const TMMCScBkupOperationType type = Driver().DrvOperation();
+ switch(type)
+ {
+ case EMMCScBkupOperationTypeFullBackup:
+ nextState = KMMCScBkupStateIdArchiveOpPublicDataFiles;
+ break;
+ case EMMCScBkupOperationTypeFullRestore:
+ nextState = KMMCScBkupStateIdSetPhoneMode;
+ break;
+ default:
+ ASSERT( EFalse );
+ break;
+ }
+ //
+ return nextState;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CMMCScBkupStateValidateDiskSpace::PerformStateInitL()
+//
+//
+// ---------------------------------------------------------------------------
+void CMMCScBkupStateValidateDiskSpace::PerformStateInitL()
+ {
+ CompleteSelf();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CMMCScBkupStateValidateDiskSpace::PerformAsynchronousStateStepL()
+//
+//
+// ---------------------------------------------------------------------------
+void CMMCScBkupStateValidateDiskSpace::PerformAsynchronousStateStepL()
+ {
+ const TMMCScBkupOperationType type = Driver().DrvOperation();
+
+ switch(type)
+ {
+ case EMMCScBkupOperationTypeFullBackup:
+ {
+ ValidateFreeSpaceBeforeBackupL();
+ break;
+ }
+ case EMMCScBkupOperationTypeFullRestore:
+ {
+ ValidateFreeSpaceBeforeRestoreL();
+ break;
+ }
+ default:
+ User::Leave(KErrNotSupported);
+ break;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL()
+//
+//
+// ---------------------------------------------------------------------------
+void CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL()
+ {
+ CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();
+ TInt64 uncompressedSize;
+
+ __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - START");
+
+ // Calculate the total progress required for the entire backup operation
+ uncompressedSize = dataOwners.TotalOperationalSizeL();
+ __LOG1("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - Total estimated uncompressed size for archive %Ld", uncompressedSize);
+ //const TInt ownerCount = dataOwners.Count();
+
+ //for( TInt i=0; i<ownerCount; i++ )
+ // {
+ // CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( i );
+ // Reset the size of public data to 0. We update this value
+ // with the compressed size during the compression stage. This
+ // is needed in order to create accurate restore information (since
+ // all of the data owner sizing info is written to disk).
+ // owner.ResetOperationalSize( EMMCScBkupOwnerDataTypePublicData );
+ // }
+
+ // Let's check do public files fit in target drive
+ TInt driveNumber;
+ TDriveInfo driveInfo;
+ TVolumeInfo volInfo;
+ TInt8 percentFree(100);
+
+ // First get the drive number, where archive resides and then get drive's free space.
+ TInt err = ADI().ADIRawArchiveFile().Drive( driveNumber, driveInfo );
+ if( err == KErrNone)
+ {
+ err = ADI().ADIFsSession().Volume( volInfo, driveNumber );
+ if( err == KErrNone)
+ {
+ iCumulatedSize += uncompressedSize;
+
+ if(Driver().DrvLastCategory())
+ {
+ __LOG3("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - Final cumulated size %Ld, free size on drive %c is %Ld",
+ iCumulatedSize, driveNumber + 'A', volInfo.iFree);
+
+ if( iCumulatedSize > volInfo.iFree)
+ {
+ percentFree = TInt( (volInfo.iFree * 100 ) / iCumulatedSize ); // accurate enough, no rounding
+ }
+
+ err = Driver().DrvProgressHandler().MMCScBkupHandleFreeSpace( percentFree );
+ if( err != KErrNone )
+ {
+ // Error indicates backup creation no more allowed
+ Driver().DrvProgressHandler().MMCScBkupStartBackuping( EFalse );
+ User::Leave( err );
+ }
+ else
+ {
+ Driver().DrvProgressHandler().MMCScBkupStartBackuping( ETrue );
+ }
+ }
+ else
+ {
+ __LOG3("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - Cumulated size now %Ld, free size on drive %c is %Ld",
+ iCumulatedSize, driveNumber + 'A', volInfo.iFree);
+ }
+ }
+ else
+ {
+ __LOG1("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - Volume info error %d", err);
+ }
+ }
+
+ __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeBackupL() - END");
+ }
+
+
+// ---------------------------------------------------------------------------
+// CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL()
+//
+//
+// ---------------------------------------------------------------------------
+void CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL()
+ {
+ CMMCScBkupArchiveFooter& footer = Driver().DrvArchive().Footer();
+ CMMCScBkupIndexPublicDataFiles& index = static_cast<CMMCScBkupIndexPublicDataFiles&>( footer.IndexByType( EMMCScBkupOwnerDataTypePublicData ) );
+ CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();
+ CMMCScBkupFileListCollection& fileList = Driver().DrvFileList();
+ TInt indexValueCurrent(0);
+
+ __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - START");
+
+ const TInt ownerCount = dataOwners.Count();
+
+ // We can only make a direct comparison for public data
+ for( TInt i=0; i<ownerCount; i++ )
+ {
+ CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( i );
+ const CDataOwnerInfo& sbeDataOwner = owner.Owner();
+
+ if ( MMCScBkupSBEUtils::HasPublicDataL( sbeDataOwner ) )
+ {
+ for( TInt i = EDriveA; i<=EDriveZ; i++ )
+ {
+ const TDriveNumber drive = static_cast< TDriveNumber >( i );
+
+ const TInt64 size = owner.OperationalSize( EMMCScBkupOwnerDataTypePublicData, drive );
+ TMMCScBkupDriveAndSize& entry = iDriveSizes[ drive ];
+ entry.SetSize(entry.Size() + size);
+ __LOG4("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - DO: 0x%08x has %Ld bytes for drive %c (total %Ld)",
+ owner.SecureId().iId, size, entry.Drive() + 'A', entry.Size());
+ }
+ }
+ }
+
+#if defined(__MMCSCBKUPLOGGING_ENABLED__)
+ for( TInt i = EDriveA; i<=EDriveZ; i++ )
+ {
+ TMMCScBkupDriveAndSize& entry = iDriveSizes[ i ];
+ __LOG2("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Initially %Ld bytes required on drive %c",
+ entry.Size(), entry.Drive() + 'A');
+ }
+#endif
+
+ const TInt count = index.Count();
+
+ __LOG1("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Public files to compare %d", count);
+
+ // Check needed size by comparing archived public files to files in disk - decrease size if matching file found
+ while( ++indexValueCurrent < count )
+ {
+ // Get the entry to restore
+ TMMCScBkupArchiveVector entryInfo;
+ //const CMMCScBkupFileInfo& fileInfo = index.At( indexValueCurrent, entryInfo );
+ const CMMCScBkupFileInfo& fileInfo = fileList.Entry(indexValueCurrent);
+ const TDriveNumber drive = fileInfo.Drive();
+
+ __LOG2("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Archived file: %S, of size %d", &fileInfo.FileName(), fileInfo.Size());
+
+ // Check file (if any) size in disk
+ RFile64 restoreFile;
+ TInt64 fileSize = 0;
+ TInt error = restoreFile.Open(ADI().ADIFsSession(), fileInfo.FileName(), EFileShareReadersOnly | EFileRead);
+ if(error == KErrNone)
+ {
+ error = restoreFile.Size(fileSize);
+ if(error == KErrNone)
+ {
+ __LOG1("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Found matching file of size %d", fileInfo.Size());
+
+ // Take into account biggest file already on disk, because reserves that much space temporarily
+ if(iDriveMaxFileSizes[ drive ].Size() < fileSize && KMMCScBkupUseTempFile)
+ {
+ TMMCScBkupDriveAndSize& bigFile = iDriveMaxFileSizes[ drive ];
+ bigFile.SetSize(fileSize);
+ }
+ }
+ else
+ {
+ fileSize = 0;
+ __LOG1("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Error % requesting file size", error);
+ }
+
+ restoreFile.Close();
+ }
+
+ TMMCScBkupDriveAndSize& entry = iDriveSizes[ drive ];
+ entry.SetSize(entry.Size() - fileSize);
+
+ __LOG2("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - %Ld bytes required now on drive %c", entry.Size(), entry.Drive() + 'A');
+ }
+
+ __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - No estimation for private and system files");
+
+ if(Driver().DrvLastCategory())
+ {
+ TVolumeInfo volInfo;
+ TInt spaceCheck(KErrNone);
+
+ // Let user interrupt restore if necessary in future. Currently if any of drives cannot be restored, we interrupt restore.
+ for( TInt i = EDriveA; i<=EDriveZ; i++ )
+ {
+ // Check whether data fits into this drive.
+ const TDriveNumber drive = static_cast< TDriveNumber >( i );
+
+ TInt err = ADI().ADIFsSession().Volume( volInfo, drive );
+ if( err == KErrNone)
+ {
+ // Total compressed size. If this exceeds total size of drive, then restore does not succeed for sure.
+ const TInt64 size = dataOwners.DiskSpaceRequiredForRestore( drive );
+ __LOG3("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - drive %c requires %Ld + %Ld for temporary file",
+ iDriveSizes[ drive ].Drive() + 'A', iDriveSizes[ drive ].Size(), iDriveMaxFileSizes[ drive ].Size());
+
+ if ( (( iDriveSizes[ drive ].Size() + iDriveMaxFileSizes[ drive ].Size() ) > volInfo.iFree ) ||
+ ( size > volInfo.iSize ) )
+ {
+ __LOG2("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Not enough space (%Ld) on drive %c",
+ TInt(volInfo.iFree), iDriveSizes[ drive ].Drive() + 'A');
+ spaceCheck = KErrDiskFull;
+ break;
+ }
+ }
+ }
+
+ User::LeaveIfError(spaceCheck);
+ }
+ else
+ {
+ __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - Checking next category...");
+ }
+
+ __LOG("CMMCScBkupStateValidateDiskSpace::ValidateFreeSpaceBeforeRestoreL() - END");
+ }
+
+