/*

* Copyright (c) 2006 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:  Container store utils implementation.

*

*/

// ========

// INCLUDES

// ========

#include "ContainerStoreUtils.h"

#include "ContainerStoreDeleteHandler.h"

#include <sysutil.h>

#include <d32dbms.h>  // database

#include <bautils.h>

//#include <s32crypt.h>

// =============

// LOCAL CLASSES

// =============

// =============================================================================

// CLASS: CCompactionHandler

// 

// This class performs database compaction operations incrementally using the

// RDbIncremental class.  Each active object invocation performs one step of the

// compaction.  

//

// The Symbian documentation explains that certain operations cannot be performed

// on the database while an incremental operation is in progress.  The Suspend

// and Resume functions are provided to suspend incremental operations until the

// database operation is completed.

//

// The wonderful Symbian documentation doesn't give a list of the functions that

// do not work during incremental operations.  In order to determine this, the

// code was temporarily modified to always have an incremental operation in

// progress, unless Suspend and Resume has been called.  The unit tester were

// executed, and each operation that had a problem was then wrapped with

// Suspend/Resume, and the code was then returned to its original state.

// =============================================================================

class CCompactionHandler : public CActive

    {

    public:

        // ==============

        // PUBLIC METHODS

        // ==============

        static CCompactionHandler* NewL( RDbDatabase& aDatabase,

                                         TInt         aPriority );  

        virtual ~CCompactionHandler();

        void Compact();

        void Suspend();

        void SuspendLC();

        void Resume( TBool aPopCleanupItem = ETrue );

        void FinishCompactionL();

    private:

        // ===============

        // PRIVATE METHODS

        // ===============

        CCompactionHandler( RDbDatabase& aDatabase,

                            TInt         aPriority );

        void ConstructL();

        void Reschedule();

		// inherited from CActive

		virtual void RunL();

		virtual void DoCancel();

	    RTimer         iDelayTimer;

	    RDbDatabase&   iDatabase;

	    RDbIncremental iIncremental;

	    TInt           iStep;

	    TBool          iCompactionNeeded;

	    TInt           iSuspendCount;

	    __LOG_DECLARATION

    }; // end class CCompactionHandler

// ======================

// METHOD IMPLEMENTATIONS

// ======================

// ==========================================================================

// FUNCTION: NewL

// ==========================================================================

CContainerStoreUtils* CContainerStoreUtils::NewL(  TDriveNumber    aDriveNumber, 

                                                   TInt            aCompactionPriority, 

                                                   const TDesC&    aDbFilename,

                                                   CDeleteHandler& aDeleteHandler )

    {

    CContainerStoreUtils* self = new(ELeave) CContainerStoreUtils( aDriveNumber, 

                                                                   aCompactionPriority, 

                                                                   aDbFilename,

                                                                   aDeleteHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    } // end NewL

// ==========================================================================

// FUNCTION: Constructor

// ==========================================================================

CContainerStoreUtils::CContainerStoreUtils( TDriveNumber    aDriveNumber, 

                                            TInt            aCompactionPriority, 

                                            const TDesC&    aDbFilename,

                                            CDeleteHandler& aDeleteHandler ) :

    iDriveNumber( aDriveNumber ),

    iCompactionPriority( aCompactionPriority ),

    iDbFilename( aDbFilename ),

    iDeleteHandler( aDeleteHandler )

    {

#ifdef _DEBUG		

    iLowDiskSpaceLatency = -1;

#endif    

    } // end constructor

// ==========================================================================

// FUNCTION: ConstructL

// ==========================================================================

void CContainerStoreUtils::ConstructL()

    {

    __LOG_CONSTRUCT( "msg", "CContainerStoreUtils" )

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

    iFs.CreatePrivatePath( iDriveNumber );

    iFs.SetSessionToPrivate( iDriveNumber ); 

    iFs.PrivatePath( iPrivatePath );

    const TUint bufSize = 3;

    TBuf<bufSize> driveLetter;

    _LIT( KFormatString, "%C:" ); 

    driveLetter.Format( KFormatString, (iDriveNumber - EDriveA + 'A' ) );

    iPrivatePath.Insert( 0, driveLetter );

	} // end ConstructL

// ==========================================================================

// FUNCTION: Destructor

// ==========================================================================

CContainerStoreUtils::~CContainerStoreUtils()

    {

    delete iCompactionHandler;

    iTables.Close();

    iDatabase.Close();

    delete iFileStore;

    iFs.Close(); 

    __LOG_DESTRUCT

    } // end destructor

// ==========================================================================

// FUNCTION: LeaveIfFalseL

// ==========================================================================

void CContainerStoreUtils::LeaveIfFalse( TBool aCondition, TInt aLeaveCode )

{

	if ( !aCondition )

	{

		User::Leave( aLeaveCode );

	}

}

// ==========================================================================

// FUNCTION: FileSystem

// ==========================================================================

RFs& CContainerStoreUtils::FileSystem()

    {

    return iFs;

    } // end FileSystem

// ==========================================================================

// FUNCTION: CreateDatabaseL

// ==========================================================================

void CContainerStoreUtils::CreateDatabaseL()

	{

	__LOG_ENTER( "CreateDatabaseL" );

    // Create the file store.

	iFileStore->SetTypeL( iFileStore->Layout() );	

	// Create a database within the file store.

	TStreamId id = iDatabase.CreateL( iFileStore );

	// Set the database as the file store root object.

	iFileStore->SetRootL( id );

	// Commit the database.

	iFileStore->CommitL();

    iCompactionHandler = CCompactionHandler::NewL( iDatabase, iCompactionPriority );

	__LOG_EXIT

	} // end CreateDatabaseL

// ==========================================================================

// FUNCTION: OpenDatabaseL

// ==========================================================================

void CContainerStoreUtils::OpenDatabaseL()

	{

	__LOG_ENTER( "OpenDatabaseL" )

	// construct a file store object

	// open database from the root of the store

	iDatabase.OpenL( iFileStore, iFileStore->Root() );	

	if( iDatabase.IsDamaged() )

		{

		__LOG_WRITE_ERROR( "Recovering database" );

		User::LeaveIfError( iDatabase.Recover() );

		} // end if

    iCompactionHandler = CCompactionHandler::NewL( iDatabase, iCompactionPriority );

	iCompactionHandler->Compact();

 	__LOG_EXIT

	} // end OpenDatabaseL

// ==========================================================================

// FUNCTION: CloseDatabaseL

// ==========================================================================

void CContainerStoreUtils::CloseDatabaseL()

	{

	__LOG_ENTER( "CloseDatabaseL" )

    // Finish compaction, if necessary.

    if( iCompactionHandler )

        {        

        iCompactionHandler->FinishCompactionL();

        } // end if

	CloseDatabase();

	__LOG_EXIT

	} // end CloseDatabaseL

// ==========================================================================

// FUNCTION: CloseDatabase

// ==========================================================================

void CContainerStoreUtils::CloseDatabase()

    {

    __LOG_ENTER( "CloseDatabase" )

    delete iCompactionHandler;

    iCompactionHandler = NULL;

    iDatabase.Close();

    delete iFileStore;

    iFileStore = NULL;

    __LOG_EXIT

    } // end CloseDatabase

// ==========================================================================

// FUNCTION: PopulateViewL

// ==========================================================================

void CContainerStoreUtils::PopulateViewL( RDbView& aView, const TDesC& aSqlQuery, RDbRowSet::TAccess aAccess )

    {

    __LOG_ENTER( "PopulateViewL" )

    User::LeaveIfError( aView.Prepare( iDatabase, TDbQuery(aSqlQuery), aAccess ) );

    // Evaluate the view (i.e. populate it based on the SQL query).

	User::LeaveIfError( aView.EvaluateAll() );

	__LOG_EXIT

    } // end PopulateViewL

// ==========================================================================

// FUNCTION: Execute

// ==========================================================================

void CContainerStoreUtils::Execute( const TDesC &aSql, TDbTextComparison aComparison )

	{

    __LOG_ENTER( "Execute" )

    iDatabase.Execute( aSql, aComparison );

	__LOG_EXIT

	}

// ==========================================================================

// FUNCTION: CreateTableL

// ==========================================================================

void CContainerStoreUtils::CreateTableL( const TDesC& aTableName, CDbColSet& aColSet )

    {

    User::LeaveIfError( iDatabase.CreateTable( aTableName, aColSet ) );

    } // end CreateTableL

// ==========================================================================

// FUNCTION: CreateIndexL

// ==========================================================================

void CContainerStoreUtils::CreateIndexL( const TDesC& aName, const TDesC& aTable, const CDbKey& aKey )

    {

    User::LeaveIfError( iDatabase.CreateIndex( aName, aTable, aKey ) );    

    } // end CreateIndexL

// ==========================================================================

// FUNCTION: OpenTableL

// ==========================================================================

void CContainerStoreUtils::OpenTableL( RDbTable& aTable, const TDesC& aTableName )

    {

    User::LeaveIfError( aTable.Open( iDatabase, aTableName ) );

    iTables.AppendL( &aTable );

    } // end OpenTableL

// ==========================================================================

// FUNCTION: CloseTable

// ==========================================================================

void CContainerStoreUtils::CloseTable( RDbTable& aTable )

    {

    aTable.Close();

    TInt index = iTables.Find( &aTable );

    if( index != KErrNotFound )

        {        

        iTables.Remove( index );

        } // end if

    } // end CloseTable

// ==========================================================================

// FUNCTION: ReadLongColumnL

// ==========================================================================

void CContainerStoreUtils::ReadLongColumnL( RDbRowSet& aRowSet, 

                                            TUint      aColNum, 

                                            RBuf8&     aBuffer,

                                            TUint      aBufferPadSpace )

    {

    __LOG_ENTER_SUPPRESS( "ReadLongColumnL" )

    iCompactionHandler->SuspendLC();

	RDbColReadStream readStream;

	TUint colLength = aRowSet.ColLength( aColNum );

	TUint desiredLength = colLength + aBufferPadSpace;

	if( aBuffer.MaxLength() < desiredLength )

		{

		__LOG_WRITE_INFO( "growing buffer" )

		aBuffer.ReAllocL( desiredLength );		

		} // end if

	aBuffer.SetLength( 0 );

	readStream.OpenLC( aRowSet, aColNum );

	readStream.ReadL( aBuffer, colLength );

	CleanupStack::PopAndDestroy( &readStream ); 

	iCompactionHandler->Resume();

    } // end ReadLongColumnL

// ==========================================================================

// FUNCTION: WriteLongColumnL

// ==========================================================================

void CContainerStoreUtils::WriteLongColumnL( RDbRowSet&    aRowSet,

                               	             TUint         aColNum, 

                                      	     const TDesC8& aBuffer )

    { 

    __LOG_ENTER( "WriteLongColumnL" )

    if ( aBuffer.Length() > 0 )

        {

    	RDbColWriteStream writeStream;

    	LeaveIfLowDiskSpaceL( aBuffer.Length() );

    	writeStream.OpenLC( aRowSet, aColNum );

    	writeStream.WriteL( aBuffer );

    	writeStream.CommitL();

    	CleanupStack::PopAndDestroy( &writeStream ); 

        }

    else

        {

        aRowSet.SetColNullL( aColNum );

        }

	__LOG_EXIT

    } // end WriteLongColumnL

// ==========================================================================

// FUNCTION: LeaveIfLowDiskSpaceL

// ==========================================================================

void CContainerStoreUtils::LeaveIfLowDiskSpaceL( TUint aBytesToWrite )

	{

	__LOG_ENTER_SUPPRESS( "LeaveIfLowDiskSpaceL" )

	// This safety margin is to account for some level of uncertainty in aBytesToWrite due to overhead

	// in the database, file system, encryption, etc.

	const TUint KSafetyMargin = 8*1024;

	__LOG_WRITE8_FORMAT1_INFO( "LeaveIfLowDiskSpace(%i)", aBytesToWrite )

	TBool belowCritical = SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, aBytesToWrite+KSafetyMargin, iDriveNumber );

#ifdef _DEBUG

    TBool belowCriticalOverride = EFalse;    

    if( iLowDiskSpaceLatency > -1 )

        {

        belowCriticalOverride = (iLowDiskSpaceLatency == 0);        

        belowCritical = belowCritical || belowCriticalOverride;

        iLowDiskSpaceLatency--;

        } // end if

#endif

    if( belowCritical )    

        {

        // Force the deletes and database compaction to complete in the foreground.  This may take

        // a while, but may free up enough space to fix this condition.

        // : It was found that the following call will fail if a database row update is in progress (calls

        //       such as FirstL assert in those cases).  The cleanup mechanism would need to be refined in order

        //       to avoid that situation.

        // iDeleteHandler.FinishDeletes();

        iCompactionHandler->FinishCompactionL();        

	    belowCritical = SysUtil::DiskSpaceBelowCriticalLevelL( &iFs, aBytesToWrite+KSafetyMargin, iDriveNumber );

#ifdef _DEBUG

        belowCritical = belowCritical || belowCriticalOverride;

#endif

        } // end if

	if( belowCritical )

		{

		__LOG_WRITE_ERROR( "below critical disk space!" );	

		User::Leave( KErrNoMemory );

		} // end if

	} // end LeaveIfLowDiskSpaceL

// ==========================================================================

// FUNCTION: PrivatePath

// ==========================================================================

const TDesC& CContainerStoreUtils::PrivatePath() const

    {

    return iPrivatePath;

    } // end PrivatePath

// ==========================================================================

// FUNCTION: BeginDatabaseTransactionLC

// ==========================================================================

void CContainerStoreUtils::BeginDatabaseTransactionLC()

	{

	__LOG_ENTER( "BeginDatabaseTransactionL" )

	// A database transaction cannot be started while an incremental operation is in progress, so

	// suspend it now.

	iCompactionHandler->Suspend();

	TUint result = iDatabase.Begin();

	if( result != KErrNone )

		{

		__LOG_WRITE8_FORMAT1_ERROR( "failed, err=%i", result );

		User::Leave( result );

		} // end if

    // Push an item on the cleanup stack taht will rollback the database transaction

    // if something fails during the transaction.		

	CleanupStack::PushL(TCleanupItem(&RollbackDatabaseTransactionL, this) );

    __LOG_EXIT

	} // end BeginDatabaseTransactionL

// ==========================================================================

// FUNCTION: CommitDatabaseTransactionL

// ==========================================================================

void CContainerStoreUtils::CommitDatabaseTransactionL()

	{

	__LOG_ENTER( "CommitDatabaseTransactionL" )

	User::LeaveIfError( iDatabase.Commit() );

    // Pop the rollback item.	

	CleanupStack::Pop( this );

	iCompactionHandler->Resume( EFalse );

	iCompactionHandler->Compact();

    __LOG_EXIT