diff -r 000000000000 -r 6a9f87576119 filemanager/bkupengine/src/CMMCScBkupDataOwnerInfo.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/filemanager/bkupengine/src/CMMCScBkupDataOwnerInfo.cpp Mon Jan 18 20:09:41 2010 +0200 @@ -0,0 +1,560 @@ +/* +* 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 ); + } + + + +