srsf/sisrscontrollerplugin/src/silexicondb.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Tue, 11 May 2010 16:14:47 +0300
branchRCL_3
changeset 11 6347473a7bb2
parent 0 bf1d17376201
permissions -rw-r--r--
Revision: 201017 Kit: 201019

/*
* Copyright (c) 2004-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:  This class handles the storage and access of speaker independent
*               lexicons.  It is also responsible for allocating memory when
*               loading lexicons into the recognizer.
*
*/


// INCLUDE FILES
#include "silexicondb.h"
#include "rubydebug.h"

// CONSTANTS


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

// -----------------------------------------------------------------------------
// CSILexiconDB::CSILexiconDB
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CSILexiconDB::CSILexiconDB( RDbNamedDatabase& aDatabase, 
                            RDbs& aDbSession,
                            TInt aDrive )
:	CSICommonDB(aDatabase, aDbSession, aDrive )
{
}

// -----------------------------------------------------------------------------
// CSILexiconDB::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSILexiconDB::ConstructL()
    {
    RUBY_DEBUG_BLOCK( "CSILexiconDB::ConstructL" );
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSILexiconDB* CSILexiconDB::NewL( RDbNamedDatabase& aDatabase, 
                                  RDbs& aDbSession,
                                  TInt aDrive )
    {
    RUBY_DEBUG_BLOCK( "CSILexiconDB::NewL" );
    CSILexiconDB* self 
        = new( ELeave ) CSILexiconDB( aDatabase, aDbSession, aDrive );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );	
    return self;
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::~CSILexiconDB
// Destructor
// -----------------------------------------------------------------------------
//
CSILexiconDB::~CSILexiconDB()
    {
    // Delete all elements of the array before deleting the array
    //	iLexiconArray.ResetAndDestroy();
    //	iLexiconArray.Close();
    RUBY_DEBUG0( "CSILexiconDB::~CSILexiconDB" );
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::CreateLexiconL
// Creates a new lexicon table in the database.
// -----------------------------------------------------------------------------
//
TSILexiconID CSILexiconDB::CreateLexiconL( TUid aClientUid )
    {
    RUBY_DEBUG_BLOCK( "CSILexiconDB::CreateLexiconL" );
    
    User::LeaveIfError( iDbSession.ReserveDriveSpace( iDrive, sizeof( CSILexicon ) ) );
    
    // Generate a new Lexicon ID
    TSILexiconID lexiconID = STATIC_CAST(TSILexiconID,CreateNewIDL(KLexiconIdTable, KLexiconIdColumn, aClientUid ));
    
    // Construct the table name using the new lexicon ID
    TBuf<40> KLexiconName( KSILexiconTable );
    KLexiconName.AppendNumUC( lexiconID );
    RUBY_DEBUG1( "CSILexiconDB::CreateLexiconL lexicon ID: %i", lexiconID );
	
    
    // Create a table definition
    CDbColSet* columns = CDbColSet::NewLC();
    
    // add the columns  
    // 1) Binary data, 2) binary data size
    columns->AddL( TDbCol( KBinaryLexiconColumn, EDbColLongBinary ) );
    columns->AddL( TDbCol( KBinaryLexiconColumnSize, EDbColUint32 ) );
    
    // Create a table
    TInt err =iDb.CreateTable( KLexiconName, *columns );
    
    if ( err != KErrNone )
        {
        // Failed to create the table.
        // Need to release the new Lexicon ID and leave.
        ReleaseIdL( KLexiconIdTable, KLexiconIdColumn, lexiconID );
        User::Leave( err );
        }
    
    // cleanup the column set
    CleanupStack::PopAndDestroy( columns );
    // Construct the table name using the provided grammar ID
    // Declare a literal string to hold the SQL statement
    // SELECT KBinaryLexiconColumn , KBinaryLexiconColumn FROM  KLexiconName
    _LIT(KSQLSelect1,"select  ");	
    _LIT(KSQLSelect2," from  ");		
    TBuf<120> KSQLStatement;		
    KSQLStatement.Append(KSQLSelect1  );	
    KSQLStatement.Append(KBinaryLexiconColumn );
    KSQLStatement.Append(KNext);
    KSQLStatement.Append(KBinaryLexiconColumnSize );	
    KSQLStatement.Append(KSQLSelect2  );
    KSQLStatement.Append(KLexiconName); 
    
    // create a view on the database
    RDbView view;
    User::LeaveIfError(view.Prepare(iDb,TDbQuery(KSQLStatement,EDbCompareNormal)));
    User::LeaveIfError(view.EvaluateAll());
    
    // Get the structure of rowset
    CDbColSet* colSet = view.ColSetL(); 
    view.InsertL();
    view.PutL();
    
    
    // close the view
    view.Close();
    delete colSet; 
    
    // add an empty lexicon
    CSILexicon *aLexicon=CSILexicon::NewL(lexiconID);	
    CleanupStack::PushL(aLexicon);
    UpdateLexiconL(aClientUid,aLexicon);
    CleanupStack::PopAndDestroy(aLexicon);	
    
    iDbSession.FreeReservedSpace( iDrive );
    
    return lexiconID;
    }


// -----------------------------------------------------------------------------
// CSILexiconDB::UpdateLexiconL
// Inserts the externalized SI Lexicon into the specified grammar table.
// Save the Lexicon into the database
// -----------------------------------------------------------------------------
//
void CSILexiconDB::UpdateLexiconL( TUid aClientUid, 
								   CSILexicon *aSILexicon )
    {
    
    //	__UHEAP_MARK;
    TSILexiconID aLexiconID=aSILexicon->LexiconID();
    VerifyOwnershipL(aClientUid, KLexiconIdTable, KLexiconIndex, aLexiconID);
    
    // Construct the table name using the provided grammar ID
    // Declare a literal string to hold the SQL statement
    // SELECT KBinaryLexiconColumn , KBinaryLexiconColumn FROM  KLexiconName
    TBuf<40> KLexiconName(KSILexiconTable);
    KLexiconName.AppendNumUC(aLexiconID);	
    _LIT(KSQLSelect1,"select  ");	
    _LIT(KSQLSelect2," from  ");		
    TBuf<120> KSQLStatement;		
    KSQLStatement.Append(KSQLSelect1  );	
    KSQLStatement.Append(KBinaryLexiconColumn );
    KSQLStatement.Append(KNext);
    KSQLStatement.Append(KBinaryLexiconColumnSize );	
    KSQLStatement.Append(KSQLSelect2  );
    KSQLStatement.Append(KLexiconName); 
    
    // create a view on the database
    RDbView view;
    User::LeaveIfError(view.Prepare(iDb,TDbQuery(KSQLStatement,EDbCompareNormal)));
    User::LeaveIfError(view.EvaluateAll());
    
    // Get the structure of rowset
    CDbColSet* colSet = view.ColSetL(); 
    
    view.FirstL(); 
    view.UpdateL();
    
    
    // Externalize grammar
    CBufFlat* dataCopyBuffer = CBufFlat::NewL( 100 ); // 100 = expand 100 bytes
    CleanupStack::PushL(dataCopyBuffer);              // when the buffer is full
    //TPtr8 Buft((TUint8*) abuf,3,3);
    //dataCopyBuffer->InsertL(0,Buft);
    RBufWriteStream stream;
    stream.Open(*dataCopyBuffer);
    CleanupClosePushL(stream);
    aSILexicon->ExternalizeL(stream);
    CleanupStack::PopAndDestroy( &stream );
    
    TPtr8 aWriteBuf(dataCopyBuffer->Ptr(0));
    TInt BufSize =aWriteBuf.Size();
    
    // add binary buffer by Using the stream  
    RDbColWriteStream out;
    TDbColNo col = colSet->ColNo(KBinaryLexiconColumn); // Ordinal position of long column	
    out.OpenLC(view, col);
    out.WriteL(aWriteBuf);	
    out.Close();	
    CleanupStack::PopAndDestroy(); // out
    // add  size of the buffer
    col = colSet->ColNo(KBinaryLexiconColumnSize); // Ordinal position of  size	
    view.SetColL( col,BufSize); 
    
    view.PutL();
    
    // close the view
    view.Close();
    
    
    delete colSet; 
    CleanupStack::PopAndDestroy( dataCopyBuffer ); 
    //	__UHEAP_MARKEND;
    }

// -----------------------------------------------------------------------------
// CSIGrammarDB::GetNewID
// Get a new uniq ID 
// -----------------------------------------------------------------------------
TInt CSILexiconDB::GetNewID( RArray<TSIRuleID>& aMyIds ) 
    {
    RArray<TSIRuleID> myIDs = aMyIds;
    TInt Count = myIDs.Count();
    TInt id = 0;
    if ( Count == 0 ) 
        {
        id = 1; // empty ,first id will be 1
        }
    else
        { 
        // Find a unique Rulevariant ID
        myIDs.SortUnsigned();
        id = myIDs[myIDs.Count() - 1] + 1; //by default , the last one 
        for ( TInt i = 0; i < myIDs.Count(); i++ ) 
            {
            TInt index = i + 1; 
            TInt s = myIDs[i];
            if ( s > index ) 
                {
                id = index;
                break;
                }
            }
        }
    return id;
    }


// -----------------------------------------------------------------------------
// CSILexiconDB::CreateIDTableL
// Creates a new lexicon ID table in the database.
// -----------------------------------------------------------------------------
//
void CSILexiconDB::CreateIDTableL()
    {
    // Invoke function in the base class CSICommonDB.
    CSICommonDB::CreateIDTableL(KLexiconIdTable, KLexiconIdColumn, KLexiconIndex);
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::GetAllClientLexiconIDsL
// This function returns all Lexicon IDs owned by the specified client.
// -----------------------------------------------------------------------------
//
void CSILexiconDB::GetAllClientLexiconIDsL( TUid aClientUid,
										    RArray<TSILexiconID>& aLexiconIDs )
    {
    //	GetAllClientIDsL(KLexiconIdTable, KLexiconIdColumn, aClientUid, aLexiconIDs);
    RArray<TUint32> ix;
    ix.Reset();
    GetAllClientIDsL(KLexiconIdTable, KLexiconIdColumn, aClientUid, ix);
    for(TInt i=0;i<ix.Count();i++) 
        aLexiconIDs.Append(STATIC_CAST(TSILexiconID,ix[i]));
    ix.Close();
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::GetAllLexiconIDsL
// This function returns all Lexicon IDs in the database.
// -----------------------------------------------------------------------------
//
void CSILexiconDB::GetAllLexiconIDsL( RArray<TSILexiconID>& aLexiconIDs )
    {
    // This is a hack to get the id aligned to 4-byte boundary,
    // for some reason this does not happen in winscw build if 
    // TSILexiconID is taken from stack.
    TSILexiconID* id = new (ELeave) TSILexiconID;
    CleanupStack::PushL( id );
    
    //	GetAllIDsL(KLexiconIdTable, KLexiconIdColumn, aLexiconIDs);
    RArray<TUint32> ix;
    ix.Reset();
    GetAllIDsL(KLexiconIdTable, KLexiconIdColumn, ix);
    for(TInt i=0;i<ix.Count();i++) 
        {
        *id = STATIC_CAST( TSILexiconID, ix[i] );
        aLexiconIDs.Append( *id );
        }
    ix.Close();
    CleanupStack::PopAndDestroy( id );
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::GetAllPronunciationIDsL
// This function returns all Pronunciation IDs within the specified Lexicon.
// Lexicon have to be loaded 
// -----------------------------------------------------------------------------
//
void CSILexiconDB::GetAllPronunciationIDsL( TSILexiconID aLexiconID, RArray<TSIPronunciationID>& aPronunciationIDs )
    {
	CleanupClosePushL( aPronunciationIDs ); 
	
    // Construct the table name using the provided Lexicon ID
    TBuf<40> KLexiconName(KSILexiconTable);
    KLexiconName.AppendNumUC(aLexiconID);
    
    CSILexicon* newLexicon = LexiconL( aLexiconID) ;// Load the Lexicon from database	
    CleanupStack::PushL(newLexicon);
    
    TSIPronunciationID	aPronunciationID;
    for (TInt  i=0;i<newLexicon->Count();i++) {
        CSIPronunciation* aPronunciation=&(newLexicon->AtL(i));
        aPronunciationID=aPronunciation->PronunciationID();		
        User::LeaveIfError(aPronunciationIDs.Append(aPronunciationID));
        } 
    
    CleanupStack::PopAndDestroy(newLexicon); // newLexicon
    //	GetAllIDsL(KLexiconName, KPronunciationIDColumn, aPronunciationIDs);
    CleanupStack::Pop(); 
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::RemoveLexiconL
// Deletes a Lexicon table from the database.
// -----------------------------------------------------------------------------
//
void CSILexiconDB::RemoveLexiconL( TUid aClientUid,
								   TSILexiconID aLexiconID )
    {
    
    VerifyOwnershipL(aClientUid, KLexiconIdTable, KLexiconIndex, aLexiconID);
    
    
    /* Some times removing of corrupted lexicon fails because of this:
    TInt diskSpace = ( PronunciationCountL(aLexiconID) * sizeof( CSIPronunciation ) )
        + sizeof( CSILexicon );
    User::LeaveIfError( iDbSession.ReserveDriveSpace( iDrive, diskSpace ) );
    */
    
    // Construct the table name using the provided Lexicon ID
    TBuf<40> KLexiconName(KSILexiconTable);
    KLexiconName.AppendNumUC(aLexiconID);
    
    TBuf<50> KSQLStatement;
    // Declare a literal string to hold the SQL statement
    // DROP TABLE KLexiconName
    _LIT(KSQLDelete1, "DROP TABLE ");
    
    KSQLStatement = KSQLDelete1;
    KSQLStatement.Append(KLexiconName);
    
    User::LeaveIfError(iDb.Execute(KSQLStatement));
    
    // Release the Lexicon ID
    ReleaseIdL(KLexiconIdTable, KLexiconIdColumn, aLexiconID);
    
    // Cancel free disk space request
    //iDbSession.FreeReservedSpace( iDrive );
    
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::PronunciationCountL
// Returns the number of Pronunciations in the specified Lexicon.
// -----------------------------------------------------------------------------
TInt CSILexiconDB::PronunciationCountL( TSILexiconID aLexiconID )
    {
    
    CSILexicon* newLexicon = LexiconL( aLexiconID) ;	
    CleanupStack::PushL(newLexicon);
    
    TInt PronunciationCount=newLexicon->Count();	 
    CleanupStack::PopAndDestroy(newLexicon); 	
    return PronunciationCount;

    }

// -----------------------------------------------------------------------------
// CSILexiconDB::IsPronunciationValidL
// Checks if the specified pronunciation exists in the specified loaded	.
// 
// -----------------------------------------------------------------------------
//
TBool CSILexiconDB::IsPronunciationValidL( TSILexiconID aLexiconID,
                                           TSIPronunciationID aPronunciationID )
    {
    CSILexicon* newLexicon = LexiconL( aLexiconID) ;		 
    CleanupStack::PushL(newLexicon);
    
    if (newLexicon->Find(aPronunciationID)==KErrNotFound) {
        CleanupStack::PopAndDestroy(newLexicon); // newLexicon
        return EFalse; 
        }
    else {
        CleanupStack::PopAndDestroy(newLexicon); // newLexicon
        return ETrue;	
        }
    }


// -----------------------------------------------------------------------------
// CSILexiconDB::ResetAndDestroy
// Deallocates the temporary memory containing the Lexicon object created with
// AllPronunciationsL.
// -----------------------------------------------------------------------------
//
void CSILexiconDB::ResetAndDestroy()
    {
    //	iLexiconArray.ResetAndDestroy();
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::RemovePronunciationL
// Deletes Pronunciation from the database.
// -----------------------------------------------------------------------------
//
void CSILexiconDB::RemovePronunciationL(  TUid aClientUid, 
                                        TSILexiconID aLexiconID,
                                        TSIPronunciationID aPronunciationID
                                        )
    {
    // Check the ownership first
    VerifyOwnershipL(aClientUid, KLexiconIdTable, KLexiconIndex, aLexiconID);
    
    CSILexicon* newLexicon = LexiconL( aLexiconID);		 
    CleanupStack::PushL(newLexicon);
    
    if (newLexicon->Find(aPronunciationID)==KErrNotFound)
        User::Leave(KErrNotFound);				 
    else  
        newLexicon->DeleteL(aPronunciationID);
    UpdateLexiconL(aClientUid  , newLexicon);
    CleanupStack::PopAndDestroy(newLexicon); // newLexicon
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::AddPronunciationL
// Add Pronunciation to the database.
// -----------------------------------------------------------------------------
//
TSIPronunciationID CSILexiconDB::AddPronunciationL( TUid aClientUid, 
                                                   TSILexiconID aLexiconID,
                                                   TDesC8& aPronunciationPr,
                                                   TSIModelBankID aModelBankID)
    {
    // Check the ownership first
    VerifyOwnershipL( aClientUid, KLexiconIdTable, KLexiconIndex, aLexiconID );
    
    CSILexicon* aLexicon = LexiconL( aLexiconID );
    CleanupStack::PushL( aLexicon );
    
    // existing myPronunciationID
    RArray<TSIPronunciationID> myPronunciationID;
    myPronunciationID.Reset();
    for( TInt i = 0; i < aLexicon->Count(); i++ )
        {
        CSIPronunciation* aPronunciation = &( aLexicon->AtL( i ) );
        myPronunciationID.Append( aPronunciation->PronunciationID() );
        }
    
    // Find a uniq new id 
    TSIPronunciationID aPronunciationID = GetNewID( myPronunciationID );
    myPronunciationID.Close();
    
    // add the  phoneme sequence  to the Pronunciation
    CSIPronunciation* pronunciation = CSIPronunciation::NewL( aPronunciationID, aModelBankID );
    CleanupStack::PushL( pronunciation );	
    pronunciation->SetPhonemeSequenceL( aPronunciationPr );
    aLexicon->AddL( pronunciation );
    CleanupStack::Pop( pronunciation ); // aPronunciation
    UpdateLexiconL( aClientUid,aLexicon );
    CleanupStack::PopAndDestroy( aLexicon ); // aLexicon
    return aPronunciationID;
    }

// -----------------------------------------------------------------------------
// CSILexiconDB::LexiconL
// Loads all pronunciations within the specified lexicon into a lexicon object
// -----------------------------------------------------------------------------
//
CSILexicon* CSILexiconDB::LexiconL( TSILexiconID aLexiconID )
    {
    
    // Construct the table name using the provided grammar ID
    // Construct the table name using the provided grammar ID
    // Declare a literal string to hold the SQL statement
    // SELECT KBinaryLexiconColumn , KBinaryLexiconColumn FROM  KLexiconName
    TBuf<40> KLexiconName(KSILexiconTable);
    KLexiconName.AppendNumUC(aLexiconID);
    // Create newLexicon object	
    CSILexicon* lexicon = CSILexicon::NewLC( aLexiconID );	
    _LIT(KSQLSelect1,"select  ");	
    _LIT(KSQLSelect2," from  ");
    TBuf<120> KSQLStatement;		
    KSQLStatement.Append(KSQLSelect1  );		
    KSQLStatement.Append(KBinaryLexiconColumn );
    KSQLStatement.Append(KNext);
    KSQLStatement.Append(KBinaryLexiconColumnSize );
    KSQLStatement.Append(KSQLSelect2  );
    KSQLStatement.Append(KLexiconName); 
    
    // create a view on the database
    RDbView view;
    CleanupClosePushL( view );
    
    User::LeaveIfError(view.Prepare(iDb,TDbQuery(KSQLStatement,EDbCompareNormal)));
    User::LeaveIfError(view.EvaluateAll());
    
    // Get the structure of the rowset 
    CDbColSet* colSet = view.ColSetL();
    CleanupStack::PushL( colSet );
    
    // iterate across the row set, one row only
    for (view.FirstL();view.AtRow();view.NextL())
        {
        
        // retrieve the row
        view.GetL();
        
        // first retrieve the size of binary package 
        TDbColNo col = colSet->ColNo(KBinaryLexiconColumnSize); // Ordinal position of long column 
        TInt32 size = view.ColUint32( col);
        
        TUint8* buf = new (ELeave) TUint8[size];		
        CleanupStack::PushL( buf);			
        TPtr8 readBuf( buf, size, size);
        CBufFlat* dataCopyBuffer = CBufFlat::NewL( 100 ); // 100 = expand 100 bytes
        CleanupStack::PushL( dataCopyBuffer );              // when the buffer is full
        
        RBufReadStream stream;
        CleanupClosePushL( stream );
        stream.Open(*dataCopyBuffer);
        
        // and a stream for long columns
        RDbColReadStream in;
        CleanupClosePushL( in );
        col = colSet->ColNo(KBinaryLexiconColumn); // Ordinal position of long column 
        
        
        in.OpenLC(view, col);
        in.ReadL(readBuf, view.ColLength(col));
        dataCopyBuffer->InsertL(0,readBuf);
        lexicon->InternalizeL( stream );
        
        CleanupStack::PopAndDestroy( col );
        CleanupStack::PopAndDestroy( &in );
        CleanupStack::PopAndDestroy( &stream ); 
        CleanupStack::PopAndDestroy( dataCopyBuffer );
        CleanupStack::PopAndDestroy( buf );
        }
    
    CleanupStack::PopAndDestroy( colSet );
    CleanupStack::PopAndDestroy( &view );
    

 
    // Cleanup lexicon
    CleanupStack::Pop( lexicon );
    return lexicon;
    }

//  End of File