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:  RNssVasDbSession is the client-side(proxy) interface through which 

    15 *               communication with the vasdb server is channelled.

    16 *

    17 */

    18 

    19 

    20 #include "nssvasrvasdbsession.h"

    21 #include "nssvascvasdb.h"

    22 

    23 // Complementary macro for TRAPD:

    24 // TRAPD( err, doSomething() );

    25 // REACT( err, return( err ) );

    26 #define REACT(a,b) if ( a < 0 ) {b;}

    27 	

    28 // -----------------------------------------------------------------------------

    29 // RNssVasDbSession::RNssVasDbSession

    30 // C++ constructor

    31 // -----------------------------------------------------------------------------

    32 //

    33 RNssVasDbSession::RNssVasDbSession()

    34     {

    35     iConnected = 0;

    36     }

    37 	

    38 // -----------------------------------------------------------------------------

    39 // RNssVasDbSession::~RNssVasDbSession

    40 // C++ destructor.

    41 // -----------------------------------------------------------------------------

    42 //

    43 RNssVasDbSession::~RNssVasDbSession()

    44     {

    45     delete iVasDb;

    46     }

    47 

    48 // -----------------------------------------------------------------------------

    49 // RNssVasDbSession::CreateDatabase

    50 // Method to create the database.

    51 // -----------------------------------------------------------------------------

    52 //

    53 TInt RNssVasDbSession::CreateDatabase()

    54     {

    55     TRAPD( error, iVasDb->CreateDatabaseL() );

    56     

    57     return error;

    58     }

    59 

    60 // -----------------------------------------------------------------------------

    61 // RNssVasDbSession::OpenDatabase

    62 // Method to open the database.

    63 // -----------------------------------------------------------------------------

    64 //

    65 TInt RNssVasDbSession::OpenDatabase()

    66     {

    67     if ( iConnected )

    68         {

    69         iConnected++;

    70         return KErrDbAlreadyOpen;

    71         }

    72 

    73     TRAPD( error, iVasDb->OpenDatabaseL() ); 

    74 

    75     if ( error == KErrNone )

    76         {

    77         iConnected++;

    78         }

    79 

    80     return error;

    81     }

    82 	

    83 // -----------------------------------------------------------------------------

    84 // RNssVasDbSession::CloseDatabase

    85 // Method to close the database.

    86 // -----------------------------------------------------------------------------

    87 //

    88 TInt RNssVasDbSession::CloseDatabase()

    89     {

    90     // Check if already closed (or never opened)

    91     if ( iConnected <= 0 )

    92         {

    93         return( KErrNone );

    94         }

    95 

    96     // Some other VAS instance in the same thread may be using the database.

    97     iConnected--;

    98 

    99     // If not, close it.

   100     if ( iConnected <= 0 )

   101         {

   102         return iVasDb->CloseDatabase();

   103         }

   104 

   105     return( KErrNone );

   106     }

   107 	

   108 // -----------------------------------------------------------------------------

   109 // RNssVasDbSession::ModelBankIdLexiconId

   110 // A method to get the model bank id and lexicon id.

   111 // -----------------------------------------------------------------------------

   112 //

   113 TBool RNssVasDbSession::ModelBankIdLexiconId( TUint32& aModelBankId, TUint32& aLexiconId )

   114     {

   115     TBool ret = EFalse;

   116 

   117     TRAPD( err, ret = iVasDb->GetModelBankIdLexiconIdL( aModelBankId, aLexiconId ) );

   118 

   119     // To remove warning

   120     if ( err != KErrNone )

   121         {

   122         }

   123 

   124     return ret;

   125     }

   126 

   127 // -----------------------------------------------------------------------------

   128 // RNssVasDbSession::TagExist

   129 // Method to check whether the context has tags or it is empty.

   130 // -----------------------------------------------------------------------------

   131 //

   132 TBool RNssVasDbSession::TagExist(TInt aContextId)

   133     {

   134     TBool tagExists = EFalse;

   135 

   136     TRAPD( err, tagExists = iVasDb->TagExistL( aContextId ) );

   137     REACT( err, tagExists = EFalse );

   138 

   139     return( tagExists );

   140     }

   141 

   142 // -----------------------------------------------------------------------------

   143 // RNssVasDbSession::TagCount

   144 // Method to return the number of tags in a context.

   145 // -----------------------------------------------------------------------------

   146 //

   147 TInt RNssVasDbSession::TagCount(TInt aContextId)

   148     {

   149     TInt ret = 0;

   150 

   151     TRAPD( err, ret = iVasDb->TagCountL( aContextId ) );

   152 

   153     // To remove warning

   154     if ( err != KErrNone )

   155         {

   156         }

   157 

   158     return ret;

   159     }

   160 

   161 // -----------------------------------------------------------------------------

   162 // RNssVasDbSession::SaveContext

   163 // Method to save a context. When a context is saved, a context ID is 

   164 // assigned to it. The newly assigned ID is returned

   165 // -----------------------------------------------------------------------------

   166 //

   167 TInt RNssVasDbSession::SaveContext( CNssContext& aContext, TInt& aContextId )

   168     {

   169     TRAPD( error, iVasDb->SaveContextL( aContext, aContextId ) );

   170 

   171 	return error;

   172     }

   173 

   174 // -----------------------------------------------------------------------------

   175 // RNssVasDbSession::UpdateContext

   176 // Method to update the data of a context.

   177 // -----------------------------------------------------------------------------

   178 //

   179 TInt RNssVasDbSession::UpdateContext(CNssContext& aContext)

   180     {

   181     TInt ret = KErrNone;

   182 

   183     TRAP( ret, iVasDb->UpdateContextL( aContext ) ); 

   184 

   185     return ret;

   186     }

   187 

   188 // -----------------------------------------------------------------------------

   189 // RNssVasDbSession::UpdateContextClientData

   190 // Method to update the client data of a context.

   191 // -----------------------------------------------------------------------------

   192 //

   193 TInt RNssVasDbSession::UpdateContextClientData(CNssContext& aContext)

   194     {

   195     TInt ret = KErrNone;

   196 

   197     TRAP( ret, iVasDb->UpdateContextClientDataL( aContext ) );

   198 

   199     return ret;

   200     }

   201 

   202 // -----------------------------------------------------------------------------

   203 // RNssVasDbSession::GetContextByName

   204 // Method to get a context by name.

   205 // -----------------------------------------------------------------------------

   206 //

   207 CArrayPtrFlat<CNssContext>* RNssVasDbSession::GetContextByName(const TDesC& aName)

   208     {

   209     //CArrayFixFlat<CNssContext>* res = 0;

   210     CArrayPtrFlat<CNssContext>* res = 0;

   211 

   212     TRAPD( err, res = iVasDb->GetContextByNameL( aName ) );

   213 

   214     // To remove warning

   215     if ( err != KErrNone )

   216         {

   217         }

   218 

   219     return( res );

   220     }

   221 

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

   223 // RNssVasDbSession::GetAllGlobalContexts

   224 // Method to list all global contexts.

   225 // -----------------------------------------------------------------------------

   226 //

   227 //CArrayFixFlat<CNssContext>* RNssVasDbSession::GetGlobalContexts()

   228 CArrayPtrFlat<CNssContext>* RNssVasDbSession::GetGlobalContexts()

   229     {

   230     //CArrayFixFlat<CNssContext>* res = 0;

   231     CArrayPtrFlat<CNssContext>* res = 0;

   232 

   233     TRAPD( err, res = iVasDb->GetGlobalContexts() );

   234 

   235     // To remove warning

   236     if ( err != KErrNone )

   237         {

   238         }

   239 

   240     return( res );

   241     }

   242 

   243 // -----------------------------------------------------------------------------

   244 // RNssVasDbSession::GetAllContexts

   245 // Method to list all contexts.

   246 // -----------------------------------------------------------------------------

   247 //

   248 //CArrayFixFlat<CNssContext>* RNssVasDbSession::GetAllContexts()

   249 CArrayPtrFlat<CNssContext>* RNssVasDbSession::GetAllContexts()

   250     {

   251     //CArrayFixFlat<CNssContext>* res = 0;

   252     CArrayPtrFlat<CNssContext>* res = 0;

   253 

   254     TRAPD( err, res = iVasDb->GetAllContexts() );

   255 

   256     // To remove warning

   257     if ( err != KErrNone )

   258         {

   259         }

   260 

   261     return( res );

   262     }

   263 

   264 // -----------------------------------------------------------------------------

   265 // RNssVasDbSession::GetTag

   266 // Method to get all tags in a context.

   267 // -----------------------------------------------------------------------------

   268 //

   269 //TNssTagListArray* RNssVasDbSession::GetTag( const TNssContext& aContext )

   270 CArrayPtrFlat<CNssTag>* RNssVasDbSession::GetTag( const CNssContext& aContext )

   271     {

   272     //TNssTagListArray* res = NULL;

   273     CArrayPtrFlat<CNssTag>* res = NULL;

   274 

   275     TRAPD( err, res = iVasDb->GetTagL( aContext ) );

   276 

   277     // To remove warning

   278     if ( err != KErrNone )

   279         {

   280         }

   281 

   282     return( res );

   283     }

   284 

   285 // -----------------------------------------------------------------------------

   286 // RNssVasDbSession::GetTag

   287 // Method to get a tag by grammar ID and rule ID.

   288 // -----------------------------------------------------------------------------

   289 //

   290 //TNssTagListArray* RNssVasDbSession::GetTag( TNssGrammarIdRuleId aGrammarIdRuleId )

   291 CArrayPtrFlat<CNssTag>* RNssVasDbSession::GetTag( TNssGrammarIdRuleId aGrammarIdRuleId )

   292     {

   293     //TNssTagListArray* res = NULL;

   294     CArrayPtrFlat<CNssTag>* res = NULL;

   295 

   296     TRAPD( err, res = iVasDb->GetTagL( aGrammarIdRuleId ) );

   297 

   298     // To remove warning

   299     if ( err != KErrNone )

   300         {

   301         }

   302 

   303     return( res );

   304     }

   305 

   306 // -----------------------------------------------------------------------------

   307 // RNssVasDbSession::GetTags

   308 // Method to get tags by their grammar ID and rule ID.

   309 // -----------------------------------------------------------------------------

   310 //

   311 //TNssTagListArray* RNssVasDbSession::GetTags( TNssGrammarIdRuleIdListArray& aGrammarIdRuleIds )

   312 CArrayPtrFlat<CNssTag>* RNssVasDbSession::GetTags( 

   313                         TNssGrammarIdRuleIdListArray& aGrammarIdRuleIds )

   314     {

   315     //TNssTagListArray* res = NULL;

   316     CArrayPtrFlat<CNssTag>* res = NULL;

   317 

   318     TRAPD( err, res = iVasDb->GetTagsL( aGrammarIdRuleIds ) );

   319 

   320     // To remove warning

   321     if ( err != KErrNone )

   322         {

   323         }

   324 

   325     return( res );

   326     }

   327 

   328 // -----------------------------------------------------------------------------

   329 // RNssVasDbSession::GetTag

   330 // Method to get a tag by name (CNssSpeechItem::SetText).

   331 // -----------------------------------------------------------------------------

   332 //

   333 //TNssTagListArray* RNssVasDbSession::GetTag( const TDesC& aName )

   334 CArrayPtrFlat<CNssTag>* RNssVasDbSession::GetTag( const TDesC& aName )

   335     {

   336     //TNssTagListArray* res = NULL;

   337     CArrayPtrFlat<CNssTag>* res = NULL;

   338 

   339     TRAPD( err, res = iVasDb->GetTagL( aName ) );

   340 

   341     // To remove warning

   342     if ( err != KErrNone )

   343         {

   344         }

   345 

   346     return( res );

   347     }

   348 

   349 // -----------------------------------------------------------------------------

   350 // RNssVasDbSession::GetTag

   351 // Method to get a tag by RRD data, given RRD integer and the position (0-4)

   352 // to which the integer is compared.

   353 // -----------------------------------------------------------------------------

   354 //

   355 //TNssTagListArray* RNssVasDbSession::GetTag( TInt aContextId, TInt aNum, TInt aPosition )

   356 CArrayPtrFlat<CNssTag>* RNssVasDbSession::GetTag( TInt aContextId, TInt aNum, TInt aPosition )

   357     {

   358     //TNssTagListArray* res = NULL;

   359     CArrayPtrFlat<CNssTag>* res = NULL;

   360 

   361     TRAPD( err, res = iVasDb->GetTagL( aContextId, aNum, aPosition ) );

   362 

   363     // To remove warning

   364     if ( err != KErrNone )

   365         {

   366         }

   367 

   368     return( res );

   369     }

   370 

   371 // -----------------------------------------------------------------------------

   372 // RNssVasDbSession::GetTag

   373 // Method to get a tag by RRD data, given RRD text and the position (0-4)

   374 // to which the text is compared.

   375 // -----------------------------------------------------------------------------

   376 //

   377 //TNssTagListArray* RNssVasDbSession::GetTag( TInt aContextId, TDesC& aText, TInt aPosition )

   378 CArrayPtrFlat<CNssTag>* RNssVasDbSession::GetTag( TInt aContextId, 

   379                                                   const TDesC& aText, TInt aPosition )

   380     {

   381     //TNssTagListArray* res = NULL;

   382     CArrayPtrFlat<CNssTag>* res = NULL;

   383 

   384     TRAPD( err, res = iVasDb->GetTagL( aContextId, aText, aPosition ) );

   385 

   386     // To remove warning

   387     if ( err != KErrNone )

   388         {

   389         }

   390 

   391     return( res );

   392     }

   393 

   394 // -----------------------------------------------------------------------------

   395 // RNssVasDbSession::GetTag

   396 // Method to get a tag, given the tag ID.

   397 // -----------------------------------------------------------------------------

   398 //

   399 //TNssTagListArray* RNssVasDbSession::GetTag( TUint32 aTagId )

   400 CArrayPtrFlat<CNssTag>* RNssVasDbSession::GetTag( TUint32 aTagId )

   401     {

   402     //TNssTagListArray* res = NULL;

   403     CArrayPtrFlat<CNssTag>* res = NULL;

   404 

   405     TRAPD( err, res = iVasDb->GetTagL( aTagId ) );

   406 

   407     // To remove warning

   408     if ( err != KErrNone )

   409         {

   410         }

   411 

   412     return( res );

   413     }

   414 

   415 // -----------------------------------------------------------------------------

   416 // RNssVasDbSession::SaveTag

   417 // Method to save a tag. During saving, a Tag ID is assigned for the tag.

   418 // This ID is returned in the refrence parameter.

   419 // -----------------------------------------------------------------------------

   420 //

   421 //TInt RNssVasDbSession::SaveTag( TNssTag& aTag, TInt& aNewId )

   422 TInt RNssVasDbSession::SaveTag( CNssTag& aTag, TInt& aNewId )

   423     {

   424     TInt ret = 0;

   425 

   426     TRAPD( err, iVasDb->SaveTagL( aTag, aNewId ) );

   427     REACT( err, ret = err );

   428 

   429     return ret;

   430     }

   431 

   432 // -----------------------------------------------------------------------------

   433 // RNssVasDbSession::SaveTags

   434 // Method to save a group of tags. During saving, a Tag IDs are assigned

   435 // for the tags. These IDs is returned in the aTagIdArray.

   436 // -----------------------------------------------------------------------------

   437 //

   438 //TInt RNssVasDbSession::SaveTags( CArrayFixFlat<TNssTag>* aTagArray, RArray<TInt>& aTagIdArray )

   439 TInt RNssVasDbSession::SaveTags( CArrayPtrFlat<CNssTag>* aTagArray, RArray<TInt>& aTagIdArray )

   440     {

   441     TRAPD( ret, iVasDb->SaveTagsL( aTagArray, aTagIdArray ) );

   442 

   443     return ret;

   444     }

   445 

   446 // -----------------------------------------------------------------------------

   447 // RNssVasDbSession::DeleteTag

   448 // Method to delete a group of tags.

   449 // -----------------------------------------------------------------------------

   450 //

   451 TInt RNssVasDbSession::DeleteTags( const RArray<TUint32>& aTagIdArray )

   452     {

   453     TRAPD( ret, iVasDb->DeleteTagsL( aTagIdArray ) );

   454 

   455     return ret;

   456     }

   457 

   458 // -----------------------------------------------------------------------------

   459 // RNssVasDbSession::UpdateTag

   460 // Method to update the information of an existing tag.

   461 // -----------------------------------------------------------------------------

   462 //

   463 //TInt RNssVasDbSession::UpdateTag( const TNssTag& /*aTag*/ )

   464 TInt RNssVasDbSession::UpdateTag( const CNssTag& /*aTag*/ )

   465     {

   466     return KErrNotSupported;

   467     }

   468 

   469 // -----------------------------------------------------------------------------

   470 // RNssVasDbSession::UpdateTagRuleIDs

   471 // Method to update the Rule IDs of some tags.

   472 // -----------------------------------------------------------------------------

   473 //

   474 TInt RNssVasDbSession::UpdateTagRuleIDs( const RArray<TNssSpeechItem>& aRetrainedTags )

   475     {

   476     TRAPD( ret, iVasDb->UpdateTagRuleIDsL( aRetrainedTags ) );

   477     return( ret );

   478     }

   479 

   480 // -----------------------------------------------------------------------------

   481 // RNssVasDbSession::DeleteTag

   482 // Method to delete a tag by name.

   483 // -----------------------------------------------------------------------------

   484 //

   485 TInt RNssVasDbSession::DeleteTag( const TDesC& aTagName )

   486     {

   487     TRAPD( error, iVasDb->DeleteTagL( aTagName ) );

   488 

   489     return( error );

   490     }

   491 

   492 // -----------------------------------------------------------------------------

   493 // RNssVasDbSession::DeleteTag

   494 // Method to delete a tag by identifier.

   495 // -----------------------------------------------------------------------------

   496 //

   497 TInt RNssVasDbSession::DeleteTag( TInt aTagId )

   498     {

   499     TRAPD( error, iVasDb->DeleteTagL( aTagId ) );

   500 

   501     return( error );

   502     }

   503 

   504 // -----------------------------------------------------------------------------

   505 // RNssVasDbSession::DeleteContext

   506 // Method to delete a context from the database.

   507 // -----------------------------------------------------------------------------

   508 //

   509 TInt RNssVasDbSession::DeleteContext( const TDesC& aName )

   510     {

   511     TRAPD( err, iVasDb->DeleteContextL( aName ) );

   512 

   513     return( err );

   514     }

   515 

   516 // -----------------------------------------------------------------------------

   517 // RNssVasDbSession::GetTagReferenceList

   518 // Method to get references to all tags in a context.

   519 // -----------------------------------------------------------------------------

   520 //

   521 TNssTagReferenceListArray* RNssVasDbSession::GetTagReferenceList( TInt aContextId )

   522     {

   523     TNssTagReferenceListArray* result = 0;

   524    

   525     TRAPD( err, result = iVasDb->GetTagReferenceListL( aContextId ) );

   526 

   527     // To remove warning

   528     if ( err != KErrNone )

   529         {

   530         }

   531 

   532     return( result );

   533     }

   534 

   535 // -----------------------------------------------------------------------------

   536 // RNssVasDbSession::GetDefaultModelBankId

   537 // Method to get the default model bank id

   538 // -----------------------------------------------------------------------------

   539 //

   540 TInt RNssVasDbSession::GetDefaultModelBankId( TUint32& aId )

   541     {

   542     TRAPD( err, iVasDb->GetDefaultModelBankIdL( aId ) );

   543     return err;

   544     }

   545 

   546 // -----------------------------------------------------------------------------

   547 // RNssVasDbSession::ResetModelBank

   548 // Modifies the context table so that all contexts start using

   549 // the new id as their model bank id.

   550 // -----------------------------------------------------------------------------

   551 //

   552 TInt RNssVasDbSession::ResetModelBank( TUint32 aNewId )

   553     {

   554     TRAPD( err, iVasDb->ResetModelBankL( aNewId ) );

   555     return err;

   556     }