diff -r 000000000000 -r ba25891c3a9e iaupdate/IAD/updater/updaterfiles/src/iaupdaterresultsfile.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/iaupdate/IAD/updater/updaterfiles/src/iaupdaterresultsfile.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,479 @@ +/* +* Copyright (c) 2007-2007 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: CIAUpdaterResultsFile +* +*/ + + + + +#include +#include +#include + +#include "iaupdaterresultsfile.h" +#include "iaupdateridentifier.h" +#include "iaupdaterfileconsts.h" +#include "iaupdaterresult.h" +#include "iaupdatedebug.h" + + +// This constant will be used to check if the IAD application +// and iaupdater are using the same version of the file. If the versions +// differ, then this may require additional checking in the future versions +// when data is internalized. For example, IAD may give old version data +// for iaupdater during self update just after iaupdater has been updated +// and IAD is itself updated after that. +const TInt KVersion( 1 ); + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::NewL +// +// ----------------------------------------------------------------------------- +// +EXPORT_C CIAUpdaterResultsFile* CIAUpdaterResultsFile::NewL() + { + CIAUpdaterResultsFile* self = + CIAUpdaterResultsFile::NewLC(); + CleanupStack::Pop( self ); + return self; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::NewLC +// +// ----------------------------------------------------------------------------- +// +EXPORT_C CIAUpdaterResultsFile* CIAUpdaterResultsFile::NewLC() + { + CIAUpdaterResultsFile* self = + new( ELeave) CIAUpdaterResultsFile(); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::CIAUpdaterResultsFile +// +// ----------------------------------------------------------------------------- +// +CIAUpdaterResultsFile::CIAUpdaterResultsFile() +: CBase() + { + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::ConstructL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdaterResultsFile::ConstructL() + { + IAUPDATE_TRACE("[IAUpdater] CIAUpdaterResultsFile::ConstructL start"); + + User::LeaveIfError( iFsSession.Connect() ); + User::LeaveIfError( + iFsSession.SetSessionToPrivate( + IAUpdaterFileConsts::KDrive ) ); + User::LeaveIfError( iFsSession.SessionPath( iPath ) ); + BaflUtils::EnsurePathExistsL( iFsSession, iPath ); + iPath.Append( IAUpdaterFileConsts::KResultsFile() ); + + IAUPDATE_TRACE_1("[IAUpdater] CIAUpdaterResultsFile::ConstructL end: %S", &iPath); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::~CIAUpdaterResultsFile +// +// ----------------------------------------------------------------------------- +// +EXPORT_C CIAUpdaterResultsFile::~CIAUpdaterResultsFile() + { + iFsSession.Close(); + + iResults.ResetAndDestroy(); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::SuccessCount +// +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CIAUpdaterResultsFile::SuccessCount() const + { + TInt count( 0 ); + + for ( TInt i = 0; i < iResults.Count(); ++i ) + { + CIAUpdaterResult* result( iResults[ i ] ); + if ( result->ErrorCode() == KErrNone + && !result->Hidden() ) + { + ++count; + } + } + + return count; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::FailCount +// +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CIAUpdaterResultsFile::FailCount() const + { + TInt count( 0 ); + + for ( TInt i = 0; i < iResults.Count(); ++i ) + { + CIAUpdaterResult* result( iResults[ i ] ); + if ( result->ErrorCode() != KErrNone + && result->ErrorCode() != KErrCancel + && !result->Hidden() ) + { + ++count; + } + } + + return count; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::CancelCount +// +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CIAUpdaterResultsFile::CancelCount() const + { + TInt count( 0 ); + + for ( TInt i = 0; i < iResults.Count(); ++i ) + { + CIAUpdaterResult* result( iResults[ i ] ); + if ( result->ErrorCode() == KErrCancel + && !result->Hidden() ) + { + ++count; + } + } + + return count; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::Reset +// +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIAUpdaterResultsFile::Reset() + { + iPckgStartIndex = 0; + iTotalPckgCount = 0; + iResults.ResetAndDestroy(); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::PckgStartIndex +// +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CIAUpdaterResultsFile::PckgStartIndex() const + { + return iPckgStartIndex; + } + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::SetPckgStartIndex +// +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIAUpdaterResultsFile::SetPckgStartIndex( const TInt& aIndex ) + { + iPckgStartIndex = aIndex; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::TotalPckgCount +// +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CIAUpdaterResultsFile::TotalPckgCount() const + { + return iTotalPckgCount; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::SetTotalPckgCount +// +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIAUpdaterResultsFile::SetTotalPckgCount( const TInt& aCount ) + { + iTotalPckgCount = aCount; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::Results +// +// ----------------------------------------------------------------------------- +// +EXPORT_C RPointerArray< CIAUpdaterResult >& CIAUpdaterResultsFile::Results() + { + return iResults; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::FilePath +// +// ----------------------------------------------------------------------------- +// +EXPORT_C const TDesC& CIAUpdaterResultsFile::FilePath() const + { + return iPath; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::SetFilePathL +// +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIAUpdaterResultsFile::SetFilePathL( const TDesC& aPath ) + { + IAUPDATE_TRACE_1("[IAUpdater] CIAUpdaterResultsFile::SetFilePathL old path: %S", &iPath); + + TParsePtrC path( aPath ); + + if ( !path.NamePresent() ) + { + IAUPDATE_TRACE("[IAUpdater] No file name"); + // Do not accept path that does not contain file name. + User::Leave( KErrArgument ); + } + + if ( path.PathPresent() || path.DrivePresent() ) + { + IAUPDATE_TRACE("[IAUpdater] Path present"); + if ( path.DrivePresent() ) + { + IAUPDATE_TRACE("[IAUpdater] Drive present"); + User::LeaveIfError( iFsSession.SetSessionPath( path.DriveAndPath() ) ); + // Because the path and the drive were given, the given parameter path + // can be used as it was given. + iPath.Copy( aPath ); + } + else + { + IAUPDATE_TRACE("[IAUpdater] Only path present"); + User::LeaveIfError( iFsSession.SetSessionPath( path.Path() ) ); + // Because the given path was missing the drive letter, + // get the correct path with some default drive letter from the + // session. + User::LeaveIfError( iFsSession.SessionPath( iPath ) ); + // Append the file name to the end of the path. + iPath.Append( path.NameAndExt() ); + } + } + else + { + IAUPDATE_TRACE("[IAUpdater] Path was not present"); + // Only the file name was given. So, use the session path to get the whole + // path of the file. + User::LeaveIfError( iFsSession.SessionPath( iPath ) ); + iPath.Append( aPath ); + } + + IAUPDATE_TRACE_1("[IAUpdater] CIAUpdaterResultsFile::SetFilePathL new path: %S", &iPath); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::ReadDataL +// +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CIAUpdaterResultsFile::ReadDataL() + { + IAUPDATE_TRACE_1("[IAUpdater] CIAUpdaterResultsFile::ReadDataL path: %S", &iPath); + + RFile file; + TInt err( file.Open( iFsSession, iPath, EFileRead ) ); + User::LeaveIfError( err ); + + CleanupClosePushL( file ); + + RFileReadStream stream( file, 0 ); + CleanupClosePushL( stream ); + + InternalizeL( stream ); + + CleanupStack::PopAndDestroy( &stream ); + CleanupStack::PopAndDestroy( &file ); + + IAUPDATE_TRACE("[IAUpdater] CIAUpdaterResultsFile::ReadDataL end"); + + return ETrue; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::WriteDataL +// +// ----------------------------------------------------------------------------- +// +EXPORT_C void CIAUpdaterResultsFile::WriteDataL() + { + IAUPDATE_TRACE_1("[IAUpdater] CIAUpdaterResultsFile::WriteDataL path: %S", &iPath); + + TInt sizeOfFile = sizeof( TInt ) //KVersion + + sizeof( TInt ) //iPckgStartIndex + + sizeof( TInt ) //iTotalPckgCount + + sizeof( TInt ); //iResults.Count() + + + TInt count( iResults.Count() ); + for( TInt i = 0; i < count; ++i ) + { + sizeOfFile += sizeof( TInt ) * 3; //version, error code, hidden flag + CIAUpdaterResult* result( iResults[ i ] ); + sizeOfFile += sizeof( TInt ) * 3; //version, length of Id, length of namespace, UId + sizeOfFile += result->Identifier().Id().Size(); //size of Id + sizeOfFile += result->Identifier().Namespace().Size(); //size of namespace + } + + + if ( SysUtil::DiskSpaceBelowCriticalLevelL( &iFsSession, + sizeOfFile, + IAUpdaterFileConsts::KDrive ) ) + { + User::Leave( KErrDiskFull ); + } + + + RFile file; + User::LeaveIfError( file.Replace( iFsSession, iPath, EFileWrite ) ); + CleanupClosePushL( file ); + + RFileWriteStream stream( file, 0 ); + CleanupClosePushL( stream ); + + ExternalizeL( stream ); + stream.CommitL(); + + CleanupStack::PopAndDestroy( &stream ); + CleanupStack::PopAndDestroy( &file ); + + IAUPDATE_TRACE("[IAUpdater] CIAUpdaterResultsFile::WriteDataL end"); + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::RemoveFile +// +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CIAUpdaterResultsFile::RemoveFile() + { + IAUPDATE_TRACE_1("[IAUpdater] CIAUpdaterResultsFile::RemoveFile path: %S", &iPath); + + // May either be a full path, or relative to the session path. + // Even if session path has already been set in the ConstructL, + // we do not use the relative path and only the hard coded filename here. + // A new path may have been given by calling SetFilePathL. So, use that + // value here. + TInt errorCode( BaflUtils::DeleteFile( iFsSession, iPath ) ); + + IAUPDATE_TRACE_1("[IAUpdater] CIAUpdaterResultsFile::RemoveFile end: %d", errorCode); + + return errorCode; + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::InternalizeL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdaterResultsFile::InternalizeL( RReadStream& aStream ) + { + // If you make changes here, + // remember to update ExternalizeL accordingly!!! + + TInt version( aStream.ReadInt32L() ); + + // Notice! In the future, some checking maybe required here + // to be sure that file version is correct and the data can be + // internalized correctly between different versions. + if ( version != KVersion ) + { + // For now, just leave with the corrupt error. + User::Leave( KErrCorrupt ); + } + + iPckgStartIndex = aStream.ReadInt32L(); + iTotalPckgCount = aStream.ReadInt32L(); + + iResults.ResetAndDestroy(); + TInt count( aStream.ReadInt32L() ); + for( TInt i = 0; i < count; ++i ) + { + CIAUpdaterResult* result( + CIAUpdaterResult::NewLC() ); + result->InternalizeL( aStream ); + iResults.AppendL( result ); + CleanupStack::Pop( result ); + } + } + + +// ----------------------------------------------------------------------------- +// CIAUpdaterResultsFile::ExternalizeL +// +// ----------------------------------------------------------------------------- +// +void CIAUpdaterResultsFile::ExternalizeL( RWriteStream& aStream ) + { + // If you make changes here, + // remember to update InternalizeL accordingly!!! + + aStream.WriteInt32L( KVersion ); + + aStream.WriteInt32L( iPckgStartIndex ); + aStream.WriteInt32L( iTotalPckgCount ); + + TInt count( iResults.Count() ); + aStream.WriteInt32L( count ); + + for( TInt i = 0; i < count; ++i ) + { + CIAUpdaterResult* result( iResults[ i ] ); + result->ExternalizeL( aStream ); + } + }