diff -r d1daf54a55b5 -r 1957042d8c7e filemanager/bkupengine/src/CMMCScBkupDataOwnerInfo.cpp --- a/filemanager/bkupengine/src/CMMCScBkupDataOwnerInfo.cpp Tue Feb 02 00:03:31 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,560 +0,0 @@ -/* -* 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: CMMCScBkupDataOwnerInfo implementation -* -* -*/ - -#include "CMMCScBkupDataOwnerInfo.h" - -// System includes -#include - -// User includes -#include "MMCScBkupLogger.h" -#include "MMCScBkupSBEUtils.h" -#include "MMMCScBkupArchiveDataInterface.h" -#include "CMMCScBkupDriveDataSizeManager.h" - -// Constants -_LIT_SECURE_ID(KMMCScBkupUninitialisedSecureId, 0); - - -// ========================= MEMBER FUNCTIONS ================================ - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::CMMCScBkupDataOwnerInfo() -// -// C++ constructor. -// --------------------------------------------------------------------------- -CMMCScBkupDataOwnerInfo::CMMCScBkupDataOwnerInfo( CDataOwnerInfo* aOwner ) -: iDataOwner(aOwner), iVersion(EStreamFormatVersionLatest-1) - { - SetStatus(EUnset); - // - iSecureId = KMMCScBkupUninitialisedSecureId; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::~CMMCScBkupDataOwnerInfo() -// -// Destructor. -// --------------------------------------------------------------------------- -CMMCScBkupDataOwnerInfo::~CMMCScBkupDataOwnerInfo() - { - delete iDataOwner; - delete iOperationalSize; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::ConstructL() -// -// -// --------------------------------------------------------------------------- -void CMMCScBkupDataOwnerInfo::ConstructL() - { - if ( iOperationalSize == NULL ) - { - iOperationalSize = CMMCScBkupDataTypeSizer::NewL(); - } - - // Try and extract the SID if its a package or a SID type - const TSBDerivedType type = iDataOwner->Identifier().DerivedTypeL(); - // - if (type == ESIDDerivedType || type == EPackageDerivedType) - { - iSecureId = MMCScBkupSBEUtils::SecureIdFromGenericL(iDataOwner->Identifier()); - if( iSecureId.iId == KNullUid.iUid && iVersion > EStreamFormatVersion1 ) - { - iSecureId = MMCScBkupSBEUtils::PackageIdFromGenericL(iDataOwner->Identifier()); - } - } - - // The following code sets the completion status to ETrue - // for any irrelevant items associated with a data owner. I.e. if - // a data owner doesn't support active backup, then it sets the completion - // of active backup to ETrue. This makes writing the logic inside the - // active/passive/system backup items a little easier (active in particular) - const TBool hasJavaData = HasJavaDataL(); - const TBool hasActiveData = HasActiveDataL(); - const TBool hasPassiveData = HasPassiveDataL(); - const TBool hasPublicData = HasPublicDataL(); - const TBool hasSystemData = HasSystemDataL(); - - // Update completion statuses (i.e. "what work must be done") - SetCompletionStatus( EMMCScBkupOwnerDataTypeJavaData, !hasJavaData ); - SetCompletionStatus( EMMCScBkupOwnerDataTypeActiveData, !hasActiveData ); - SetCompletionStatus( EMMCScBkupOwnerDataTypePassiveData, !hasPassiveData ); - SetCompletionStatus( EMMCScBkupOwnerDataTypePublicData, !hasPublicData ); - SetCompletionStatus( EMMCScBkupOwnerDataTypeSystemData, !hasSystemData ); - - // Be aware that CMMCScBkupStateRequestSizeOfDataOwner::GetJavaDataSizesL() can - // manipulate the passive data completion status depending on whether the midlet - // has associated data files. - - // If we're logging, then we write out some useful debugging info that shows - // which operations must be performed for each D.O. -#ifdef __MMCSCBKUPLOGGING_ENABLED__ - TBuf<256> drivePrint; - const TDriveList& driveList = iDataOwner->DriveList(); - - for(TInt i=0; iIdentifier() ); - __LOG7("CMMCScBkupDataOwnerInfo::ConstructL() - PubD: %d, ActD: %d, PasD: %d, JavD: %d, SysD: %d, drives: %S, hash: %S", hasPublicData, hasActiveData, hasPassiveData, hasJavaData, hasSystemData, &drivePrint, hash); - CleanupStack::PopAndDestroy( hash ); - } - else - { - __LOG8("CMMCScBkupDataOwnerInfo::ConstructL() - PubD: %d, ActD: %d, PasD: %d, JavD: %d, SysD: %d, drives: %S, SID : 0x%08x %S", hasPublicData, hasActiveData, hasPassiveData, hasJavaData, hasSystemData, &drivePrint, iSecureId.iId, &MMCScBkupLogger::FriendlyNameForSID( iSecureId )); - } -#endif - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::New() -// -// -// --------------------------------------------------------------------------- -CMMCScBkupDataOwnerInfo* CMMCScBkupDataOwnerInfo::New( TSecureId aSecureId ) - { - CMMCScBkupDataOwnerInfo* self = new CMMCScBkupDataOwnerInfo( NULL ); - if (self) - { - self->iSecureId = aSecureId; - } - return self; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::NewLC() -// -// -// --------------------------------------------------------------------------- -CMMCScBkupDataOwnerInfo* CMMCScBkupDataOwnerInfo::NewLC( CDataOwnerInfo* aOwner ) - { - CleanupStack::PushL(aOwner); - CMMCScBkupDataOwnerInfo* self = new(ELeave) CMMCScBkupDataOwnerInfo( aOwner ); - CleanupStack::Pop(aOwner); - CleanupStack::PushL(self); - self->ConstructL(); - return self; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::NewLC() -// -// -// --------------------------------------------------------------------------- -CMMCScBkupDataOwnerInfo* CMMCScBkupDataOwnerInfo::NewLC( RReadStream& aStream ) - { - CMMCScBkupDataOwnerInfo* self = new(ELeave) CMMCScBkupDataOwnerInfo(); - CleanupStack::PushL(self); - aStream >> *self; - self->ConstructL(); - return self; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::Owner() -// -// -// --------------------------------------------------------------------------- -CDataOwnerInfo& CMMCScBkupDataOwnerInfo::Owner() - { - return *iDataOwner; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::Owner() -// -// -// --------------------------------------------------------------------------- -const CDataOwnerInfo& CMMCScBkupDataOwnerInfo::Owner() const - { - return *iDataOwner; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::Status() -// -// -// --------------------------------------------------------------------------- -TDataOwnerStatus CMMCScBkupDataOwnerInfo::Status() const - { - return iStatus; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::SetStatus() -// -// -// --------------------------------------------------------------------------- -void CMMCScBkupDataOwnerInfo::SetStatus(TDataOwnerStatus aStatus) - { - iStatus = aStatus; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::AddToOperationalSizeL() -// -// -// --------------------------------------------------------------------------- -void CMMCScBkupDataOwnerInfo::AddToOperationalSizeL( TMMCScBkupOwnerDataType aType, TDriveNumber aDrive, TInt64 aSize ) - { - iOperationalSize->AddToSizeL( aType, aSize, aDrive ); - -#if defined(__MMCSCBKUPLOGGING_ENABLED__) - const TInt64 newSize = iOperationalSize->Size( aType, aDrive ); - __LOG5("CMMCScBkupDataOwnerInfo::AddToOperationalSizeL() - [0x%08x] - aSize: %8Ld, newSize: %8Ld, aDrive: %c:, aType: %S", iSecureId.iId, aSize, newSize, aDrive + 'A', &MMCScBkupLogger::DataType( aType ) ); -#endif - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::SetOperationalSizeL() -// -// -// --------------------------------------------------------------------------- -void CMMCScBkupDataOwnerInfo::SetOperationalSizeL( TMMCScBkupOwnerDataType aType, TDriveNumber aDrive, TInt64 aSize ) - { - iOperationalSize->Reset( aType, aDrive ); - iOperationalSize->AddToSizeL( aType, aSize, aDrive ); - - __LOG4("CMMCScBkupDataOwnerInfo::SetOperationalSizeL() - [0x%08x] - aSize: %8Ld, aDrive: %c:, aType: %S", iSecureId.iId, aSize, aDrive + 'A', &MMCScBkupLogger::DataType( aType ) ); - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::ResetOperationalSize() -// -// -// --------------------------------------------------------------------------- -void CMMCScBkupDataOwnerInfo::ResetOperationalSize( TMMCScBkupOwnerDataType aType ) - { - iOperationalSize->Reset( aType ); - __LOG2("CMMCScBkupDataOwnerInfo::ResetOperationalSize() - [0x%08x] - aType: %S", iSecureId.iId, &MMCScBkupLogger::DataType( aType ) ); - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::OperationalSize() -// -// -// --------------------------------------------------------------------------- -TInt64 CMMCScBkupDataOwnerInfo::OperationalSize( TMMCScBkupOwnerDataType aType, TDriveNumber aDrive ) const - { - const TInt64 size = iOperationalSize->Size( aType, aDrive ); - - __LOG4("CMMCScBkupDataOwnerInfo::OperationalSize() - [0x%08x] - size: %8Ld, aDrive: %c:, aType: %S", iSecureId.iId, size, aDrive + 'A', &MMCScBkupLogger::DataType( aType ) ); - - return size; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::OperationalSize() -// -// -// --------------------------------------------------------------------------- -TInt64 CMMCScBkupDataOwnerInfo::OperationalSize( TMMCScBkupOwnerDataType aType ) const - { - const TInt64 size = iOperationalSize->Size( aType ); - - //__LOG3("CMMCScBkupDataOwnerInfo::OperationalSize() - [0x%08x] - size: %8Ld, aType: %S", iSecureId.iId, size, &MMCScBkupLogger::DataType( aType ) ); - - return size; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::OperationalSize() -// -// -// --------------------------------------------------------------------------- -TInt64 CMMCScBkupDataOwnerInfo::OperationalSize( TDriveNumber aDrive ) const - { - const TInt64 size = iOperationalSize->CombinedSize( aDrive ); - - //__LOG3("CMMCScBkupDataOwnerInfo::OperationalSize() - [0x%08x] - size: %8Ld, aDrive: %c:", iSecureId.iId, size, aDrive + 'A' ); - - return size; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::OperationalSizesL() -// -// -// --------------------------------------------------------------------------- -void CMMCScBkupDataOwnerInfo::OperationalSizesL( RArray& aSizes ) const - { - iOperationalSize->GetSizesL( aSizes ); - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::SetCompletionStatus() -// -// -// --------------------------------------------------------------------------- -void CMMCScBkupDataOwnerInfo::SetCompletionStatus( TMMCScBkupOwnerDataType aType, TBool aCompleted ) - { - iCompletionStatus[aType] = aCompleted; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::CompletionStatus() -// -// -// --------------------------------------------------------------------------- -TBool CMMCScBkupDataOwnerInfo::CompletionStatus( TMMCScBkupOwnerDataType aType ) const - { - return iCompletionStatus[aType]; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::ActiveDataRetryCount() -// -// -// --------------------------------------------------------------------------- -TInt CMMCScBkupDataOwnerInfo::ActiveDataRetryCount() const - { - return iActiveDataRetryCount; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::SetActiveDataRetryCount() -// -// -// --------------------------------------------------------------------------- -void CMMCScBkupDataOwnerInfo::SetActiveDataRetryCount(TInt aCount) - { - iActiveDataRetryCount = aCount; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::InternalizeL() -// -// -// --------------------------------------------------------------------------- -void CMMCScBkupDataOwnerInfo::InternalizeL(RReadStream& aStream) - { - iVersion = aStream.ReadInt32L(); // EStreamFormatVersionX - aStream.ReadInt32L(); // spare1 - aStream.ReadInt32L(); // spare2 - aStream.ReadInt32L(); // spare3 - - // Secure ID - iSecureId = aStream.ReadInt32L(); - - // Data sizes - CMMCScBkupDataTypeSizer* operationalSize = CMMCScBkupDataTypeSizer::NewLC( aStream ); - delete iOperationalSize; - iOperationalSize = operationalSize; - CleanupStack::Pop( operationalSize ); - - // Read data owner buffer length - TCardinality dataOwnerLength; - aStream >> dataOwnerLength; - - // Internalize the data owner (as raw descriptor) - HBufC8* dataOwnerBuffer = HBufC8::NewLC( dataOwnerLength ); - TPtr8 pDataOwnerBuffer( dataOwnerBuffer->Des() ); - aStream.ReadL( pDataOwnerBuffer, dataOwnerLength ); - // - CDataOwnerInfo* dataOwner = CDataOwnerInfo::NewL( *dataOwnerBuffer ); - delete iDataOwner; - iDataOwner = dataOwner; - CleanupStack::PopAndDestroy( dataOwnerBuffer ); - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::ExternalizeL() -// -// -// --------------------------------------------------------------------------- -void CMMCScBkupDataOwnerInfo::ExternalizeL(RWriteStream& aStream) const - { - aStream.WriteInt32L( EStreamFormatVersion2 ); - aStream.WriteInt32L( 0 ); // spare1 - aStream.WriteInt32L( 0 ); // spare2 - aStream.WriteInt32L( 0 ); // spare3 - - // Always write secure id - aStream.WriteInt32L( iSecureId ); - - // ... and always write the data sizes - aStream << *iOperationalSize; - - // Externalize the data owner to an HBufC8 - HBufC8* dataOwnerBuffer = iDataOwner->ExternaliseL(); - CleanupStack::PushL( dataOwnerBuffer ); - - // Write leading byte count - helps us when it comes to internalising - const TCardinality dataOwnerLength( dataOwnerBuffer->Length() ); - aStream << dataOwnerLength; - - // Now write the data owner buffer - not using chevrons just in case it - // does funny unicode compression stuff... - aStream.WriteL( *dataOwnerBuffer ); - - CleanupStack::PopAndDestroy(dataOwnerBuffer); - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::CompareDataOwnerBySIDL() -// -// -// --------------------------------------------------------------------------- -TBool CMMCScBkupDataOwnerInfo::CompareDataOwnerBySIDL(const CMMCScBkupDataOwnerInfo& aLeft, const CMMCScBkupDataOwnerInfo& aRight) - { - TBool same = EFalse; - - // If we have an owner object, then we first compare the derived types. - // If not, we just directly compare the SIDs - if ( aLeft.iDataOwner && aRight.iDataOwner ) - { - const TSBDerivedType leftType = aLeft.Owner().Identifier().DerivedTypeL(); - const TSBDerivedType rightType = aRight.Owner().Identifier().DerivedTypeL(); - // - same = ((leftType == rightType) || - (leftType == ESIDDerivedType && rightType == EPackageDerivedType) || - (leftType == EPackageDerivedType && rightType == ESIDDerivedType) - ); - } - else if ( aRight.iDataOwner ) - { - // Check that it is not Java data owner in question. Java DOs all have - // secure id 0x0, but it could also be the case for certain package - // data owners (see for KDummyId in SBE implementation). - if( !MMCScBkupSBEUtils::HasJavaDataL( aRight.Owner() ) ) - { - // ..set to ETrue to trip next if-statement - same = ETrue; - } - } - - // Now compare the SID's themselves - if ( same ) - { - same = (aLeft.SecureId() == aRight.SecureId()); - } - // - return same; - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::HasJavaDataL() -// -// -// --------------------------------------------------------------------------- -TBool CMMCScBkupDataOwnerInfo::HasJavaDataL() const - { - const TBool hasJavaData = MMCScBkupSBEUtils::HasJavaDataL( *iDataOwner ); - const TInt64 opSize = OperationalSize( EMMCScBkupOwnerDataTypeJavaData ); - // - return hasJavaData || (opSize > 0 ); - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::HasActiveDataL() -// -// -// --------------------------------------------------------------------------- -TBool CMMCScBkupDataOwnerInfo::HasActiveDataL() const - { - const TBool hasActiveData = MMCScBkupSBEUtils::HasActiveDataL( *iDataOwner ); - const TInt64 opSize = OperationalSize( EMMCScBkupOwnerDataTypeActiveData ); - // - return hasActiveData || (opSize > 0 ); - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::HasPassiveDataL() -// -// -// --------------------------------------------------------------------------- -TBool CMMCScBkupDataOwnerInfo::HasPassiveDataL() const - { - const TBool hasPassiveData = MMCScBkupSBEUtils::HasPassiveDataL( *iDataOwner ); - const TInt64 opSize = OperationalSize( EMMCScBkupOwnerDataTypePassiveData ); - // - return hasPassiveData || (opSize > 0 ); - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::HasPublicDataL() -// -// -// --------------------------------------------------------------------------- -TBool CMMCScBkupDataOwnerInfo::HasPublicDataL() const - { - const TBool hasPublicData = MMCScBkupSBEUtils::HasPublicDataL( *iDataOwner ); - const TInt64 opSize = OperationalSize( EMMCScBkupOwnerDataTypePublicData ); - // - return hasPublicData || (opSize > 0 ); - } - - -// --------------------------------------------------------------------------- -// CMMCScBkupDataOwnerInfo::HasSystemDataL() -// -// -// --------------------------------------------------------------------------- -TBool CMMCScBkupDataOwnerInfo::HasSystemDataL() const - { - const TBool hasSystemData = MMCScBkupSBEUtils::HasSystemDataL( *iDataOwner ); - const TInt64 opSize = OperationalSize( EMMCScBkupOwnerDataTypeSystemData ); - // - return hasSystemData || (opSize > 0 ); - } - - - -