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:  The CNssSpeechItemTrainer provides methods to train, save

    15 *               and delete CNssSpeechItem objects in large quantities.

    16 *

    17 */

    18 

    19 

    20 /* Here is a state machine for training:

    21 *

    22 * Summary:

    23 *

    24 * Idle state

    25 *     |

    26 * Waiting state     <-------------------

    27 *     |                                | (loop back to waiting state)

    28 * ###################################  |

    29 * # IF NEEDED: Create lexicon state #  |

    30 * #            |                    #  |

    31 * # IF NEEDED: Create grammar state #---

    32 * #            |                    #

    33 * #       Training state            #

    34 * ###################################

    35 *     |

    36 * Idle state

    37 *

    38 *

    39 *

    40 * State: Idle state

    41 * Event: A client calls TrainTextL, 

    42 * Action:This induces a call to CNssSpeechItemTrainer::TrainTextDealyed().

    43 *

    44 *        The basic idea of _delayed_training_ is that several training calls

    45 *        are piled up before taking action. When a large number of names is

    46 *        trained at a time, the economies of scale are considerable.

    47 *

    48 *        So, TrainTextDelayed() adds the name to the to-be-trained list,

    49 *        and starts a _delay_timer_. When this delay timer has finished, the

    50 *        actual training starts.

    51 * Transition: Idle state -> Waiting state

    52 *

    53 *

    54 * State: Waiting state

    55 * Event: A client calls TrainTextL.

    56 * Action:The function adds the name to the to-be-trained list, and

    57 *        resets the timer

    58 *        (background: In contact synchronization via PC Suite, names are added

    59 *         every 1/2 seconds. We want to keep piling the names  as long as

    60 *         new names keep coming. Since we can't wait 50 seconds

    61 *         before training, the only reasonable solution is to reset the timer

    62 *         every time a new name arrives)

    63 * Transition: Waiting state -> Waiting state

    64 *

    65 *

    66 * State: Waiting state

    67 * Event: Timer finishes doing time.

    68 * Action:Check the preparations for training:

    69 *         * Has the grammar for the context been created?

    70 *         * Has the lexicon for the context been created?

    71 * CASE: Preconditions OK

    72 *       Action    : Send async AddVoiceTags call

    73 *       Transition: Waiting state -> Training state

    74 *

    75 * State: Training state

    76 * Event: Training finished

    77 * Action: Save the newly created Rule IDs to the speech items.

    78 *         Commit the database.

    79 *         Make the callbacks (success or failure) to the client.

    80 *

    81 * Transition: Check if new names were piled during traning.

    82 *         YES: Training state -> Waiting state

    83 *         NO : Training state -> Idle state

    84 *

    85 */

    86 

    87 #include "srsfbldvariant.hrh"

    88 #include "nssvascspeechitemtrainer.h"

    89 #include "nssvasctrainingparameters.h"

    90 #include "nssvascvasdatabase.h"

    91 #include "nssvasmsavetagclient.h"

    92 #include "nssvasmdeletetagclient.h"

    93 

    94 #include "rubydebug.h"

    95 

    96 #include <badesca.h>

    97 

    98 #ifdef _DEBUG

    99     // Used in UDEB only

   100     _LIT( KSpeechItemTrainerPanic, "VasCSpeechItemTrainer" );

   101 #endif  // _DEBUG

   102 

   103 #define DEBUGPANIC User::Panic( KSpeechItemTrainerPanic, __LINE__ )

   104 #define REACT( a, b ) if ( a != KErrNone ) { b; }

   105 #define CHECK_NOT_NULL( a ) \

   106     if ( !(a) ) \

   107         { \

   108         return MNssSpeechItem::EVasTrainFailed; \

   109         }

   110 #define ALLOWED_STATES( a, b, c ) \

   111     if ( iState != a && iState != b && iState != c ) \

   112         { \

   113         return MNssSpeechItem::EVasTrainFailed; \

   114         } 

   115 

   116 // tags are buffered in the buffer that grows with this granularity

   117 const TInt KTagBufferGranularity = 100;

   118 

   119 // rule ids are buffered in the buffer that grows with this granularity

   120 const TInt KRuleIdBufferGranularity = 50;

   121 

   122 // tag ids are buffered in the buffer that grows with this granularity

   123 const TInt KRemoveTagIdBufferGranularity = 50;

   124 

   125 // Granularity for the array of words per sinde phrase

   126 const TInt KSindeWordArrayGranularity = 2;

   127 

   128 

   129 // Local function declarations

   130 TInt EnforceRuleIdCountInvariant( RArray<TUint32>& aArray, TInt aCount );

   131 

   132 // ---------------------------------------------------------

   133 // CNssSpeechItemTrainer::CNssSpeechItemTrainer

   134 // C++ default constructor can NOT contain any code, that

   135 // might leave.

   136 // ---------------------------------------------------------

   137 //

   138 CNssSpeechItemTrainer::CNssSpeechItemTrainer( CNssVASDatabase* aDatabase )

   139 : iDatabase( aDatabase ),

   140   iSpeechItemBuffer       ( NULL ),

   141   iSpeechItemTrainingBuffer( NULL ),

   142   iGrammarIdBuffer        ( NULL ),

   143   iGrammarIdDeletingBuffer( NULL ),

   144   iTagBuffer(NULL)

   145     {

   146     // empty

   147     }

   148 

   149 

   150 // -----------------------------------------------------------------------------

   151 // CNssSpeechItemTrainer::ConstructL

   152 // Symbian 2nd phase constructor can leave.

   153 // This is overloaded function for SpeechItemTrainer from database

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

   155 //

   156 void CNssSpeechItemTrainer::ConstructL()

   157     {

   158     RUBY_DEBUG_BLOCK("CNssSpeechItemTrainer::ConstructL");

   159     iActionTracker = CNssTrainingActionTracker::NewL( *this );

   160 

   161     // Create buffer for grouping phrases in training

   162     iSpeechItemBuffer = new(ELeave)RPointerArray<CNssSpeechItem>;

   163     iSpeechItemTrainingBuffer = 0; // No name being currently trained.

   164     }

   165 

   166 

   167 // -----------------------------------------------------------------------------

   168 // CNssSpeechItemTrainer::NewL

   169 // Two-phased constructor.

   170 // This is for new SpeechItemTrainer

   171 // -----------------------------------------------------------------------------

   172 //

   173 CNssSpeechItemTrainer* CNssSpeechItemTrainer::NewL( CNssVASDatabase* aDatabase )

   174     {

   175     RUBY_DEBUG_BLOCK( "CNssSpeechItemTrainer::NewL" );

   176 

   177     CNssSpeechItemTrainer* self = NewLC( aDatabase );

   178     CleanupStack::Pop( self );

   179     return self;

   180     }

   181 

   182 

   183 // -----------------------------------------------------------------------------

   184 // CNssSpeechItemTrainer::NewLC

   185 // Two-phased constructor.

   186 // This is overloaded function for SpeechItemTrainer from database

   187 // -----------------------------------------------------------------------------

   188 //

   189 CNssSpeechItemTrainer* CNssSpeechItemTrainer::NewLC( CNssVASDatabase* aDatabase )

   190     {

   191     CNssSpeechItemTrainer* self

   192         = new (ELeave) CNssSpeechItemTrainer( aDatabase );

   193 

   194     CleanupStack::PushL( self );

   195     self->ConstructL();

   196     return self;

   197     }

   198 

   199 // ---------------------------------------------------------

   200 // CNssSpeechItemTrainer::~CNssSpeechItemTrainer

   201 // Delete the SpeechItemTrainer object and set the Portal's 

   202 // state to Terminate.

   203 // The Trainer does not delete the Portal, the Portal  

   204 // deletes itself.

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

   206 //

   207 CNssSpeechItemTrainer::~CNssSpeechItemTrainer()

   208     {

   209     RUBY_DEBUG0( "CNssSpeechItemTrainer::~CNssSpeechItemTrainer" );

   210 

   211     delete iActionTracker;

   212 

   213 

   214     // Buffer for grouping the MNssSpeechItems for efficient training.

   215     if ( iSpeechItemBuffer )

   216         {

   217         iSpeechItemBuffer->Reset();

   218         delete iSpeechItemBuffer;

   219         }

   220 

   221     // Names, which are being trained by CSISpeechRecognitionUtility.

   222     if ( iSpeechItemTrainingBuffer )

   223         {

   224         iSpeechItemTrainingBuffer->Reset();

   225         delete iSpeechItemTrainingBuffer;

   226         }

   227 

   228     // This buffer is sent to SRS Utility. Contains: The recognition phrase split into subwords.

   229     iPhraseArray.ResetAndDestroy();

   230 

   231     // Training parameters

   232     delete iTrainingParams;

   233 

   234     // Context

   235     delete iContext;

   236 

   237     // Rule ID array. Return values from AddVoiceTags() are placed here.

   238     if ( iRuleIDArray )

   239         {

   240         iRuleIDArray->Close();

   241         delete iRuleIDArray;

   242         }

   243       

   244     if ( iDeleteRuleIDArray )

   245     	{

   246         RUBY_DEBUG0( "CNssSpeechItemTrainer::~CNssSpeechItemTrainer Deleting iDeleteRuleIDArray" );

   247     	iDeleteRuleIDArray->Close();

   248     	delete iDeleteRuleIDArray;

   249     	}

   250 

   251     // Handle to speech services

   252     if ( iSrsApi )

   253         {

   254         iSrsApi->CancelUtility();

   255         delete iSrsApi;

   256         iSrsApi = NULL;

   257         }

   258 

   259     // The tags to be saved: Owned by client

   260     // RPointerArray<CNssTag> *iTagBuffer;

   261     if ( iTagBuffer )

   262         {

   263         iTagBuffer->Reset();

   264         delete iTagBuffer;

   265         iTagBuffer = 0;

   266         }

   267 

   268     if ( iGrammarIdBuffer )

   269         {

   270         iGrammarIdBuffer->Reset();

   271         delete iGrammarIdBuffer;

   272         iGrammarIdBuffer = 0;

   273         }

   274 

   275     if ( iGrammarIdDeletingBuffer )

   276         {

   277         iGrammarIdDeletingBuffer->Reset();

   278         delete iGrammarIdDeletingBuffer;

   279         iGrammarIdDeletingBuffer = 0;

   280         }

   281     }

   282 

   283 // ---------------------------------------------------------

   284 // CNssSpeechItemTrainer::RetrainTextDelayed

   285 // Does delayed retraining.

   286 // ---------------------------------------------------------

   287 //

   288 MNssSpeechItem::TNssSpeechItemResult CNssSpeechItemTrainer::RetrainTextDelayed(

   289     MNssTrainTextEventHandler* aEventHandler,

   290 	CNssTrainingParameters*    aTrainingParams,

   291     CNssSpeechItem&            aSpeechItem,

   292     CNssContext&               aContext)

   293     {

   294     RUBY_DEBUG0( "CNssSpeechItemTrainer::RetrainTextDelayed" );

   295 

   296     // Check parameters: 

   297     // callback 

   298     CHECK_NOT_NULL( aEventHandler );

   299 

   300     // phrase to be trained

   301     CHECK_NOT_NULL( aSpeechItem.Text().Length() );

   302 

   303     // Check state

   304     ALLOWED_STATES( EStateIdle, ERetrainStateWaiting, ERetrainStateRetraining );

   305 

   306     // Check event handler

   307     if ( !iTrainEventHandler )

   308         {

   309         iTrainEventHandler = aEventHandler;

   310         }

   311     else if ( iTrainEventHandler != aEventHandler )

   312         {

   313         return( MNssSpeechItem::EVasTrainFailed );

   314         }

   315 

   316     // The training parameters and the context 

   317     // must be the same for all in the buffer.

   318     TRAPD( error,

   319         if ( !CheckTrainingParametersL( aTrainingParams ) ||

   320              !CheckContext( aContext ) )

   321             {

   322             return( MNssSpeechItem::EVasTrainFailed );

   323             }

   324          );

   325     if ( error != KErrNone )

   326         {

   327         return MNssSpeechItem::EVasTrainFailed;

   328         }

   329 

   330     // Buffer the training request

   331 

   332     // Allocate buffer, if not done earlier

   333     if ( !SpeechItemBufferNeeded() )

   334         {

   335         return( MNssSpeechItem::EVasTrainFailed );

   336         }

   337 

   338     // If this is the first tag, save Lexicon ID and Grammar ID.

   339     if ( iSpeechItemBuffer->Count() == 0 )

   340         {

   341         iLexiconId = aContext.LexiconId();

   342         iGrammarId = aContext.GrammarId();

   343         }

   344     else

   345         {

   346         // The tags after the first one must have the same Gramamr ID & Lexicon ID.

   347         if ( iLexiconId != aContext.LexiconId() ||

   348             iGrammarId != aContext.GrammarId() )

   349             {

   350             return( MNssSpeechItem::EVasTrainFailed );

   351             }

   352         }

   353 

   354     // Add request to buffer

   355     TInt ret = iSpeechItemBuffer->Append( &aSpeechItem );

   356 

   357     if ( ret != KErrNone )

   358         {

   359         return( MNssSpeechItem::EVasTrainFailed );

   360         }

   361 

   362     // Restart timer. When the timer has waited for a defined period, the names

   363     // get retrained. Timer is reseted every time RetrainTextDelayed is called.

   364     //

   365     // Retraining in groups is more efficient. The delay ensures this grouping.

   366     switch( iState )

   367         {

   368         case ERetrainStateRetraining:

   369             // Wait for the retraining to finish before acting.

   370             break;

   371 

   372         case EStateIdle:

   373             SetState( ERetrainStateWaiting );

   374             RestartTimer();

   375             break;

   376 

   377         case ERetrainStateWaiting:

   378             RestartTimer();

   379             break;

   380 

   381         default:

   382             return( MNssSpeechItem::EVasTrainFailed );

   383         }

   384 

   385     return( MNssSpeechItem::EVasErrorNone );

   386     }

   387 

   388 // ---------------------------------------------------------

   389 // CNssSpeechItemTrainer::SaveTagDelayed

   390 // Does delayed saving.

   391 // ---------------------------------------------------------

   392 //

   393 TInt CNssSpeechItemTrainer::SaveTagDelayed(

   394     MNssSaveTagClient* aSaveTagClient,

   395     CNssTag& aTag )

   396     {

   397     RUBY_DEBUG0( "CNssSpeechItemTrainer::SaveTagDelayed" );

   398 

   399     // Check internal state: Must not be training

   400     if ( this->iState != EStateIdle &&

   401          this->iState != ESaveStateWaiting &&

   402          this->iState != ESaveStateSaving )

   403         {

   404         return( KErrNotReady );

   405         }

   406 

   407     // Check arguments

   408     if ( aSaveTagClient == 0  )

   409         {

   410         return KErrArgument;

   411         }

   412 

   413     if ( !((CNssSpeechItem*)aTag.SpeechItem())->Trained() )

   414         {

   415         return KErrNotReady;

   416         }

   417 

   418     // The event handler must be the same for all group-saved tags

   419     if ( !iSaveEventHandler )

   420         {

   421         iSaveEventHandler = aSaveTagClient;

   422         }

   423     else if ( aSaveTagClient != iSaveEventHandler )

   424         {

   425         return KErrArgument;

   426         }

   427 

   428     // Buffer the saving request

   429 

   430     // Allocate buffer, if not done earlier

   431     if ( !iTagBuffer )

   432         {

   433         iTagBuffer = new RPointerArray<CNssTag>( KTagBufferGranularity );

   434 

   435         if ( !iTagBuffer )

   436             {

   437             return KErrNoMemory;

   438             }

   439         }

   440 

   441     // Add request to buffer

   442     TInt ret = iTagBuffer->Append( &aTag );

   443 

   444     if ( ret != KErrNone )

   445         {

   446         return( ret );

   447         }

   448 

   449     // Restart timer. When the timer has waited for a defined period, the names

   450     // get saved. Timer is reseted every time SaveTagDelayed is called.

   451     //

   452     // Saving in groups is more efficient. The delay ensures this grouping.

   453     switch( iState )

   454         {

   455         case ESaveStateSaving:

   456             // Wait for the training to finish before acting.

   457             break;

   458 

   459         case EStateIdle:

   460             SetState( ESaveStateWaiting );

   461             RestartTimer();

   462             break;

   463 

   464         case ESaveStateWaiting:

   465             RestartTimer();

   466             break;

   467 

   468         default:

   469             return( KErrCorrupt );

   470         }

   471 

   472     return( KErrNone );

   473     }

   474 

   475 // ---------------------------------------------------------

   476 // CNssSpeechItemTrainer::DeleteTagDelayed

   477 // Does delayed deleting.

   478 // (other items were commented in a header)

   479 // ---------------------------------------------------------

   480 //

   481 TInt CNssSpeechItemTrainer::DeleteTagDelayed(

   482     MNssDeleteTagClient* aDeleteTagClient,

   483     CNssTag& aTag )

   484     {

   485     RUBY_DEBUG0( "CNssSpeechItemTrainer::DeleteTagDelayed" );

   486 

   487     // Check internal state: Must not be doing something else

   488     ALLOWED_STATES( EStateIdle, EDeleteStateWaiting, EDeleteStateDeleting );

   489 

   490     // Check arguments

   491     CHECK_NOT_NULL( aDeleteTagClient );

   492 

   493     // The event handler must be the same for all group-deleted tags

   494     if ( !iDeleteEventHandler )

   495         {

   496         iDeleteEventHandler = aDeleteTagClient;

   497         }

   498     else if ( aDeleteTagClient != iDeleteEventHandler )

   499         {

   500         return KErrArgument;

   501         }

   502 

   503     // Buffer the deleting request

   504 

   505     // Allocate buffer, if not done earlier

   506     if ( !SpeechItemBufferNeeded() ||

   507          !GrammarIdBufferNeeded()  )

   508         {

   509         return( MNssSpeechItem::EVasTrainFailed );

   510         }

   511 

   512     // If this is the first tag, save the grammar id.

   513     if ( iSpeechItemBuffer->Count() == 0 )

   514         {

   515         iGrammarId = ((CNssContext*)aTag.Context())->GrammarId();

   516         if ( !iDeleteRuleIDArray ) 

   517         	{

   518         	iDeleteRuleIDArray = new RArray<TUint32>;

   519         	if( !iDeleteRuleIDArray ) 

   520         		{

   521         		return KErrNoMemory;

   522 	        	}

   523         	// no deletion. iDeleteRuleIDArray might still be used

   524         	}

   525 //        delete iDeleteRuleIDArray; // if any

   526 //        iDeleteRuleIDArray = new RArray<TUint32>;

   527         }

   528     else

   529         {

   530         // subsequent tags must have the same grammar id.

   531         if ( iGrammarId != ((CNssContext*)aTag.Context())->GrammarId() )

   532             {

   533             return( MNssSpeechItem::EVasTrainFailed );

   534             }

   535         }

   536 

   537     // Add request to buffer

   538     // iSpeechItemBuffer will be copied into iSpeechItemTrainingBuffer later and

   539     // iSpeechItemTrainingBuffer will be used to delete tags from the VAS DB

   540     TInt ret = iSpeechItemBuffer->Append( (CNssSpeechItem*)aTag.SpeechItem() );

   541     if ( ret != KErrNone )

   542         {

   543         return( MNssSpeechItem::EVasTrainFailed );

   544         }

   545 

   546     RUBY_DEBUG1( "CNssSpeechItemTrainer::DeleteTagDelayed Adding [%d] to iDeleteRuleIDArray", 

   547         ( ( CNssSpeechItem* )aTag.SpeechItem() )->RuleID() );

   548 

   549     ret = iDeleteRuleIDArray->Append( ( ( CNssSpeechItem* )aTag.SpeechItem() )->RuleID() );

   550 

   551     if ( ret != KErrNone )

   552         {

   553         RUBY_DEBUG1( "CNssSpeechItemTrainer::DeleteTagDelayed Adding to iDeleteRuleIDArray failed with error [%d]", ret );

   554         return( MNssSpeechItem::EVasTrainFailed );

   555         }

   556 

   557     // Restart timer. When the timer has waited for a defined period, the names

   558     // get deleted. Timer is reseted every time DeleteDagDelayed is called.

   559     //

   560     // Deleting in groups is more efficient. The delay ensures this grouping.

   561     switch( iState )

   562         {

   563         case EDeleteStateDeleting:

   564             // Wait for the training to finish before acting.

   565             break;

   566 

   567         case EStateIdle:

   568             SetState( EDeleteStateWaiting );

   569             RestartTimer();

   570             break;

   571 

   572         case EDeleteStateWaiting:

   573             RestartTimer();

   574             break;

   575 

   576         default:

   577             return( KErrCorrupt );

   578         }

   579 

   580     return( KErrNone );

   581     }

   582 

   583 // ---------------------------------------------------------

   584 // CNssSpeechItemTrainer::TrainTextDelayed

   585 // Does delayed training.

   586 // ---------------------------------------------------------

   587 //

   588 MNssSpeechItem::TNssSpeechItemResult CNssSpeechItemTrainer::TrainTextDelayed(

   589     MNssTrainTextEventHandler* aEventHandler,

   590 	CNssTrainingParameters*    aTrainingParams,

   591     CNssSpeechItem&            aSpeechItem,

   592     CNssContext&               aContext)

   593     {

   594     RUBY_DEBUG0( "CNssSpeechItemTrainer::TrainTextDelayed" );

   595 

   596     // Check parameters: 

   597     // callback

   598     CHECK_NOT_NULL( aEventHandler );

   599 

   600     // Text is not null

   601     CHECK_NOT_NULL( aSpeechItem.Text().Length() );

   602 

   603     // Check state

   604     ALLOWED_STATES( EStateIdle, ETrainStateWaiting, ETrainStateTraining );

   605 

   606     // Check event handler

   607     if ( !iTrainEventHandler )

   608         {

   609         iTrainEventHandler = aEventHandler;

   610         }

   611     else if ( iTrainEventHandler != aEventHandler )

   612         {

   613         return( MNssSpeechItem::EVasTrainFailed );

   614         }

   615 

   616     // The training parameters and the context 

   617     // must be the same for all in the buffer.

   618     TRAPD( error,

   619         if ( !CheckTrainingParametersL( aTrainingParams ) ||

   620              !CheckContext( aContext ) )

   621             {

   622             return( MNssSpeechItem::EVasTrainFailed );

   623             }

   624         );

   625     if ( error != KErrNone )

   626         {

   627         return MNssSpeechItem::EVasTrainFailed;

   628         }

   629 

   630     // Buffer the training request

   631     if ( !SpeechItemBufferNeeded() )

   632         {

   633         return( MNssSpeechItem::EVasTrainFailed );

   634         }

   635 

   636     TInt ret = iSpeechItemBuffer->Append( &aSpeechItem );

   637 

   638     if ( ret == KErrNoMemory )

   639         {

   640         return( MNssSpeechItem::EVasTrainFailed );

   641         }

   642 

   643     // Restart timer. When the timer has waited for a defined period, the names

   644     // get trained. Timer is reseted every time TrainTextDelayed is called.

   645     //

   646     // Training in groups is more efficient. The delay ensures this grouping.

   647     switch( iState )

   648         {

   649         case ETrainStateTraining:

   650             // Wait for the training to finish before acting.

   651             break;

   652 

   653         case EStateIdle:

   654             SetState( ETrainStateWaiting );

   655             RestartTimer();

   656             break;

   657 

   658         case ETrainStateWaiting:

   659             RestartTimer();

   660             break;

   661 

   662         default:

   663             return( MNssSpeechItem::EVasTrainFailed );

   664         }

   665 

   666     return( MNssSpeechItem::EVasErrorNone );

   667     }

   668 

   669 // ---------------------------------------------------------

   670 // CNssSpeechItemTrainer::HandleTrainError

   671 // Called if AddVoiceTags() call failed.

   672 // ---------------------------------------------------------

   673 //

   674 void CNssSpeechItemTrainer::HandleTrainError( RPointerArray<CNssSpeechItem>*& anItemArray )

   675     {

   676     RUBY_DEBUG0( "CNssSpeechItemTrainer::HandleTrainError" );

   677 

   678     TInt count = anItemArray->Count();

   679 

   680     CleanUpTraining();

   681 

   682     // Announce the error to the client

   683     for( TInt k=0; k<count; k++ )

   684         {

   685         iTrainEventHandler->HandleTrainComplete( KErrGeneral );

   686         

   687         }

   688     iTrainEventHandler = NULL;

   689     // All the errors reported, everything was rolled back

   690     // Back tothe idle state

   691     SetState( EStateIdle );

   692     }

   693 

   694 // ---------------------------------------------------------

   695 // CNssSpeechItemTrainer::CleanUpTrianing

   696 // Cleans memory allocated by training.

   697 // ---------------------------------------------------------

   698 //

   699 void CNssSpeechItemTrainer::CleanUpTraining(void)

   700     {

   701     // Delete buffered names

   702     if ( iSpeechItemTrainingBuffer )

   703         {

   704         iSpeechItemTrainingBuffer->Close();

   705         }

   706     delete iSpeechItemTrainingBuffer;

   707     iSpeechItemTrainingBuffer = 0;

   708 

   709     // Delete parameters common to all names

   710     delete iTrainingParams;

   711     iTrainingParams = 0;

   712 

   713     delete iContext;

   714     iContext = 0;

   715     }

   716 

   717 // ---------------------------------------------------------

   718 // CNssSpeechItemTrainer::DoTrainTextDelayed

   719 // Starts training tags. Sends the AddVoiceTags() call.

   720 // ---------------------------------------------------------

   721 //

   722 void CNssSpeechItemTrainer::DoTrainTextDelayed()

   723     {

   724     SetState( ETrainStateTraining );

   725 

   726     // Move from speech item buffers from filling state to processing state.

   727 

   728     // names to be trained + names to be retrained

   729     iSpeechItemTrainingBuffer = iSpeechItemBuffer;

   730     iSpeechItemBuffer = 0;

   731 

   732     // Initialize iSrsApi (speech recognition utility)

   733     TInt error = CreateSrsApi();

   734     if ( error != KErrNone )

   735         {

   736         RUBY_DEBUG1( "CNssSpeechItemTrainer::DoTrainTextDelayed Creating SrsApi failed. Error [%d]", error );

   737         HandleTrainError( iSpeechItemTrainingBuffer );

   738         }

   739     else 

   740        	{

   741         	

   742 	    __ASSERT_DEBUG( iContext->LexiconId() != KInvalidLexiconID, 

   743 	                    User::Panic( KSpeechItemTrainerPanic, KErrCorrupt ) );

   744 	    __ASSERT_DEBUG( iContext->GrammarId() != KInvalidGrammarID, 

   745 	                    User::Panic( KSpeechItemTrainerPanic, KErrCorrupt ) );

   746 

   747 	    // Extract texts from speech items to phrase array.

   748 

   749 	    // iPhraseArray is an array of arrays: 

   750 	    // 

   751 	    //        |-- firstname1

   752 	    //  tag1 -|-- lastname1

   753 	    //

   754 	    //  tag2 -|-- firstname2

   755 	    //        |-- lastname2

   756 	    iPhraseArray.ResetAndDestroy();

   757 

   758 	    // Convert speech item array to the format understood by the Utility.

   759 	    TInt ret = SpeechItems2Phrases( *iSpeechItemTrainingBuffer, iPhraseArray );

   760 	    if ( ret != KErrNone )

   761 	        {

   762 	        SendTrainingCallbacks( ret );

   763 	        /** @todo reengineer into signle return path

   764 	            @todo check that everything is cleaned up before the return */

   765 	        return;

   766 	        }

   767 

   768 	    // Initialize Rule ID array. The Utility puts the IDs

   769 	    // of newly created rules here.

   770 	    // Not using (ELeave) since this is non-leaving function (trapping of (ELeave) is not allowed).

   771 	    iRuleIDArray = new RArray<TUint32>;

   772 

   773 	    if ( iRuleIDArray == 0 )

   774 	        {

   775             RUBY_DEBUG0( "CNssSpeechItemTrainer::DoTrainTextDelayed iRuleIDArray == 0" );

   776 

   777 	        HandleTrainError( iSpeechItemTrainingBuffer );

   778 	        }

   779 	    else

   780 	       	{

   781             RUBY_DEBUG1( "CNssSpeechItemTrainer::Calling AddVoiceTags (%d names)", 

   782                          iPhraseArray.Count() ); 

   783 	       	// allocation succeeded

   784 

   785             TRAPD( errSinde, const RArray<RTrainingLanguageArray>& languages = 

   786                                         iTrainingParams->SindeLanguagesL() );

   787             

   788             if ( errSinde == KErrNone )

   789                 {

   790 #ifdef __SINDE_TRAINING

   791                 TRAP_IGNORE(

   792                     const RArray<RTrainingLanguageArray>& languages = 

   793                                         iTrainingParams->SindeLanguagesL();

   794     		        ret = iSrsApi->AddVoiceTags( iPhraseArray,

   795                                                  languages,

   796                                                  (TSILexiconID)iContext->LexiconId(),

   797                                                  (TSIGrammarID)iContext->GrammarId(),

   798                                                  *iRuleIDArray );

   799                 ); // TRAP_IGNORE

   800 #endif // __SINDE_TRAINING

   801                 }

   802             else

   803                 {

   804                 // Use the old style of training if SINDE languages are not available

   805 		        ret = iSrsApi->AddVoiceTags( iPhraseArray,

   806                                              iTrainingParams->Languages(),

   807                                              (TSILexiconID)iContext->LexiconId(),

   808                                              (TSIGrammarID)iContext->GrammarId(),

   809                                              *iRuleIDArray );

   810                 }

   811 

   812 		    // error -> cleanup

   813 		    if ( ret != KErrNone )

   814 		        {

   815                 RUBY_DEBUG1( "CNssSpeechItemTrainer::AddVoiceTags failed(%d)", ret );

   816 

   817 		        HandleTrainComplete( ret );

   818 		        }  // if ret is not KErrNone

   819 	       	}  // if iRuleIDArray allocation succeeded

   820        	}  // if SRS API was created successfully

   821     }

   822 

   823 // ---------------------------------------------------------

   824 // CNssSpeechItemTrainer::DoRetrainTextDelayed

   825 // Starts the 1st phase of retraining,

   826 // which is removing old rules.

   827 // ---------------------------------------------------------

   828 //

   829 void CNssSpeechItemTrainer::DoRetrainTextDelayed()

   830     {

   831     __ASSERT_DEBUG( iSpeechItemBuffer != 0, DEBUGPANIC );

   832 

   833     SetState( ERetrainStateRetraining );

   834 

   835     // Move speech item buffer from filling state to processing state.

   836     iSpeechItemTrainingBuffer = iSpeechItemBuffer;

   837     iSpeechItemBuffer = 0;

   838 

   839     // Initialize iSrsApi (speech recognition utility)

   840     TInt error = CreateSrsApi();

   841     if ( error != KErrNone )

   842         {

   843         RUBY_DEBUG1( "CNssSpeechItemTrainer::DoRetrainTextDelayed Creating SrsApi failed. Error [%d]", error );

   844         HandleTrainError( iSpeechItemTrainingBuffer );

   845         return;

   846         }

   847 

   848     // Start deleting tags

   849     iTagDeleteCounter = 0;

   850     DeleteNextTag();

   851     }

   852 

   853 // ---------------------------------------------------------

   854 // CNssSpeechItemTrainer::DoRetrainAddVoiceTags

   855 // Phase 2 of retraining: Add voice tags

   856 // ---------------------------------------------------------

   857 //

   858 void CNssSpeechItemTrainer::DoRetrainAddVoiceTags()

   859     {

   860     SetState( ERetrainStateRetraining );

   861 

   862     // Move from speech item buffers from filling state to processing state.

   863 

   864     __ASSERT_DEBUG( iContext->LexiconId() != KInvalidLexiconID, 

   865                     User::Panic( KSpeechItemTrainerPanic, KErrCorrupt ) );

   866     __ASSERT_DEBUG( iContext->GrammarId() != KInvalidGrammarID, 

   867                     User::Panic( KSpeechItemTrainerPanic, KErrCorrupt ) );

   868 

   869     // Extract texts from speech items to phrase array.

   870 

   871     iPhraseArray.ResetAndDestroy();

   872 

   873     // Convert speech item array to the format understood by the Utility.

   874     TInt ret = SpeechItems2Phrases( *iSpeechItemTrainingBuffer, iPhraseArray );

   875     if ( ret != KErrNone )

   876         {

   877         SendTrainingCallbacks( ret );

   878         return;

   879         }

   880 

   881     // Allocate Rule ID array. The Utility fills this array.

   882     // When the utility trans a name, it attaches a Rule ID to the name.

   883     iRuleIDArray = new RArray<TUint32>;

   884     if ( iRuleIDArray == 0 )

   885         {

   886         SendTrainingCallbacks( KErrNoMemory );

   887         return;

   888         }

   889 

   890     RUBY_DEBUG1( "CNssSpeechItemTrainer::Retrain Calling AddVoiceTags (%d names)", 

   891                  iPhraseArray.Count() );

   892 

   893     TRAPD( errSinde, const RArray<RTrainingLanguageArray>& languages = 

   894                                         iTrainingParams->SindeLanguagesL() );

   895             

   896     if ( errSinde == KErrNone )

   897         {

   898 #ifdef __SINDE_TRAINING        	

   899         TRAP_IGNORE(

   900             const RArray<RTrainingLanguageArray>& languages = 

   901                                 iTrainingParams->SindeLanguagesL();

   902 	        ret = iSrsApi->AddVoiceTags( iPhraseArray,

   903                                          languages,

   904                                          (TSILexiconID)iContext->LexiconId(),

   905                                          (TSIGrammarID)iContext->GrammarId(),

   906                                          *iRuleIDArray );

   907         ); // TRAP_IGNORE

   908 #endif // __SINDE_TRAINING

   909         }

   910     else

   911         {

   912         // Use the old style of training if SINDE languages are not available

   913         ret = iSrsApi->AddVoiceTags( iPhraseArray,

   914                                      iTrainingParams->Languages(),

   915                                      (TSILexiconID)iLexiconId,

   916                                      (TSIGrammarID)iGrammarId,

   917                                      *iRuleIDArray );

   918         }

   919 

   920     // error -> cleanup

   921     if ( ret != KErrNone )

   922         {

   923         RUBY_DEBUG1( "CNssSpeechItemTrainer::Retrain ERROR: AddVoiceTags(%d)", ret );

   924 

   925         SendTrainingCallbacks( ret );

   926         }

   927 

   928     }

   929 

   930 // ---------------------------------------------------------

   931 // CNssSpeechItemTrainer::DoRetrainAddVoiceTags

   932 // After the new tags have been trained:

   933 // Announce the new rule IDs for speech items,

   934 // and update the rule IDs to the VAS database.

   935 // ---------------------------------------------------------

   936 //

   937 void CNssSpeechItemTrainer::HandleRetrainComplete( TInt aResult )

   938     {

   939     RUBY_DEBUG1( "CNssSpeechItemTrainer::HandleTrainComplete(%d)", aResult );

   940 

   941     // iRuleIdArray contains the rule IDs of the newly trained tags.

   942     // The following call makes sure that

   943     // iRuleIdArray.Count() == iSpeechItemTrainingBuffer.Count().

   944     if ( EnforceRuleIdCountInvariant( *iRuleIDArray, 

   945                         iSpeechItemTrainingBuffer->Count() ) != KErrNone )

   946         {

   947         SendTrainingCallbacks( KErrNoMemory );

   948         }

   949     else

   950         {

   951         TInt count = iSpeechItemTrainingBuffer->Count();

   952         RArray<TNssSpeechItem> ruleIdUpdateArray( KRuleIdBufferGranularity );

   953 

   954         for( TInt itemIdx = 0; itemIdx < count; itemIdx++ )

   955             {

   956             CNssSpeechItem* item = (*iSpeechItemTrainingBuffer)[itemIdx];

   957             TUint32    ruleID = (*iRuleIDArray)[itemIdx];

   958             if ( ruleID != KInvalidRuleID )

   959                 {

   960                 // tag was trained successfully

   961 

   962                 item->DelayedTrainingComplete( ruleID );

   963                 

   964                 TNssSpeechItem flatItem;

   965 

   966                 flatItem.iRuleId = item->RuleID();

   967                 flatItem.iTagId  = item->TagId();

   968 

   969                 TInt ret = ruleIdUpdateArray.Append( flatItem );

   970 

   971                 if ( ret != KErrNone )

   972                     {

   973                     ruleIdUpdateArray.Close();

   974                     SendTrainingCallbacks( KErrNoMemory );

   975                     return;

   976                     }

   977                 }

   978             else

   979                 {

   980                 // training failed -> remove tag

   981                 iDatabase->DeleteTag( item->TagId() );

   982                 }   

   983             }

   984 

   985         aResult = iDatabase->UpdateTagRuleIDs( ruleIdUpdateArray );

   986         ruleIdUpdateArray.Close();

   987         SendTrainingCallbacks( aResult );

   988         }

   989 

   990     

   991     }

   992 

   993 // ---------------------------------------------------------

   994 // CNssSpeechItemTrainer::DoSaveTags

   995 // Saves tags.

   996 // ---------------------------------------------------------

   997 //

   998 void CNssSpeechItemTrainer::DoSaveTags()

   999     {

  1000 

  1001     __ASSERT_DEBUG( iState == ESaveStateWaiting, DEBUGPANIC );

  1002 

  1003     // Save the tags en masse

  1004     TInt ret = iDatabase->SaveTags( iTagBuffer );

  1005 

  1006     // Next, we're going to make callbacks to the client.

  1007     // Before that, we have to return the object to idle state,

  1008     // This way, the last callback can trigger new train/save action.

  1009 

  1010     // Destroy buffered tags

  1011     TInt count = iTagBuffer->Count();

  1012     iTagBuffer->Close();

  1013     delete iTagBuffer;

  1014     iTagBuffer = 0;

  1015 

  1016     // Detach save tag client

  1017     MNssSaveTagClient* client = iSaveEventHandler;

  1018     iSaveEventHandler = 0;

  1019 

  1020     // Make SpeechItemTrainer ready for new challenges

  1021     SetState( EStateIdle );

  1022 

  1023     // Make callbacks

  1024     for ( TInt k = 0; k < count; k++ )

  1025         {

  1026         if ( ret == KErrNone )

  1027             {

  1028 #ifdef _DEBUG

  1029             TRAPD( err, client->SaveTagCompleted( KErrNone ) );

  1030             __ASSERT_DEBUG( err == KErrNone, DEBUGPANIC );

  1031 #else

  1032             client->SaveTagCompleted( KErrNone );

  1033 #endif // _DEBUG

  1034             }

  1035         else

  1036             {

  1037 #ifdef _DEBUG

  1038             TRAPD( err, client->SaveTagCompleted( KErrGeneral ) );

  1039             __ASSERT_DEBUG( err == KErrNone, DEBUGPANIC );

  1040 #else

  1041             client->SaveTagCompleted( KErrGeneral );

  1042 #endif // _DEBUG

  1043             }

  1044         }

  1045     }

  1046 

  1047 // ---------------------------------------------------------

  1048 // CNssSpeechItemTrainer::DoDeleteTags

  1049 // Starts tag removal.

  1050 // ---------------------------------------------------------

  1051 //

  1052 void CNssSpeechItemTrainer::DoDeleteTags()

  1053     {

  1054     // NOTE: This method is never called from anywhere!

  1055     

  1056     SetState( EDeleteStateDeleting );

  1057 

  1058     TInt err = CreateSrsApi();

  1059     if ( err != KErrNone )

  1060         {

  1061         RemoveTagsFinished( err );

  1062         return;

  1063         }

  1064 

  1065     // Move Tag Buffer from filling state to processing state.

  1066     iSpeechItemTrainingBuffer = iSpeechItemBuffer;

  1067     iSpeechItemBuffer = 0;

  1068     iSpeechItemBuffer = new RPointerArray<CNssSpeechItem>; // New filling buffer

  1069     if( !iSpeechItemBuffer )

  1070         {

  1071         SendTrainingCallbacks( KErrNoMemory );

  1072         return;

  1073         }

  1074 

  1075     iTagDeleteCounter = 0;

  1076     DeleteNextTag();

  1077     }

  1078 

  1079 // ---------------------------------------------------------

  1080 // CNssSpeechItemTrainer::DoDeleteGroupedTags

  1081 // Starts grouped tag removal.

  1082 // Used when deleting tags without retraining.

  1083 // ---------------------------------------------------------

  1084 //

  1085 void CNssSpeechItemTrainer::DoDeleteGroupedTags()

  1086     {

  1087   	RUBY_DEBUG1("CNssSpeechItemTrainer::DoDeleteGroupedTags iDeleteRuleIDArray->Count() = [%d]", iDeleteRuleIDArray->Count() );

  1088 	SetState( EDeleteStateDeleting );

  1089 

  1090     // Move Tag Buffer from filling state to processing state.

  1091     // We want to have this buffer != NULL so that we are able to do callbacks (with appropriate error code )

  1092     // in RemoveTagsFinished method even if e.g. CreateSrsApi fails. 

  1093     iSpeechItemTrainingBuffer = iSpeechItemBuffer;

  1094     iSpeechItemBuffer = 0;

  1095 

  1096     TInt err = CreateSrsApi();

  1097     if ( err != KErrNone )

  1098         {

  1099         RemoveTagsFinished( err );

  1100         return;

  1101         }

  1102 

  1103     iSpeechItemBuffer = new RPointerArray<CNssSpeechItem>; // New filling buffer

  1104     

  1105     if( !iSpeechItemBuffer )

  1106         {

  1107         // As this method is not used when retraining, no need 

  1108         // to send other callbacks than those related to deleting tags.

  1109         RemoveTagsFinished( KErrNoMemory );

  1110         return;

  1111         }

  1112 

  1113 	TInt ret = iSrsApi->RemoveRules( ( TSIGrammarID )iGrammarId,

  1114                                      *iDeleteRuleIDArray );

  1115 

  1116     if ( ret != KErrNone && ret != KErrNotFound )

  1117         {

  1118         RUBY_DEBUG1( "CNssSpeechItemTrainer::DoDeleteGroupedTags RemoveRules failed. \

  1119                       Error [%d]", ret );

  1120         RemoveTagsFinished( ret );

  1121         return;

  1122         }

  1123 

  1124     }

  1125 

  1126 // ---------------------------------------------------------

  1127 // CNssSpeechItemTrainer::DeleteNextTag

  1128 // Sends a RemoveRule() call for the next rule in the removal queue.

  1129 // ---------------------------------------------------------

  1130 //

  1131 void CNssSpeechItemTrainer::DeleteNextTag()

  1132     {

  1133     RUBY_DEBUG2( "CNssSpeechItemTrainer::DeleteNextTag iTagDeleteCounter [%d], iSpeechItemTrainingBuffer->Count() [%d]", iTagDeleteCounter, iSpeechItemTrainingBuffer->Count() );

  1134