/*

* 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 );

	}