1 /*

     2 * Copyright (c) 2004-2006 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementation of VAS database handling

    15 *

    16 */

    17 

    18 

    19 #include "nssvascvasdb.h"

    20 #include <e32test.h>

    21 #include <e32std.h>

    22 #include <e32svr.h>

    23 #include "rubydebug.h"

    24 #include "nssvascoreconstant.h"

    25 #include "nssvascrrd.h"

    26 

    27 #include "nssvasbackupobserver.h"

    28 

    29 // CONSTANTS

    30 

    31 // Name of the DB lock mutex

    32 _LIT( KLockMutex, "VASDATABASE" );

    33 

    34 #ifdef _DEBUG

    35 // used in UDEB macros only

    36 _LIT( KVasDbPanic, "VasCNssVasDb.cpp");

    37 #endif // _UDEB

    38 

    39 // Maximum size of tag array

    40 static const TInt KMaxTagArraySize = 50;

    41 

    42 const TInt KContextListGranularity = 5;

    43 

    44 const TInt KSqlStatementmaxLength = 120;

    45 

    46 // MACROS

    47 

    48 // Complementary macro for TRAPD

    49 #define REACT( err, codeblock ) if ( err != KErrNone ) { codeblock; }

    50 

    51 // ============================ Methods ===============================

    52 

    53 // -----------------------------------------------------------------------------

    54 // CNssVasDb::NewL

    55 // 2-level constructor

    56 // -----------------------------------------------------------------------------

    57 //

    58 CNssVasDb* CNssVasDb::NewL( CNssContextBuilder& contextBuilder,

    59 	                        CNssSpeechItemBuilder& speechItemBuilder )

    60     {

    61     RUBY_DEBUG_BLOCK( "CNssVasDb::NewL" );

    62 

    63     CNssVasDb* self = new(ELeave) CNssVasDb( contextBuilder,

    64                                              speechItemBuilder );

    65     CleanupStack::PushL( self );

    66     self->ConstructL();

    67     CleanupStack::Pop( self );

    68 

    69     return self;

    70     }

    71 

    72 // -----------------------------------------------------------------------------

    73 // CNssVasDb::~CNssVasDb

    74 // Standard C++ destructor

    75 // -----------------------------------------------------------------------------

    76 //

    77 CNssVasDb::~CNssVasDb()

    78     {

    79     RUBY_DEBUG0( "CNssVasDb::~CNssVasDb" );

    80 

    81     if ( iLocked )

    82         {

    83         RUBY_DEBUG0( "Signalling mutex in CNssVasDb::~CNssVasDb" );

    84         iMutex.Signal();

    85         }

    86     else

    87         {

    88         RUBY_DEBUG0( "NOT signalling mutex in CNssVasDb::~CNssVasDb iLocked = EFalse" );

    89         }

    90 

    91     if ( iClientHasOpenedDatabase )

    92         {

    93         CloseDatabase();

    94         }

    95 

    96     iMutex.Close();

    97     delete iBackupObserver;

    98     iCriticalSection.Close();

    99     RUBY_DEBUG0( "CNssVasDb::~CNssVasDb Mutex handle closed" );

   100     }

   101 	

   102 

   103 // -----------------------------------------------------------------------------

   104 // CNssVasDb::CNssVasDb

   105 // Standard C++ contructor

   106 // -----------------------------------------------------------------------------

   107 //

   108 CNssVasDb::CNssVasDb( CNssContextBuilder& aContextBuilder,

   109 	                  CNssSpeechItemBuilder& aSpeechItemBuilder )

   110 : iClientHasOpenedDatabase( EFalse ),

   111   iLocked( EFalse ),

   112   iContextBuilder( aContextBuilder ),

   113   iSpeechItemBuilder( aSpeechItemBuilder )

   114     {

   115     // empty

   116     }

   117 

   118 // -----------------------------------------------------------------------------

   119 // CNssVasDb::ConstructL

   120 // Symbian second constructor.

   121 // -----------------------------------------------------------------------------

   122 //

   123 void CNssVasDb::ConstructL()

   124     {

   125     TInt err = iMutex.OpenGlobal( KLockMutex );

   126     if ( err != KErrNone )

   127         {

   128         RUBY_DEBUG0( "CNssVasDb::ConstructL Creating new global mutex" );

   129         iMutex.CreateGlobal( KLockMutex );

   130         }

   131     else

   132         {

   133         RUBY_DEBUG0( "CNssVasDb::ConstructL Using existing global mutex" );

   134         }

   135     iCriticalSection.CreateLocal();

   136     iBackupObserver = CNssVasBackupObserver::NewL( *this );

   137     }

   138 

   139 // -----------------------------------------------------------------------------

   140 // CNssVasDb::RollbackCleanupFunction

   141 // This function is used to form iRollbackCleanupItem. When this item is

   142 // popped from the cleanup stack, it makes a rollback on VAS DB.

   143 // -----------------------------------------------------------------------------

   144 //

   145 void CNssVasDb::RollbackCleanupFunction( TAny* aArg )

   146     {

   147     RUBY_DEBUG0( "CNssVasDb::RollbackCleanupFunction" );

   148 

   149     CNssVasDb* me = (CNssVasDb*)aArg;

   150 

   151     me->RollbackTransaction();

   152     }

   153 

   154 // -----------------------------------------------------------------------------

   155 // CNssVasDb::CreateDatabaseL

   156 // Creates a new database.

   157 // from a resource file.

   158 // -----------------------------------------------------------------------------

   159 //

   160 void CNssVasDb::CreateDatabaseL()

   161     {

   162     User::LeaveIfError( iDbSession.Connect() );

   163     CleanupClosePushL( iDbSession );

   164     iDbcreator.CreateVasDatabaseL( iDbSession );

   165     CleanupStack::PopAndDestroy( &iDbSession );

   166     }

   167 

   168 // -----------------------------------------------------------------------------

   169 // CNssVasDb::OpenDatabaseL

   170 // Opens the database. Reads the path and file name of the database

   171 // from a resource file.

   172 // -----------------------------------------------------------------------------

   173 //

   174 void CNssVasDb::OpenDatabaseL()

   175     {

   176     RUBY_DEBUG_BLOCK( "CNssVasDb::OpenDatabaseL" );

   177 

   178     if ( !iClientHasOpenedDatabase )

   179         {

   180         RFs fs;

   181         User::LeaveIfError( fs.Connect() );

   182         CleanupClosePushL ( fs ); // Stack: file session

   183 

   184         // Open the database

   185 	    User::LeaveIfError( iDbSession.Connect() );

   186 	    

   187         User::LeaveIfError( iDatabase.Open( iDbSession, 

   188                             KVasDatabaseName, KVasDatabaseFormatString ) );

   189         User::LeaveIfError( fs.CharToDrive( KVasDatabaseDrive, iDrive ) );

   190 

   191         if ( iDatabase.IsDamaged() )

   192             {

   193             RUBY_DEBUG0( "CNssVasDb::OpenDatabaseL Recovering" );

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

   195             }

   196             

   197         CleanupStack::PopAndDestroy( &fs ); 

   198 

   199 	    iClientHasOpenedDatabase = ETrue;

   200         }

   201     }

   202 

   203 // -----------------------------------------------------------------------------

   204 // CNssVasDb::CloseDatabase

   205 // Closes the database.

   206 // -----------------------------------------------------------------------------

   207 //

   208 TInt CNssVasDb::CloseDatabase()

   209     {

   210     RUBY_DEBUG0( "CNssVasDb::CloseDatabase" ); 

   211   

   212     iDatabase.Close();

   213     iDbSession.Close();

   214     iClientHasOpenedDatabase = EFalse;

   215 

   216     return KErrNone;

   217     }

   218 

   219 // -----------------------------------------------------------------------------

   220 // CNssVasDb::GetModelBankIdLexiconIdL

   221 // Returns the model bank ID and the lexicon ID.

   222 // -----------------------------------------------------------------------------

   223 //

   224 TBool CNssVasDb::GetModelBankIdLexiconIdL( TUint32& aModelBankId, TUint32& aLexiconId )

   225     {

   226     TBool ret = EFalse;

   227     RDbView view;

   228   

   229     _LIT( KSQLGetModelBankLexicon, "select modelbankid,lexiconid from contexttable" );

   230 

   231     User::LeaveIfError( StartTransaction() );

   232     CreatePushRollbackItemLC();

   233 

   234     CleanupClosePushL( view );

   235 

   236     User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( 

   237                             KSQLGetModelBankLexicon, EDbCompareNormal ) ) );

   238     User::LeaveIfError( view.EvaluateAll() );

   239 

   240     // There is no ModelbankId or LexiconId 

   241     if ( view.IsEmptyL() )

   242         {

   243         User::Leave( KErrNotFound );

   244         }

   245     // There is a ModelBankId and a LexiconId 

   246     ret = ETrue;

   247     view.FirstL();

   248     view.GetL();

   249 

   250     // Get column set

   251     CDbColSet* columns = view.ColSetL();

   252     // Get column ordinals

   253     TDbColNo modelbankid_col = columns->ColNo( KModelBankIdCol );

   254     TDbColNo lexiconid_col = columns->ColNo( KLexiconIdCol );

   255     // Cleanup column set

   256     delete columns;

   257 

   258     aModelBankId = view.ColUint32( modelbankid_col );

   259     aLexiconId   = view.ColUint32( lexiconid_col );

   260  

   261     // Close view

   262     CleanupStack::PopAndDestroy( &view );

   263 

   264     // Release lock

   265     CleanupStack::Pop();  // Rollback cleanup item

   266     CommitTransaction( EFalse );

   267 

   268     return ret;

   269     }

   270 

   271 

   272 // -----------------------------------------------------------------------------

   273 // CNssVasDb::TagExistsL

   274 // Checks if a context is empty.

   275 // -----------------------------------------------------------------------------

   276 //

   277 TBool CNssVasDb::TagExistL( TInt aContextId )

   278     {

   279     RUBY_DEBUG_BLOCK( "CNssVasDb::TagExistL" );

   280  

   281     TBool   ret( EFalse );

   282     RDbView view;

   283 

   284     CleanupClosePushL(view);

   285 

   286     _LIT( KSQLGetTags, "select * from tagtable " );

   287     _LIT( KSQLWhereContextId, "where contextid=" );

   288 

   289     iSQLStatement = KSQLGetTags;

   290     iSQLStatement.Append( KSQLWhereContextId );

   291     iSQLStatement.AppendNumUC( aContextId );

   292     

   293     User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );

   294     User::LeaveIfError( view.EvaluateAll() );

   295 

   296     if ( view.IsEmptyL() )

   297         {

   298         ret = EFalse;

   299         }

   300     else

   301         {

   302         ret = ETrue;

   303         }

   304 

   305     // Close view

   306     CleanupStack::PopAndDestroy( &view );

   307 

   308     return ret;

   309     }

   310 

   311 // -----------------------------------------------------------------------------

   312 // CNssVasDb::TagCountL

   313 // Returns the number of tags.

   314 // -----------------------------------------------------------------------------

   315 //

   316 TInt CNssVasDb::TagCountL( TInt aContextId )

   317     {

   318     RUBY_DEBUG_BLOCK( "CNssVasDb::TagCountL" );

   319         

   320     RDbView view;

   321     TInt    numberOfTags = 0;

   322 

   323     CleanupClosePushL( view );

   324 

   325     _LIT( KSQLGetTags, "select * from tagtable " );

   326     _LIT( KSQLWhereContextId, "where contextid=" );

   327 

   328     iSQLStatement = KSQLGetTags;

   329     iSQLStatement.Append( KSQLWhereContextId );

   330     iSQLStatement.AppendNumUC( aContextId );

   331     

   332     User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );

   333     User::LeaveIfError( view.EvaluateAll() );

   334 

   335     numberOfTags = view.CountL();

   336    

   337     view.Close();

   338     CleanupStack::PopAndDestroy( &view );

   339    

   340     return numberOfTags;

   341     }

   342 

   343 // -----------------------------------------------------------------------------

   344 // CNssVasDb::CommitIfSuccess

   345 // Commits or rolls back accoring to success parameter.

   346 // -----------------------------------------------------------------------------

   347 //

   348 void CNssVasDb::CommitIfSuccess( RDbDatabase /*aDatabase*/, TInt aSuccess, TBool aCompactIfCommit )

   349     {

   350     if ( aSuccess >= 0 )

   351         {

   352         CommitTransaction( aCompactIfCommit );

   353         }

   354     else

   355         {

   356         // Otherwise, roll back the transaction and release the lock.

   357         RollbackTransaction();

   358         }

   359     }

   360 

   361 // -----------------------------------------------------------------------------

   362 // CNssVasDb::SaveContextL

   363 // Saves a newly created context. The Context ID is assigned and returned

   364 // using the reference parameter.

   365 // -----------------------------------------------------------------------------

   366 //

   367 void CNssVasDb::SaveContextL( CNssContext& aContext, TInt& aContextId )

   368     {

   369     RUBY_DEBUG_BLOCK( "CNssVasDb::SaveContextL" );

   370   

   371     if ( !iClientHasOpenedDatabase )

   372         {

   373         RUBY_DEBUG0( "CNssVasDb error: database not opened." );

   374         

   375         User::Leave( KErrNotReady );

   376         }

   377 

   378     // Locks the database for the use of this process only

   379     TInt error = StartTransaction();

   380 

   381     if ( error != KErrNone )

   382         {

   383         RUBY_DEBUG0( "CNssVasDb error: could not lock database." );

   384         

   385         User::Leave( KErrGeneral );

   386         }

   387 

   388     TRAP( error, SaveContextL( &aContext, aContextId ) );

   389     REACT( error, RUBY_DEBUG0( "Context saving failed" ) );

   390 

   391     if ( error == KErrNone )

   392         {

   393         TRAP ( error, DoUpdateContextClientDataL( aContext ) );

   394         }

   395     

   396     CommitIfSuccess( iDatabase, error, ETrue );

   397     

   398     User::LeaveIfError( error );

   399     }

   400 

   401 // -----------------------------------------------------------------------------

   402 // CNssVasDb::UpdateContextL

   403 // Updates the context to VAS DB.

   404 // -----------------------------------------------------------------------------

   405 //

   406 void CNssVasDb::UpdateContextL( CNssContext& aContext )

   407     {

   408     RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateContextL" );

   409 

   410     if ( !iClientHasOpenedDatabase )

   411         {

   412         RUBY_DEBUG0( "CNssVasDb error: database not opened." );

   413         

   414         User::Leave( KErrNotReady );

   415         }

   416 

   417     TInt error = StartTransaction();

   418 

   419     if ( error != KErrNone )

   420         {

   421         RUBY_DEBUG0( "CNssVasDb error: could not lock database." );

   422         

   423         User::Leave( KErrGeneral );

   424         }

   425 

   426     TRAP( error, DoUpdateContextL( aContext ) );

   427     REACT( error, RUBY_DEBUG0( "Context updating failed" ) );

   428 

   429     CommitIfSuccess( iDatabase, error, ETrue );

   430     

   431     User::LeaveIfError( error );

   432     }

   433 

   434 // -----------------------------------------------------------------------------

   435 // CNssVasDb::UpdateContextInsideTransactionL

   436 // Updates the context to VAS DB.

   437 // -----------------------------------------------------------------------------

   438 //

   439 void CNssVasDb::UpdateContextInsideTransactionL( CNssContext& aContext )

   440     {

   441     RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateContextInsideTransactionL" );

   442 

   443     if ( !iClientHasOpenedDatabase )

   444         {

   445         RUBY_DEBUG0( "CNssVasDb error: database not opened." );

   446         

   447         User::Leave( KErrNotReady );

   448         }

   449 

   450     DoUpdateContextL( aContext );

   451     }

   452 

   453 // -----------------------------------------------------------------------------

   454 // CNssVasDb::UpdateContextClientDataL

   455 // Updates the client data of the context.

   456 // -----------------------------------------------------------------------------

   457 //

   458 void CNssVasDb::UpdateContextClientDataL( CNssContext& aContext )   

   459     {

   460     RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateContextClientDataL" );

   461 	

   462     if ( !iClientHasOpenedDatabase )

   463         {

   464         RUBY_DEBUG0( "CNssVasDb error: database not opened." );

   465         

   466         User::Leave( KErrNotReady );

   467         }

   468 

   469     TInt error = StartTransaction();

   470 

   471     if ( error != KErrNone )

   472         {

   473         RUBY_DEBUG0( "CNssVasDb error: could not lock database." );

   474         

   475         User::Leave( KErrGeneral );

   476         }

   477 

   478     TRAP( error, DoUpdateContextClientDataL( aContext ) );

   479 

   480     CommitIfSuccess( iDatabase, error, ETrue );

   481     

   482     User::LeaveIfError( error );

   483     }

   484 

   485 // -----------------------------------------------------------------------------

   486 // CNssVasDb::GetDefaultModelBankIdL

   487 // Usually, all contexts use the same Model Bank. This function

   488 // returns the first model bank ID it finds.

   489 // -----------------------------------------------------------------------------

   490 //

   491 void CNssVasDb::GetDefaultModelBankIdL( TUint32& aId )

   492     {

   493     RUBY_DEBUG_BLOCK( "CNssVasDb::GetDefaultModelBankIdL" );

   494       

   495     _LIT( KSQLGetAll,"select modelbankid from contexttable");

   496 

   497     iSQLStatement = KSQLGetAll;

   498 

   499     if ( !iClientHasOpenedDatabase )

   500         {

   501         User::Leave( KErrDbNotSet );

   502         }

   503 

   504     StartTransaction();

   505     CreatePushRollbackItemLC();

   506 

   507     RDbView view;

   508 

   509     CleanupClosePushL(view);

   510 

   511     User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );

   512     User::LeaveIfError( view.EvaluateAll() );

   513 

   514     if ( view.IsEmptyL() )

   515         {

   516 	    User::Leave( KErrNotFound );

   517         }

   518 

   519     // Get column set

   520     CDbColSet* columns = view.ColSetL();

   521     // Get model bank id column ordinal

   522 	TDbColNo modelbankid_col= columns->ColNo( KModelBankIdCol );

   523 	delete columns;

   524 

   525 	view.FirstL();

   526     view.GetL(); // Retrieve the current row - actually reads the row from the database.

   527 

   528     aId = view.ColUint32( modelbankid_col );

   529 

   530     CleanupStack::PopAndDestroy( &view );// close view

   531 

   532     // Rollback cleanup

   533     CleanupStack::Pop();  // Rollback cleanup item

   534     CommitTransaction( EFalse );

   535     }

   536 

   537 // -----------------------------------------------------------------------------

   538 // CNssVasDb::ResetModelBankL

   539 // Usually, all contexts use the same Model Bank. When the model bank is reseted,

   540 // (=speaker independent models are resotred and speaker adaptation is destroyed)

   541 // the model bank ID changes for all contexts.

   542 // -----------------------------------------------------------------------------

   543 //

   544 void CNssVasDb::ResetModelBankL( TUint32 aNewId )

   545     {

   546     RUBY_DEBUG_BLOCK( "CNssVasDb::ResetModelBankL" );

   547 

   548     _LIT( KSQLUpdateModelbank,"update contexttable set modelbankid=");

   549 

   550     iSQLStatement = KSQLUpdateModelbank;

   551     iSQLStatement.AppendNumUC( aNewId );

   552 

   553 

   554     if ( !iClientHasOpenedDatabase )

   555         {

   556         User::Leave( KErrDbNotSet );

   557         }

   558 

   559     StartTransaction();

   560     CreatePushRollbackItemLC();

   561 

   562     User::LeaveIfError( iDatabase.Execute( iSQLStatement ) );

   563 

   564     CleanupStack::Pop();  // Rollback cleanup item

   565 

   566     User::LeaveIfError( CommitTransaction( ETrue ) );

   567     }

   568 

   569 // -----------------------------------------------------------------------------

   570 // CNssVasDb::GetContextByNameL

   571 // Reads a context from VAS DB by name.

   572 // -----------------------------------------------------------------------------

   573 //

   574 CArrayPtrFlat<CNssContext>* CNssVasDb::GetContextByNameL(const TDesC& aName)

   575     {

   576 	RUBY_DEBUG_BLOCK("CNssVasDb::GetContextByNameL");

   577 

   578     _LIT( KSQLGetAll,"select * from contexttable ");

   579     _LIT( KSQLWhereName,"where name='");

   580     _LIT( KTick,"' ");

   581 

   582     iSQLStatement = KSQLGetAll;

   583     iSQLStatement.Append( KSQLWhereName );

   584     iSQLStatement.Append( aName );

   585     iSQLStatement.Append( KTick );

   586 

   587     return GetContextL( iSQLStatement );

   588     }

   589 

   590 // -----------------------------------------------------------------------------

   591 // CNssVasDb::GetGlobalContexts

   592 // Reads all global contexts from VAS DB.

   593 // -----------------------------------------------------------------------------

   594 //

   595 CArrayPtrFlat<CNssContext>* CNssVasDb::GetGlobalContexts()

   596     {

   597 	RUBY_DEBUG0("CNssVasDb::GetGlobalContexts");

   598 	    

   599     _LIT( KSQLGetAll,"select * from contexttable ");

   600     _LIT( KSQLWhereGlobal,"where global=1");

   601 

   602     iSQLStatement = KSQLGetAll;

   603     iSQLStatement.Append( KSQLWhereGlobal );

   604 

   605     CArrayPtrFlat<CNssContext>* ret( NULL );

   606     TRAPD( error, ret = GetContextL( iSQLStatement ) );

   607     if ( error != KErrNone )

   608         {

   609         return NULL;

   610         }

   611     return ret;

   612     }

   613 

   614 // -----------------------------------------------------------------------------

   615 // CNssVasDb::GetAllContexts

   616 // Reads all contexts from VAS DB.

   617 // -----------------------------------------------------------------------------

   618 //

   619 CArrayPtrFlat<CNssContext>* CNssVasDb::GetAllContexts()

   620     {   

   621     RUBY_DEBUG0("CNssVasDb::GetAllContexts");

   622     

   623     _LIT( KSQLGetAll,"select * from contexttable ");

   624 

   625     iSQLStatement = KSQLGetAll;

   626 

   627     CArrayPtrFlat<CNssContext>* ret( NULL );

   628     TRAPD( error, ret = GetContextL( iSQLStatement ) );

   629     if ( error != KErrNone )

   630         {

   631         return NULL;

   632         }

   633     return ret;

   634     }

   635 

   636 

   637 // -----------------------------------------------------------------------------

   638 // CNssVasDb::GetContextL

   639 // Executes the SQL query. After the query has selected a list of contexts,

   640 // these contexts are read from DB to memory.

   641 // -----------------------------------------------------------------------------

   642 //

   643 CArrayPtrFlat<CNssContext>* CNssVasDb::GetContextL(const TDesC& aSQLStatement)

   644     {

   645     RUBY_DEBUG_BLOCK("CNssVasDb::GetContextL");

   646 

   647     __ASSERT_DEBUG( aSQLStatement.Left( 6 ).Compare( _L("select") ) == 0,

   648                     User::Panic( KVasDbPanic, __LINE__ ) );

   649 

   650     if ( !iClientHasOpenedDatabase )

   651         {

   652         User::Leave( KErrDbNotSet );

   653         }

   654 

   655     TInt ret = StartTransaction();

   656     RUBY_DEBUG1("Started transaction. Error code [%d]", ret);

   657     

   658     CreatePushRollbackItemLC();

   659     CArrayPtrFlat<CNssContext>* contextList = GetContextInsideTransactionL( aSQLStatement );

   660 

   661     // Rollback cleanup (just to avoid automatic locking)

   662     CleanupStack::Pop();  // Rollback cleanup item 

   663     CommitTransaction( EFalse );

   664 

   665     return contextList;

   666     }

   667 

   668 // -----------------------------------------------------------------------------

   669 // CNssVasDb::GetContextInsideTransaction

   670 // Reads a context by name. Assumes that a transaction has already been started.

   671 // -----------------------------------------------------------------------------

   672 //

   673 CArrayPtrFlat<CNssContext>* CNssVasDb::GetContextInsideTransactionL( const TDesC& aSQLStatement )

   674     {

   675     RUBY_DEBUG_BLOCK("CNssVasDb::GetContextInsideTransactionL");

   676     RDbView view;

   677 

   678     CleanupClosePushL(view);

   679 

   680     User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( aSQLStatement, EDbCompareNormal ) ) );

   681     RUBY_DEBUG0("CNssVasDb::GetContextInsideTransactionL Prepared query");

   682     User::LeaveIfError( view.EvaluateAll() );

   683     RUBY_DEBUG0("CNssVasDb::GetContextInsideTransactionL Evaluated query");

   684 

   685     if ( view.IsEmptyL() )

   686         {

   687         RUBY_DEBUG0("CNssVasDb::GetContextInsideTransactionL Empty view. Leaving with KErrNotFound");

   688 	    User::Leave( KErrNotFound );

   689         }

   690 

   691     CArrayPtrFlat<CNssContext>* contextList = 

   692             new (ELeave) CArrayPtrFlat<CNssContext>( KContextListGranularity );

   693     CleanupStack::PushL( contextList );

   694     CleanupResetAndDestroyPushL( *contextList );

   695     RUBY_DEBUG0("CNssVasDb::GetContextInsideTransactionL Before FillContextListArrayL");

   696 

   697     FillContextListArrayL(view, *contextList);

   698    

   699     CleanupStack::Pop( contextList ); // ResetAndDestroy

   700     CleanupStack::Pop( contextList );  // array itself

   701     CleanupStack::PopAndDestroy( &view );// close view

   702 

   703     return( contextList );

   704     }

   705 

   706 // -----------------------------------------------------------------------------

   707 // CNssVasDb::GetTagReferenceList

   708 // Fetches tag references for all tags in a context.

   709 // -----------------------------------------------------------------------------

   710 //

   711 TNssTagReferenceListArray* CNssVasDb::GetTagReferenceListL( TInt aContextId )

   712     {

   713     RUBY_DEBUG_BLOCK( "CNssVasDb::GetTagReferenceListL" );

   714     

   715     RDbView view;

   716     TNssTagReference tagRef;

   717 

   718     TNssTagReferenceListArray* tagArray = 

   719             new (ELeave) TNssTagReferenceListArray( KMaxTagArraySize );

   720     CleanupStack::PushL( tagArray );

   721 

   722     if ( !iClientHasOpenedDatabase )

   723         {

   724         User::Leave( KErrDbNotSet );

   725         }

   726 

   727     // Start transaction - lock database

   728     StartTransaction();

   729     CreatePushRollbackItemLC();

   730 

   731     // Make a query, which lists all tags in the context.

   732     // Making a CNssTagReferece only requires tagid and name.

   733     _LIT( KSQLGetTag, "select tagid,name from tagtable where contextid=" );

   734     iSQLStatement = KSQLGetTag;

   735     iSQLStatement.AppendNumUC( aContextId );

   736 

   737     CleanupClosePushL(view);

   738 

   739     User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );

   740     User::LeaveIfError( view.EvaluateAll() );

   741 

   742     if ( view.IsEmptyL() )

   743         {

   744 	    User::Leave( KErrNotFound );

   745         }

   746 

   747     // Get column set

   748     CDbColSet* columns = view.ColSetL();

   749     // Get column ordinals

   750     TDbColNo name_col  = columns->ColNo( KNameCol );

   751     TDbColNo tagid_col = columns->ColNo( KTagIdCol );

   752 

   753     delete columns;

   754 

   755     for( view.FirstL(); view.AtRow(); view.NextL() )

   756         {

   757         view.GetL();

   758 	    tagRef.iTagName = view.ColDes( name_col );

   759 	    tagRef.iTagId   = view.ColUint32( tagid_col );

   760 	    tagArray->AppendL( tagRef );

   761         }

   762 

   763     // Close view

   764     CleanupStack::PopAndDestroy( &view );

   765 

   766     // Finish transaction - release lock

   767     CleanupStack::Pop();  // Rollback cleanup item

   768     CommitTransaction( EFalse );

   769 

   770     // Return result

   771     CleanupStack::Pop( tagArray );

   772 

   773     return( tagArray );

   774     }

   775 

   776 // -----------------------------------------------------------------------------

   777 // CNssVasDb::SaveTagL

   778 // Saves a newly created tag. When a tag is saved, a Tag ID is assigned to it.

   779 // This Tag ID is returned in the reference parameter.

   780 // -----------------------------------------------------------------------------

   781 //

   782 void CNssVasDb::SaveTagL( CNssTag& aTag, TInt& aNewId )

   783     {

   784     if ( !iClientHasOpenedDatabase )

   785         {

   786         RUBY_DEBUG0( "CNssVasDb error: database not opened." );

   787         

   788         User::Leave( KErrNotReady );

   789         }

   790 

   791     // Locks the database for the use of this process only	

   792     

   793     TInt error = StartTransaction();

   794 

   795     if ( error != KErrNone )

   796         {

   797         RUBY_DEBUG0( "CNssVasDb error: could not lock database." );

   798         

   799         User::Leave( KErrGeneral );

   800         }

   801 

   802     TInt contextId; // Discard context ID 

   803     

   804     CNssContext* context = static_cast<CNssContext*> ( aTag.Context() );

   805     TRAP( error, SaveContextL( context, contextId ) );

   806 	

   807     if ( error == KErrItemAlreadyExist || error == KErrNone )

   808         {

   809         TRAP( error, SaveTagL( &aTag, aNewId ) );

   810         }

   811     else 

   812         {

   813         RollbackTransaction(); 

   814         User::Leave( error );

   815         }

   816     

   817     // Check SavetagL result

   818     if ( error != KErrNone )

   819         {

   820         RollbackTransaction(); 	

   821         User::Leave( error );

   822         }

   823     else

   824         {

   825         CNssRRD* rrd = static_cast<CNssRRD*>( aTag.RRD() );

   826         rrd->SetTagId( aNewId );

   827 

   828         TRAPD( error, SaveRRDL( rrd ) );

   829 	    REACT( error, RUBY_DEBUG0( "RRD saving failed." ) );

   830 

   831         CommitIfSuccess( iDatabase, error, ETrue );

   832         }

   833         

   834     User::LeaveIfError( error );

   835     }

   836 

   837 // ---------------------------------------------------------

   838 // CNssVasDb::SaveTagsL

   839 // Saves several tags in one commit.

   840 // ---------------------------------------------------------

   841 //

   842 void CNssVasDb::SaveTagsL( CArrayPtrFlat<CNssTag>* aTagArray, RArray<TInt>& aTagIdArray )

   843     {

   844     TInt k( 0 );

   845     TInt error( KErrNone );

   846 

   847     if ( !iClientHasOpenedDatabase )

   848         {

   849         User::Leave( KErrDbNotSet );

   850         }

   851 

   852     // Locks the database for the use of this process only	

   853     User::LeaveIfError( StartTransaction() );

   854 

   855     CreatePushRollbackItemLC(); // Stack: rollback cleanup

   856 

   857     RArray<TInt> contextIds;

   858     CleanupClosePushL( contextIds ); // Stack: rollback cleanup, contextIds

   859 

   860     for ( k = 0; k < aTagArray->Count(); k++ )

   861         {

   862         CNssTag* tag = (*aTagArray)[k];

   863         CNssContext* context = static_cast<CNssContext*> ( tag->Context() );

   864 

   865         if ( contextIds.Find( context->ContextId() ) == KErrNotFound )

   866             {

   867             TInt contextId;

   868             TRAP( error, SaveContextL( context, contextId ) );

   869 

   870             // We accept leaves with error KErrAlreadyExists

   871             if ( error != KErrNone && error != KErrAlreadyExists )

   872                 {

   873                 break;

   874                 }

   875 

   876             contextIds.Append( context->ContextId() );

   877             }

   878         }

   879 

   880     // Close context id array

   881     CleanupStack::PopAndDestroy( &contextIds ); // Stack: Rollback cleanup

   882 

   883     // We accept leaves with error KErrAlreadyExists

   884     if ( error != KErrNone && error != KErrAlreadyExists )

   885         {

   886         User::Leave( error );

   887         }

   888 

   889     TInt id;

   890     for ( k = 0; k < aTagArray->Count(); k++ )

   891         {

   892         CNssTag* tag = (*aTagArray)[k];

   893 

   894         if ( tag->TagId() == KNssVASDbDefaultValue )

   895             {

   896             SaveTagL( tag, id );

   897 

   898             CNssRRD* rrd = static_cast<CNssRRD*>( tag->RRD() );

   899             rrd->SetTagId( id );

   900 

   901 	        SaveRRDL( rrd );

   902             User::LeaveIfError( aTagIdArray.Append( id ) );

   903             }

   904         else{

   905             UpdateTagInTransactionL( *tag );

   906             User::LeaveIfError( aTagIdArray.Append( tag->TagId() ) );

   907             }

   908         }

   909 

   910     User::LeaveIfError( CommitTransaction( ETrue ) );

   911 

   912     // Pop rollback cleanup

   913     // (which would have made database rollback, if a leave had happened)

   914     CleanupStack::Pop();  // Rollback cleanup item

   915     }

   916 

   917 // ---------------------------------------------------------

   918 // CNssVasDb::DeleteTagsL

   919 // Deletes several tags in one commit.

   920 // ---------------------------------------------------------

   921 //

   922 void CNssVasDb::DeleteTagsL( const RArray<TUint32>& aTagIdArray )

   923     {

   924     TInt k( 0 );

   925    

   926     if ( !iClientHasOpenedDatabase )

   927         {

   928         User::Leave( KErrDbNotSet );

   929         }

   930 

   931     // Locks the database for the use of this process only	

   932     User::LeaveIfError( StartTransaction() );

   933 

   934     CreatePushRollbackItemLC();

   935 

   936     for ( k = 0; k < aTagIdArray.Count(); k++ )

   937         {

   938         DeleteTagInsideTransactionL( aTagIdArray[k] );

   939         }

   940 

   941     User::LeaveIfError( CommitTransaction( ETrue ) );

   942 

   943     // Pop rollback cleanup

   944     // (which would have made database rollback, if a leave had happened)

   945     CleanupStack::Pop();  // Rollback cleanup item

   946     }

   947 

   948 // -----------------------------------------------------------------------------

   949 // CNssVasDb::UpdateTagL

   950 // Updates the data of an existing tag.

   951 // -----------------------------------------------------------------------------

   952 //

   953 void CNssVasDb::UpdateTagL( CNssTag& aTag )

   954     {

   955     RUBY_DEBUG_BLOCK( "CNssVasDb::UpdateTagL" );	

   956 

   957     if ( !iClientHasOpenedDatabase )

   958         {

   959         RUBY_DEBUG0( "CNssVasDb error: database not opened." );

   960         

   961         User::Leave( KErrNotReady );

   962         }

   963 	

   964     // Locks the database for the use of this process only

   965     User::LeaveIfError( StartTransaction() );

   966 

   967     TRAPD( error, UpdateTagInTransactionL( aTag ) );

   968 

   969     CommitIfSuccess( iDatabase, error, ETrue );

   970 

   971     User::LeaveIfError( error );

   972     }

   973 

   974 

   975 // -----------------------------------------------------------------------------

   976 // CNssVasDb::UpdateTagRuleIDs

   977 // Changes the Rule IDs of some tags. The Rule ID changes, when

   978 // and already trained tags is retrained.

   979 // -----------------------------------------------------------------------------

   980 //

   981 void CNssVasDb::UpdateTagRuleIDsL( const RArray<TNssSpeechItem>& aRetrainedTags )

   982     {

   983     TInt error( KErrNone );

   984     if ( !iClientHasOpenedDatabase )

   985         {

   986         User::Leave( KErrDbNotSet );

   987         }

   988    

   989     _LIT( KSQLUpdateTag,"update tagtable set ");

   990     _LIT( KEqual,"=");

   991     _LIT( KSQLWhereTagIdIs," where tagid = ");

   992 

   993     TInt count = aRetrainedTags.Count();

   994 

   995     if ( count > 0 )

   996         {

   997         return;

   998         }

   999 

  1000     // Start transaction

  1001     User::LeaveIfError( StartTransaction() );

  1002     CreatePushRollbackItemLC();

  1003 

  1004     // Make the changes to Rule IDs

  1005     for ( TInt k( 0 ); k < count; k++ )

  1006         {

  1007         // "update tagtable set "

  1008         iSQLStatement = KSQLUpdateTag;

  1009 

  1010         // "ruleid=1234"

  1011         iSQLStatement.Append( KRuleIdCol );

  1012         iSQLStatement.Append( KEqual );

  1013         iSQLStatement.AppendNumUC( aRetrainedTags[k].iRuleId );

  1014 

  1015         // " where tagid = 5678"

  1016         iSQLStatement.Append( KSQLWhereTagIdIs );

  1017         iSQLStatement.AppendNumUC( aRetrainedTags[k].iTagId );

  1018 

  1019         error =  iDatabase.Execute( iSQLStatement );

  1020         if ( error < KErrNone )

  1021             {

  1022             ReleaseDiskSpace();

  1023             User::Leave( error );

  1024             }

  1025         }

  1026 

  1027     // Commit transaction

  1028     error = CommitTransaction( ETrue );

  1029     if ( error )

  1030         {

  1031         ReleaseDiskSpace();

  1032         User::Leave( error );

  1033         }

  1034 

  1035     // Pop rollback cleanup object

  1036     CleanupStack::Pop();  // Rollback cleanup item

  1037 

  1038     ReleaseDiskSpace();    

  1039     }

  1040 

  1041 

  1042 // -----------------------------------------------------------------------------

  1043 // CNssVasDb::SaveContextL

  1044 // Saves a newly created context. When a context is saved, a Context ID is

  1045 // assigned to it. This id is returned using the reference parameter.

  1046 // -----------------------------------------------------------------------------

  1047 //

  1048 void CNssVasDb::SaveContextL( CNssContext* aContext, TInt& aContextId )

  1049     {

  1050     TBuf<KNssVasDbContextName> name;

  1051     RDbView view1;

  1052 

  1053     _LIT( KSQLAdd, "select * from contexttable " );

  1054     _LIT( KSQLWhereName, "where name='" );

  1055     _LIT( KTick, "' " );

  1056 

  1057     //Check to see if a context already exist with the new name

  1058     iSQLStatement = KSQLAdd;

  1059     iSQLStatement.Append( KSQLWhereName );

  1060     iSQLStatement.Append( aContext->ContextName() );

  1061     iSQLStatement.Append( KTick );

  1062 	

  1063     CleanupClosePushL( view1 );

  1064    

  1065     User::LeaveIfError( view1.Prepare( iDatabase, TDbQuery( iSQLStatement, EDbCompareNormal ) ) );	

  1066     User::LeaveIfError( view1.EvaluateAll() );

  1067 

  1068     if ( !view1.IsEmptyL() ) // context with that name already exist so return status

  1069         {  

  1070         // Get column set

  1071         CDbColSet* columns1 = view1.ColSetL();

  1072         TDbColNo contextid_col = columns1->ColNo( KContextIdCol );

  1073 

  1074 	    delete columns1;

  1075 

  1076         view1.FirstL();

  1077         view1.GetL();

  1078 	    //Get the  unique contextid key just generated

  1079 	    aContextId = view1.ColUint32(contextid_col);

  1080 	    aContext->SetContextId( aContextId );

  1081 

  1082 	    view1.Close();	  

  1083 	    CleanupStack::PopAndDestroy( &view1 );

  1084         

  1085         User::Leave( KErrAlreadyExists );

  1086         }

  1087     else{

  1088         view1.Close();

  1089 	    CleanupStack::PopAndDestroy( &view1 );

  1090 	   

  1091 	    RDbView view2;

  1092 

  1093         CleanupClosePushL( view2 );

  1094 

  1095 	    User::LeaveIfError( view2.Prepare( iDatabase, TDbQuery(KSQLAdd,EDbCompareNormal)));	

  1096         User::LeaveIfError( view2.EvaluateAll() );

  1097   

  1098 	    // Get column set

  1099         CDbColSet* columns = view2.ColSetL();

  1100         // Get column ordinals

  1101         TDbColNo name_col = columns->ColNo( KNameCol );

  1102         TDbColNo global_col = columns->ColNo( KGlobalCol );

  1103 	    TDbColNo grammarid_col = columns->ColNo( KGrammarIdCol );

  1104 	    TDbColNo lexiconid_col = columns->ColNo( KLexiconIdCol );

  1105 	    TDbColNo modelbankid_col = columns->ColNo( KModelBankIdCol );

  1106 	    TDbColNo contextid_col = columns->ColNo( KContextIdCol );

  1107 

  1108 	    delete columns;

  1109 

  1110 	    // Begin process of inserting a row...

  1111 	    view2.InsertL();

  1112 	    // set column values...

  1113 	    view2.SetColL( name_col, aContext->ContextName() );

  1114 	    view2.SetColL( global_col, aContext->IsGlobal() );

  1115 	    view2.SetColL( lexiconid_col, aContext->LexiconId() );

  1116 	    view2.SetColL( grammarid_col, aContext->GrammarId() );

  1117 	    view2.SetColL( modelbankid_col, aContext->ModelBankId() );

  1118 	

  1119 	    // add the row to the table...

  1120 	    view2.PutL();

  1121 	             

  1122 	    view2.GetL();

  1123         //Get the  unique contextid key just generated

  1124 	    aContextId = view2.ColUint32( contextid_col );

  1125 

  1126 	    aContext->SetContextId( aContextId );

  1127 

  1128 	    name = view2.ColDes( name_col );

  1129 	  

  1130 	    view2.Close();

  1131 	    CleanupStack::PopAndDestroy( &view2 );

  1132         }

  1133     }

  1134 

  1135 // -----------------------------------------------------------------------------