/*
* 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: CIAUpdatePendingNodesFile
*
*/
#include <bautils.h>
#include <s32file.h>
#include <sysutil.h>
#include "iaupdatependingnodesfile.h"
#include "iaupdatectrlfileconsts.h"
#include "iaupdateridentifier.h"
#include "iaupdatedebug.h"
// This constant will be used to check if the IAD application
// and its updates 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, previous IAD may give old version data
// into the file during self update.
const TInt KVersion( 1 );
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::NewL
//
// -----------------------------------------------------------------------------
//
EXPORT_C CIAUpdatePendingNodesFile* CIAUpdatePendingNodesFile::NewL()
{
CIAUpdatePendingNodesFile* self =
CIAUpdatePendingNodesFile::NewLC();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::NewLC
//
// -----------------------------------------------------------------------------
//
EXPORT_C CIAUpdatePendingNodesFile* CIAUpdatePendingNodesFile::NewLC()
{
CIAUpdatePendingNodesFile* self =
new( ELeave) CIAUpdatePendingNodesFile();
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::CIAUpdatePendingNodesFile
//
// -----------------------------------------------------------------------------
//
CIAUpdatePendingNodesFile::CIAUpdatePendingNodesFile()
: CBase()
{
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::ConstructL
//
// -----------------------------------------------------------------------------
//
void CIAUpdatePendingNodesFile::ConstructL()
{
IAUPDATE_TRACE("[IAUPDATE] CIAUpdatePendingNodesFile::ConstructL start");
User::LeaveIfError( iFsSession.Connect() );
User::LeaveIfError(
iFsSession.SetSessionToPrivate(
IAUpdateCtrlFileConsts::KDrive ) );
User::LeaveIfError( iFsSession.SessionPath( iPath ) );
BaflUtils::EnsurePathExistsL( iFsSession, iPath );
iPath.Append( IAUpdateCtrlFileConsts::KPendingNodesFile() );
IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdatePendingNodesFile::ConstructL end: %S", &iPath);
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::~CIAUpdatePendingNodesFile
//
// -----------------------------------------------------------------------------
//
EXPORT_C CIAUpdatePendingNodesFile::~CIAUpdatePendingNodesFile()
{
iFsSession.Close();
Reset();
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::Reset
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdatePendingNodesFile::Reset()
{
iIndex = 0;
iPendingNodes.ResetAndDestroy();
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::Index
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CIAUpdatePendingNodesFile::Index() const
{
return iIndex;
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::SetIndex
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdatePendingNodesFile::SetIndex( TInt aIndex )
{
iIndex = aIndex;
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::Results
//
// -----------------------------------------------------------------------------
//
EXPORT_C RPointerArray< CIAUpdaterIdentifier >& CIAUpdatePendingNodesFile::PendingNodes()
{
return iPendingNodes;
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::FilePath
//
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC& CIAUpdatePendingNodesFile::FilePath() const
{
return iPath;
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::SetFilePathL
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdatePendingNodesFile::SetFilePathL( const TDesC& aPath )
{
IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdatePendingNodesFile::SetFilePathL old path: %S", &iPath);
TParsePtrC path( aPath );
if ( !path.NamePresent() )
{
IAUPDATE_TRACE("[IAUPDATE] No file name");
// Do not accept path that does not contain file name.
User::Leave( KErrArgument );
}
if ( path.PathPresent() || path.DrivePresent() )
{
IAUPDATE_TRACE("[IAUPDATE] Path present");
if ( path.DrivePresent() )
{
IAUPDATE_TRACE("[IAUPDATE] 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("[IAUPDATE] 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("[IAUPDATE] 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("[IAUPDATE] CIAUpdatePendingNodesFile::SetFilePathL new path: %S", &iPath);
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::ReadDataL
//
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CIAUpdatePendingNodesFile::ReadDataL()
{
IAUPDATE_TRACE("[IAUPDATE] CIAUpdatePendingNodesFile::ReadDataL begin");
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("[IAUPDATE] CIAUpdatePendingNodesFile::ReadDataL end");
return ETrue;
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::WriteDataL
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdatePendingNodesFile::WriteDataL()
{
IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdatePendingNodesFile::ReadDataL path: %S", &iPath);
TInt sizeOfFile = 2 * sizeof( TInt ); //version, count of identifiers
TInt count( iPendingNodes.Count() );
for( TInt i = 0; i < count; ++i )
{
CIAUpdaterIdentifier* identifier( iPendingNodes[ i ] );
sizeOfFile += sizeof( TInt ) // version
+ identifier->Id().Size() //Id
+ sizeof( TInt ) //Id length
+ identifier->Namespace().Size() //namespace
+ sizeof( TInt ); //namespace length
}
if ( SysUtil::DiskSpaceBelowCriticalLevelL(
&iFsSession,
sizeOfFile,
IAUpdateCtrlFileConsts::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("[IAUPDATE] CIAUpdatePendingNodesFile::WriteDataL end");
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::RemoveFile
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CIAUpdatePendingNodesFile::RemoveFile()
{
IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdatePendingNodesfile::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("[IAUPDATE] CIAUpdatePendingNodesfile::RemoveFile end: %d", errorCode);
return errorCode;
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::InternalizeL
//
// -----------------------------------------------------------------------------
//
void CIAUpdatePendingNodesFile::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 );
}
iPendingNodes.ResetAndDestroy();
TInt count( aStream.ReadInt32L() );
for( TInt i = 0; i < count; ++i )
{
CIAUpdaterIdentifier* identifier( CIAUpdaterIdentifier::NewLC() );
identifier->InternalizeL( aStream );
iPendingNodes.AppendL( identifier );
CleanupStack::Pop( identifier );
}
iIndex = aStream.ReadInt32L();
}
// -----------------------------------------------------------------------------
// CIAUpdatePendingNodesFile::ExternalizeL
//
// -----------------------------------------------------------------------------
//
void CIAUpdatePendingNodesFile::ExternalizeL( RWriteStream& aStream )
{
// If you make changes here,
// remember to update InternalizeL accordingly!!!
aStream.WriteInt32L( KVersion );
TInt count( iPendingNodes.Count() );
aStream.WriteInt32L( count );
for( TInt i = 0; i < count; ++i )
{
CIAUpdaterIdentifier* identifier( iPendingNodes[ i ] );
identifier->ExternalizeL( aStream );
}
aStream.WriteInt32L( iIndex );
}