/*
* Copyright (c) 2004-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:  This class implements the SI Controller Plugin database.
*
*/


// INCLUDE FILES
#include "sidatabase.h"
#include "rubydebug.h"
#include "nssbackupobserver.h"


// CONSTANTS
// Estimate size in bytes for an empty database
// const TInt KSizeEstimateDb = 650;

// Plugin database format string for secure DBMS
_LIT( KPluginDatabaseFormatString, "SECURE[10201AFF]" );

// Name of the DB lock mutex
_LIT( KLockMutex, "SIDATABASE" );

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CSIDatabase::CSIDatabase
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CSIDatabase::CSIDatabase( TFileName aDatabaseFileName )
                        : iOpenTransaction( EFalse ),
                          iDatabaseFileName( aDatabaseFileName ),
                          iDatabaseOpen( EFalse )
    {
    // Nothing
    }

// -----------------------------------------------------------------------------
// CSIDatabase::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSIDatabase::ConstructL()
    {
    RUBY_DEBUG_BLOCKL( "CSIDatabase::ConstructL" );
    // Checks to see if the Database already exists.  If not, it creates one.
    User::LeaveIfError( iDbSession.Connect() );
    CreateDatabaseL();
    OpenDatabaseL();
    
    TInt err = iMutex.OpenGlobal( KLockMutex );
    if ( err != KErrNone )
        {
        RUBY_DEBUG0( "CSIDatabase::ConstructL Creating new global mutex" );
        iMutex.CreateGlobal( KLockMutex );
        }
    else
        {
        RUBY_DEBUG0( "CSIDatabase::ConstructL Using existing global mutex" );
        }
        
    iCriticalSection.CreateLocal();
    iBackupObserver = CNssBackupObserver::NewL( *this );
    
    }

// -----------------------------------------------------------------------------
// CSIDatabase::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSIDatabase* CSIDatabase::NewL( TFileName aSDDatabaseFileName )
    {
    RUBY_DEBUG_BLOCKL( "CSIDatabase::NewL" );
    
    CSIDatabase* self = new( ELeave ) CSIDatabase( aSDDatabaseFileName );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    
    return self;
    }

// -----------------------------------------------------------------------------
// CSIDatabase::Rollback
// Rollback all changes to the database. 
// -----------------------------------------------------------------------------
//
void CSIDatabase::Rollback()
    {
    RUBY_DEBUG0( "CSIDatabase::Rollback" );
    if ( iOpenTransaction )
        {
        iDb.Rollback();
        // Try to recover the database, if it is damaged
        if( iDb.IsDamaged() )
            {
            iDb.Recover();
            }
        iMutex.Signal();
        iCriticalSection.Signal();
        iOpenTransaction = EFalse;
        }
    
    }

// -----------------------------------------------------------------------------
// CSIDatabase::~CSIDatabase
// Destructor 
// -----------------------------------------------------------------------------
//
CSIDatabase::~CSIDatabase()
    {
    // Rollback if there are any changes not commited
    if ( iOpenTransaction )
        {
        iDb.Rollback();
        // Try to recover the database, if it is damaged
        if( iDb.IsDamaged() )
            {
            iDb.Recover();
            }
        // Signal mutex if somebody happens to be waiting in BeginTransactionL()
        iMutex.Signal();
        }
        
    delete iBackupObserver;
    iCriticalSection.Close();

    iDb.Close();
    iDbSession.Close();
    iDatabaseOpen = EFalse;
    }

// -----------------------------------------------------------------------------
// CSIDatabase::BeginTransactionL
// Begins a database transaction if not already. Waits until exclusive write lock
// has been gained.
// -----------------------------------------------------------------------------
//
void CSIDatabase::BeginTransactionL()
    {
   

    if ( iOpenTransaction )
        {
        // If we already have the lock, no need to take it again
        RUBY_DEBUG0( "CSIDatabase::BeginTransactionL DB is already locked by current process" );
        return;
        }
    
    // Take mutex to ensure that only one process tries to gain the lock
    iMutex.Wait();
    iCriticalSection.Wait();
    
    // Taking the global mutex makes it sure that this should succeed every time
    TInt readLockErr = iDb.Begin();

    if ( readLockErr == KErrNone )
        {
        iOpenTransaction = ETrue;
        }
    }

// -----------------------------------------------------------------------------
// CSIDatabase::CommitChangesL
// Commits all changes to the database.
// -----------------------------------------------------------------------------
//
void CSIDatabase::CommitChangesL( TBool aCompact )
    {
    if ( iOpenTransaction )
        {
        TInt err = iDb.Commit();
        
        RUBY_DEBUG1( "CSIDatabase::CommitChangesL iDb.Commit() [%d]", err );
        
        if ( err != KErrNone )
            {
            iDb.Rollback();
            // Try to recover the database, if it is damaged
            if( iDb.IsDamaged() )
                {
                iDb.Recover();
                }
                
            iMutex.Signal();
            iCriticalSection.Signal();  
            iOpenTransaction = EFalse;
            User::Leave( err );
            }
        
        if ( aCompact )
            {
            RUBY_DEBUG0( "CSIDatabase::CommitChangesL compacting DB" );
            TInt error = iDb.Compact();
            if ( error != KErrNone )
                {
                RUBY_DEBUG1( "CSIDatabase::CommitChangesL compact error: [%d]", error );
                }
            }
        
        // Signal waiting BeginTransactionL()
        iMutex.Signal();
        iCriticalSection.Signal();  
        iOpenTransaction = EFalse;
        
        User::LeaveIfError( err );
        }
        
          
    }

// -----------------------------------------------------------------------------
// CSIDatabase::DoIDTablesExistL
// Checks to see if ID tables exist.
// -----------------------------------------------------------------------------
//
TBool CSIDatabase::DoIDTablesExistL()
    {
    // Get db table names list
    CDbTableNames* table_names = iDb.TableNamesL();
    TInt count = table_names->Count();
    delete table_names;
    // 1 is for the lock table!
    return ( count > 1 );
    }

// -----------------------------------------------------------------------------
// CSIDatabase::DoesLockTableExistL
// Checks to see if lock table exists
// -----------------------------------------------------------------------------
//
TBool CSIDatabase::DoesLockTableExistL()
    {
    // Get db table names list
    CDbTableNames* table_names = iDb.TableNamesL();
    TInt count = table_names->Count();

    for ( TInt counter = 0 ; counter < count ; counter++ )
        {
        if ( (*table_names)[counter] == _L( "writelocktable" ) )
            {
            delete table_names;
            return ETrue;
            }
        }

    delete table_names;
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CSIDatabase::DoesModelBankTableExistL
// Checks to see if model bank table exists
// -----------------------------------------------------------------------------
//
TBool CSIDatabase::DoesModelBankTableExistL()
    {
    // Get db table names list
    CDbTableNames* table_names = iDb.TableNamesL();
    TInt count = table_names->Count();

    for ( TInt counter = 0 ; counter < count ; counter++ )
        {
        if ( (*table_names)[counter] == _L( "siModelBankIdTable" ) )
            {
            delete table_names;
            return ETrue;
            }
        }

    delete table_names;
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CSIDatabase::DoesLexiconTableExistL
// Checks if lexicon table exists
// -----------------------------------------------------------------------------
//
TBool CSIDatabase::DoesLexiconTableExistL()
    {
    // Get db table names list
    CDbTableNames* table_names = iDb.TableNamesL();
    TInt count = table_names->Count();

    for ( TInt counter = 0 ; counter < count ; counter++ )
        {
        if ( (*table_names)[counter] == _L( "siLexiconIdTable" ) )
            {
            delete table_names;
            return ETrue;
            }
        }

    delete table_names;
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CSIDatabase::DoesGrammarTableExistL
// Checks if grammar table exists
// -----------------------------------------------------------------------------
//
TBool CSIDatabase::DoesGrammarTableExistL()
    {
    // Get db table names list
    CDbTableNames* table_names = iDb.TableNamesL();
    TInt count = table_names->Count();

    for ( TInt counter = 0 ; counter < count ; counter++ )
        {
        if ( (*table_names)[counter] == _L( "siGrammarIdTable" ) )
            {
            delete table_names;
            return ETrue;
            }
        }

    delete table_names;
    return EFalse;
    }


// -----------------------------------------------------------------------------
// CSIDatabase::SIDatabase
// Returns a reference to the database.
// -----------------------------------------------------------------------------
//
RDbNamedDatabase& CSIDatabase::SIDatabase()
    {
    return iDb;
    }

// -----------------------------------------------------------------------------
// CSIDatabase::CreateDatabaseL
// Creates a database file if one does not exist yet.
// -----------------------------------------------------------------------------
//
void CSIDatabase::CreateDatabaseL()
    {
    RUBY_DEBUG_BLOCKL( "CSIDatabase::CreateDatabaseL" );
    
    // Get the drive of the database file
    iDatabaseDrive = EDriveC;
    if ( iDatabaseFileName.Locate( 'c' ) == 0 || iDatabaseFileName.Locate( 'C' ) == 0 )
        {
        iDatabaseDrive = EDriveC;
        }
    else if ( iDatabaseFileName.Locate( 'd' ) == 0 || iDatabaseFileName.Locate( 'D' ) == 0 )
        {
        iDatabaseDrive = EDriveD;
        }
    else if ( iDatabaseFileName.Locate( 'z' ) == 0 || iDatabaseFileName.Locate( 'Z' ) == 0 )
        {
        iDatabaseDrive = EDriveZ;
        }
    
    else if ( iDatabaseFileName.Locate( 'e' ) == 0 || iDatabaseFileName.Locate( 'E' ) == 0 )
        {
        iDatabaseDrive = EDriveE;
        }
    else
        {
        User::Leave( KErrPathNotFound );
        }
    
    RDbNamedDatabase database;
    TInt ret = database.Create( iDbSession, iDatabaseFileName, KPluginDatabaseFormatString );
    if ( ret == KErrAlreadyExists )
        {
        // Ignore KErrAlreadyExists, we will use the existing one if it is there
        ret = KErrNone;
        }
    database.Close();
    User::LeaveIfError( ret );
    }

// -----------------------------------------------------------------------------
// CSIDatabase::OpenDatabaseL
// Opens the database.
// -----------------------------------------------------------------------------
//
void CSIDatabase::OpenDatabaseL()
    {
    if ( !iDatabaseOpen )
        {
        
        User::LeaveIfError( iDb.Open( iDbSession, iDatabaseFileName, KPluginDatabaseFormatString ) );
        
        // Try to recover the database, if it is damaged
        if( iDb.IsDamaged() )
            {
            RUBY_DEBUG0( "CSIDatabase::OpenDatabaseL - Db is damaged. Attempt to recover." );
            
            User::LeaveIfError( iDb.Recover() );
            }
        
        iDatabaseOpen = ETrue;
        }
    }
    
// -----------------------------------------------------------------------------
// CSIDatabase::CloseDatabase
// Closes the database.
// -----------------------------------------------------------------------------
//
TInt CSIDatabase::CloseDatabase()
    {
    RUBY_DEBUG0( "CSIDatabase::CloseDatabase" ); 
  
    iDb.Close();
    iDatabaseOpen = EFalse;

    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CSIDatabase::DbSession
// Return reference to DB session.
// -----------------------------------------------------------------------------
//
RDbs& CSIDatabase::DbSession()
    {
    return iDbSession;
    }

// -----------------------------------------------------------------------------
// CSIDatabase::DbDrive
// Returns a drive for DB file.
// -----------------------------------------------------------------------------
//
TInt CSIDatabase::DbDrive()
    {
    return iDatabaseDrive;
    }

// -----------------------------------------------------------------------------
// CSIDatabase::CreateLockTableL
// Creates a dummy table to gain write-lock at the beginning of each transaction.
// -----------------------------------------------------------------------------
//
void CSIDatabase::CreateLockTableL()
    {
    // Create writelocktable
    // This table is accessed every time when transaction starts to gain
    // exclusive locking of the DB
    _LIT( KWriteLockTable, "writelocktable" );
    
    _LIT( KCol1, "temporary" );
    
    OpenDatabaseL();
    
    // Create the rrd tables definition (columnset).
    CDbColSet* columns = CDbColSet::NewLC();
    
    // The tag id 
    TDbCol dbCol1( KCol1, EDbColUint32 );
    columns->AddL( dbCol1 );
    
    User::LeaveIfError( iDb.CreateTable( KWriteLockTable, *columns ) );
    
    // Cleanup columns
    CleanupStack::PopAndDestroy( columns ); 
    }
    
// -----------------------------------------------------------------------------
// CSIDatabase::LockTransactionsL
// Permit transactions and release database
// -----------------------------------------------------------------------------
//
void CSIDatabase::LockTransactionsL()
    {
    // lock transactions
    RUBY_DEBUG_BLOCK( "CSIDatabase::LockTransactionsL" );
    
    iCriticalSection.Wait(); // wait until a possible transaction ends
            
    // release a database
    CloseDatabase();
    }

// -----------------------------------------------------------------------------
// CSIDatabase::UnlockTransactionsL
// Allow transactions and reserve database
// -----------------------------------------------------------------------------
//
void CSIDatabase::UnlockTransactionsL()
    {
    // unlock transactions
    RUBY_DEBUG_BLOCK( "CSIDatabase::UnlockTransactionsL" );
    OpenDatabaseL(); // open database
    
    if ( iCriticalSection.IsBlocked() )
        {        
        iCriticalSection.Signal(); // allow to do transactions
        }
    }

//  End of File