diff -r 95243422089a -r 491b3ed49290 filemanager/src/fmbkupengine/src/CMMCScBkupStateValidateDiskSpace.cpp
--- /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");
+    }
+
+