/*
* 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");
}