/*

* 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:    

*

*/

// INCLUDE FILES

#include "iaupdatequeryhistory.h"

#include "iaupdatedebug.h"

#include "iaupdatedialogutil.h"

#include <bautils.h>  // bafl.lib 

#include <s32file.h>  // estor.lib

#include <sysutil.h>

// CONSTANTS

const TInt KHistoryDrive( EDriveC );

const TInt KHistoryItemSize( 12 );

// MACROS

_LIT( KHistoryFile, "IADQueryHistory" );

/*******************************************************************************

 * class TIAUpdateQueryHistoryItem

 *******************************************************************************/

// -----------------------------------------------------------------------------

// TIAUpdateQueryHistoryItem::Time

//

// -----------------------------------------------------------------------------

//

TTime TIAUpdateQueryHistoryItem::Time()

	{

	return iTime;

	}

// -----------------------------------------------------------------------------

// TIAUpdateQueryHistoryItem::SetTime

//

// -----------------------------------------------------------------------------

//

void TIAUpdateQueryHistoryItem::SetTime( TTime aTime )

	{

	iTime = aTime;

	}

// -----------------------------------------------------------------------------

// TIAUpdateQueryHistoryItem::InternalizeL

//

// -----------------------------------------------------------------------------

//

void TIAUpdateQueryHistoryItem::InternalizeL( RReadStream& aStream )

	{

	iUid = aStream.ReadUint32L();

	TInt64 temp = 0;

	aStream >> temp;

	if ( temp <= 0 )

	    {

	    User::Leave( KErrCorrupt );

	    }

	TTime time( temp );

	iTime = time;

	}

// -----------------------------------------------------------------------------

// TIAUpdateQueryHistoryItem::ExternalizeL

//

// -----------------------------------------------------------------------------

//

void TIAUpdateQueryHistoryItem::ExternalizeL( RWriteStream& aStream )

	{

	aStream.WriteUint32L( iUid );

	aStream << iTime.Int64();

	}

/*******************************************************************************

 * class CIAUpdateQueryHistory

 *******************************************************************************/

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::NewL

//

// -----------------------------------------------------------------------------

//

CIAUpdateQueryHistory* CIAUpdateQueryHistory::NewL()

    {

    CIAUpdateQueryHistory* self = new (ELeave) CIAUpdateQueryHistory();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return(self);

    }

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::CIAUpdateQueryHistory

// 

// -----------------------------------------------------------------------------

//

CIAUpdateQueryHistory::CIAUpdateQueryHistory()

: iDelay( KDefaultDelayHours )

	{

    }

// ----------------------------------------------------------------------------

// Destructor

//

// ----------------------------------------------------------------------------

//

CIAUpdateQueryHistory::~CIAUpdateQueryHistory()

    {

    iList.Close();

    }

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::ConstructL

//

// -----------------------------------------------------------------------------

//

void CIAUpdateQueryHistory::ConstructL()

    {

    } 

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::SetTimeL

//

// -----------------------------------------------------------------------------

//

void CIAUpdateQueryHistory::SetTimeL( TUint aUid )

    {

    RFs fsSession;

    HBufC* path = HBufC::NewLC( KMaxFileName );

    TPtr pathPtr = path->Des();

    ConnectLC( fsSession, pathPtr );

    ReadHistoryL( fsSession, *path );

    TTime currentTime;

    currentTime.UniversalTime();

    TIAUpdateQueryHistoryItem item;

    item.iUid = aUid;

    item.SetTime( currentTime );

    AddItemL( item );

    WriteHistoryL( fsSession, *path );

    CleanupStack::PopAndDestroy( &fsSession ); 

    CleanupStack::PopAndDestroy( path ); 

    }

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::SetDelay

//

// -----------------------------------------------------------------------------

//

void CIAUpdateQueryHistory::SetDelay( TInt aHours )

    {

    iDelay = aHours;

    }

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::IsDelayedL

//

// -----------------------------------------------------------------------------

//

TBool CIAUpdateQueryHistory::IsDelayedL( TUint aUid )

    {

    RFs fsSession;

    HBufC* path = HBufC::NewLC( KMaxFileName );

    TPtr pathPtr = path->Des();

    ConnectLC( fsSession, pathPtr );

    ReadHistoryL( fsSession, *path );

    CleanupStack::PopAndDestroy( &fsSession ); 

    CleanupStack::PopAndDestroy( path );

    TInt index = ItemIndex( aUid );

    if ( index == KErrNotFound )

        {

        return EFalse; // no history data for this uid

        }

    TIAUpdateQueryHistoryItem& item = Item( index );

    return IsDelayed( item );

    }

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::ConnectLC

//

// -----------------------------------------------------------------------------

//

void CIAUpdateQueryHistory::ConnectLC( RFs& aFsSession, TDes& aPath )

    {

    User::LeaveIfError( aFsSession.Connect() );

    CleanupClosePushL( aFsSession );

    User::LeaveIfError( aFsSession.SetSessionToPrivate( KHistoryDrive ) );

    // sessionpath in emulator: '\epoc32\winscw\c\private\2000F85A'

    User::LeaveIfError( aFsSession.SessionPath( aPath ) );

    BaflUtils::EnsurePathExistsL( aFsSession, aPath );

    aPath.Append( KHistoryFile );

    }

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::InternalizeL

//

// -----------------------------------------------------------------------------

//

void CIAUpdateQueryHistory::InternalizeL( RReadStream& aStream )

	{

	TInt count = aStream.ReadInt32L();

	if ( count < 0 )

	    {

	    User::Leave( KErrCorrupt );

	    }

	for (TInt i = 0; i< count; i++ )

		{

		TIAUpdateQueryHistoryItem item;

		item.InternalizeL( aStream );

		iList.AppendL( item );

		}

	}

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::ExternalizeL

//

// -----------------------------------------------------------------------------

//

void CIAUpdateQueryHistory::ExternalizeL( RWriteStream& aStream )

	{

	TInt count = iList.Count();

	aStream.WriteInt32L( count );

	for (TInt i = 0; i < count; i++ )

		{

		TIAUpdateQueryHistoryItem& item = iList[i];

		item.ExternalizeL( aStream );

		}

	}

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::ReadHistoryL

//

// -----------------------------------------------------------------------------

//

void CIAUpdateQueryHistory::ReadHistoryL( RFs& aFsSession, const TDesC& aPath )

	{

	iList.Reset();

	RFile file;

    TInt err = file.Open( aFsSession, aPath, EFileRead|EFileShareAny );

    if ( err != KErrNotFound )

    	{

    	User::LeaveIfError( err );

    	CleanupClosePushL( file );

        RFileReadStream stream( file, 0 );

        CleanupClosePushL( stream );

        InternalizeL( stream );

        CleanupStack::PopAndDestroy( &stream );

        CleanupStack::PopAndDestroy( &file );

    	}

 	}

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::WriteHistoryL

//

// -----------------------------------------------------------------------------

//

void CIAUpdateQueryHistory::WriteHistoryL( RFs& aFsSession, const TDesC& aPath )

	{

	TDriveUnit driveUnit( KHistoryDrive );

	if ( SysUtil::DiskSpaceBelowCriticalLevelL( &aFsSession, KHistoryItemSize, driveUnit ) )

	    {

		User::Leave( KErrDiskFull );

	    }

	RFile file;

    User::LeaveIfError( file.Replace( aFsSession, aPath, EFileWrite|EFileShareAny ) );

    CleanupClosePushL( file );

    RFileWriteStream stream( file, 0 );

    CleanupClosePushL( stream );

    ExternalizeL( stream );

    stream.CommitL();

    CleanupStack::PopAndDestroy( &stream );

    CleanupStack::PopAndDestroy( &file );

	}

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::IsDelayed

//

// -----------------------------------------------------------------------------

//

TBool CIAUpdateQueryHistory::IsDelayed( TIAUpdateQueryHistoryItem& aItem )

    {

    TTime currentTime;

    currentTime.UniversalTime();

    TTime lastQueryTime = aItem.Time();

    TTimeIntervalHours hours;

    TInt err = currentTime.HoursFrom( lastQueryTime, hours );

    if ( err != KErrNone )

        {

        return EFalse;

        }

    TInt hourCount = hours.Int();

    if ( hourCount >= 0 && hourCount < iDelay )

        {

        return ETrue;

        }

    return EFalse;

    }

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::AddItemL

//

// -----------------------------------------------------------------------------

//

void CIAUpdateQueryHistory::AddItemL( TIAUpdateQueryHistoryItem aItem )

	{

	TInt index = ItemIndex( aItem.iUid );

	if ( index != KErrNotFound )

		{

		iList.Remove( index );

		}

	User::LeaveIfError( iList.Append( aItem ) );

	}

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::ItemIndex

//

// -----------------------------------------------------------------------------

//

TInt CIAUpdateQueryHistory::ItemIndex( TUint aUid )

	{

	TInt count = iList.Count();

	for (TInt i=0; i < count; i++)

		{

		TIAUpdateQueryHistoryItem& item= iList[i];

		if ( item.iUid == aUid )

			{

			return i;

			}

		}

	return KErrNotFound;

	}

// -----------------------------------------------------------------------------

// CIAUpdateQueryHistory::Item

//

// -----------------------------------------------------------------------------

//

TIAUpdateQueryHistoryItem& CIAUpdateQueryHistory::Item( TInt aIndex )

	{

	return iList[aIndex];

	}

//  End of File