/*
* Copyright (c) 2007-2008 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:   This module contains the implementation of CIAUpdateControllerFile 
*                class  member functions.
*
*/




#include <bautils.h>
#include <s32file.h>
#include <sysutil.h>

#include "iaupdatecontrollerfile.h"
#include "iaupdatectrlfileconsts.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 );

const TInt KSizeOfFile( 16 );
    

// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::NewL
//
// -----------------------------------------------------------------------------
//
EXPORT_C CIAUpdateControllerFile* CIAUpdateControllerFile::NewL( 
    const TDesC& aFile )
    {
    CIAUpdateControllerFile* self =
        CIAUpdateControllerFile::NewLC( aFile );
    CleanupStack::Pop( self );
    return self;
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::NewLC
//
// -----------------------------------------------------------------------------
//
EXPORT_C CIAUpdateControllerFile* CIAUpdateControllerFile::NewLC( 
    const TDesC& aFile )
    {
    CIAUpdateControllerFile* self =
        new( ELeave) CIAUpdateControllerFile();
    CleanupStack::PushL( self );
    self->ConstructL( aFile );
    return self;    
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::CIAUpdateControllerFile
//
// -----------------------------------------------------------------------------
//
CIAUpdateControllerFile::CIAUpdateControllerFile()
: CBase(),
  iRefreshTime( 0 ),
  iLanguage( User::Language() )
    {
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::ConstructL
//
// -----------------------------------------------------------------------------
//
void CIAUpdateControllerFile::ConstructL( const TDesC& aFile )
    {
    User::LeaveIfError( iFsSession.Connect() );
    User::LeaveIfError( 
        iFsSession.SetSessionToPrivate( 
            IAUpdateCtrlFileConsts::KDrive ) );
    
    User::LeaveIfError( iFsSession.SessionPath( iPath ) );
    BaflUtils::EnsurePathExistsL( iFsSession, iPath );
    iPath.Append( aFile );
    
    // Read data from the file if the file exists.
    // Otherwise, let default values remain.
    ReadControllerDataL(); 
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::~CIAUpdateControllerFile
//
// -----------------------------------------------------------------------------
//
EXPORT_C CIAUpdateControllerFile::~CIAUpdateControllerFile()
    {
    iFsSession.Close();
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::ReadControllerDataL
//
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CIAUpdateControllerFile::ReadControllerDataL()
	{
	RFile file;
    TInt err = file.Open( iFsSession, iPath, EFileRead|EFileShareAny );
    if ( err == KErrNotFound )
    	{
    	// File did not exist. 
    	// So, nothing to do here anymore.
    	return EFalse;
    	}
    User::LeaveIfError( err );
    	
    CleanupClosePushL( file );
    
    RFileReadStream stream( file, 0 );
    CleanupClosePushL( stream );

    InternalizeL( stream );

    CleanupStack::PopAndDestroy( &stream );
    CleanupStack::PopAndDestroy( &file );

    return ETrue;
	}


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::WriteControllerDataL
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdateControllerFile::WriteControllerDataL()
	{
	TDriveUnit driveUnit( IAUpdateCtrlFileConsts::KDrive );
	if ( SysUtil::DiskSpaceBelowCriticalLevelL( 
	        &iFsSession, KSizeOfFile, driveUnit ) )
	    {
		User::Leave( KErrDiskFull );
	    }
	
	RFile file;
    User::LeaveIfError( 
        file.Replace( iFsSession, iPath, EFileWrite|EFileShareAny ) );
    CleanupClosePushL( file );
    
    RFileWriteStream stream( file, 0 );
    CleanupClosePushL( stream );

    ExternalizeL( stream );
    
    stream.CommitL();
    
    CleanupStack::PopAndDestroy( &stream );
    CleanupStack::PopAndDestroy( &file );
	}


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::SetCurrentData
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdateControllerFile::SetCurrentData()
    {
    SetCurrentRefreshTime();
    SetCurrentLanguage();
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::RefreshTime
//
// -----------------------------------------------------------------------------
//
EXPORT_C const TTime& CIAUpdateControllerFile::RefreshTime() const
    {
    return iRefreshTime;
    }
    

// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::SetRefreshTime
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdateControllerFile::SetRefreshTime( const TTime& aTime )
    {
    iRefreshTime = aTime;
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::SetRefreshTime
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdateControllerFile::SetRefreshTime( TInt64 aTime )
    {
    iRefreshTime = aTime;
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::SetCurrentRefreshTime
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdateControllerFile::SetCurrentRefreshTime()
    {
    TTime universalTime;
    universalTime.UniversalTime();
    iRefreshTime = universalTime;
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::Language
//
// -----------------------------------------------------------------------------
//
EXPORT_C TLanguage CIAUpdateControllerFile::Language() const
    {
    return iLanguage;
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::SetLanguage
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdateControllerFile::SetLanguage( TLanguage aLanguage )
    {
    iLanguage = aLanguage;
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::SetCurrentLanguage
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CIAUpdateControllerFile::SetCurrentLanguage()
    {
    SetLanguage( User::Language() );
    }


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::InternalizeL
//
// -----------------------------------------------------------------------------
//
void CIAUpdateControllerFile::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 );
        }
	
	TInt64 refreshTime( 0 );
	aStream >> refreshTime;
    SetRefreshTime( refreshTime );
    
    TInt language( aStream.ReadInt32L() );
    // Static casting is safe to do here because enum and TInt are the same.
    SetLanguage( static_cast< TLanguage >( language ) );
	}


// -----------------------------------------------------------------------------
// CIAUpdateControllerFile::ExternalizeL
//
// -----------------------------------------------------------------------------
//
void CIAUpdateControllerFile::ExternalizeL( RWriteStream& aStream )
	{
	// If you make changes here, 
	// remember to update InternalizeL accordingly!!!

    aStream.WriteInt32L( KVersion );
	
	TInt64 refreshTime( RefreshTime().Int64() );
	aStream << refreshTime;

    TInt language( Language() );
    aStream.WriteInt32L( language );
	}