1 /*

     2 * Copyright (c) 2003-2007 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 CNssRecognitionHandler class performs the recognition function.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <e32base.h>

    21 #include <e32property.h>

    22 #include "nssvascoreconstant.h"

    23 

    24 #include "nssvascrecognitionhandler.h"

    25 #include "nssvasctagmgr.h"

    26 #include "nssvascadaptationitem.h"

    27 #include <nsssispeechrecognitionutilityobserver.h>

    28 

    29 #ifndef __WINS__

    30 	// for hardware

    31     #include <AudioPreference.h>

    32 #else

    33   // use default values for WINS

    34   const TUint KAudioPriorityVoiceDial = 73;

    35 

    36   const TUint KAudioPrefVocosPlayback = 0x00030001;

    37   const TUint KAudioPrefVocosTrain = 0x00020001;

    38   const TUint KAudioPrefVocosRecog = 0x00010001;

    39 #endif

    40 #include "nssvascdbtagselectnotifier.h"

    41 #include "nssvascoreconstant.h"

    42 #include "nssvasmrecognizeinitcompletehandler.h"

    43 #include "nssvascvasdbbuilder.h"

    44 #include "rubydebug.h"

    45 

    46 // maximal number of results that can be handled

    47 const TInt KMaxResults = 100;

    48 

    49 #ifdef _DEBUG

    50 // Used under UDEB only

    51 _LIT( KRecognitionHandlerPanic, "VasCNssRecognitionHandler.cpp" );

    52 #endif  // _DEBUG

    53 

    54 

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

    56 

    57 // -----------------------------------------------------------------------------

    58 // CNssRecognitionHandler::NewL

    59 // Two-phased constructor.

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

    61 //

    62 CNssRecognitionHandler* CNssRecognitionHandler::NewL()

    63     {

    64     RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::NewL" );

    65 

    66     // version of NewLC which leaves nothing on the cleanup stack

    67     CNssRecognitionHandler* self=NewLC();

    68     CleanupStack::Pop( self );

    69     return self;

    70     }

    71 

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

    73 // CNssRecognitionHandler::NewLC

    74 // Two-phased constructor.

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

    76 //

    77 CNssRecognitionHandler* CNssRecognitionHandler::NewLC()

    78     {

    79     CNssRecognitionHandler* self = new (ELeave)  CNssRecognitionHandler();

    80     CleanupStack::PushL(self);

    81     // push onto cleanup stack 

    82     // (in case self->ConstructL leaves)

    83     self->ConstructL();      // use two-stage construct

    84     return self;

    85     }

    86 

    87 // -----------------------------------------------------------------------------

    88 // CNssRecognitionHandler::~CNssRecognitionHandler

    89 // Destructor

    90 // -----------------------------------------------------------------------------

    91 //

    92 CNssRecognitionHandler::~CNssRecognitionHandler()

    93     {

    94     RUBY_DEBUG0( "CNssRecognitionHandler::~CNssRecognitionHandler" );

    95     

    96     Cleanup();

    97     

    98     for ( TInt k( 0 ); k < iAdaptItemArray.Count(); k++ )

    99         {

   100         iAdaptItemArray[k]->Disable();

   101         }

   102     iAdaptItemArray.Close();

   103     

   104     CNssVASDBBuilder::RemoveInstance();  // remove iVasDBBuilder instance

   105     

   106     TInt state( ERecognitionFail );

   107     RProperty::Get( KSINDUID, ERecognitionState, state );

   108     

   109     if ( state == ERecognitionStarted || state == ERecognitionSpeechEnd )

   110         {

   111         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail );

   112         }

   113     // Delete P&S property

   114     RProperty::Delete( KSINDUID, ERecognitionState ); 

   115     }

   116 

   117 // -----------------------------------------------------------------------------

   118 // CNssRecognitionHandler::RecognizeInitL

   119 // Method to perform initialization for the recognize funtion.

   120 // -----------------------------------------------------------------------------

   121 //

   122 MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::RecognizeInitL(

   123     MNssRecognizeInitCompleteHandler* aInitCompleteHandler,

   124     const CArrayPtrFlat<MNssContext>& aRecognitionVocabulary,

   125 	TInt aMaxResults)

   126     {

   127     RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::RecognizeInitL" );

   128 

   129     MNssRecognitionHandler::TNssRecognitionResult res = EVasErrorNone;

   130 

   131     // Vocabulary independent initialization:

   132     // CSISpeechRecognitionUtility and CSIClientResultSet.

   133     res = CommonRecognizeInitL( aInitCompleteHandler, aMaxResults );

   134 

   135     if ( res != EVasErrorNone )

   136         {

   137         return( res );

   138         }

   139 

   140     // Agenda for vocab dependent init:

   141     // 1. Get the list of global contexts from VAS DB.

   142     //    The information we need is:

   143     //     * Model Bank ID, which is the same for all contexts

   144     //     * Grammar ID for each context

   145     // 2. Load a model bank from SRS DB.

   146     // 3. Load the grammars from SRS DB. Each context has one grammar.

   147 	if ( !iContextList )

   148 	    {

   149 		iContextList = new (ELeave) TMNssContextList(1);

   150         }

   151     else

   152         {

   153         iContextList->Reset();

   154         }

   155 

   156 

   157     for ( TInt k( 0 ); k < aRecognitionVocabulary.Count(); k++ )

   158         {

   159         CNssContext* context = ((CNssContext*)aRecognitionVocabulary[k])->CopyL();

   160         CleanupStack::PushL( context );

   161 

   162         iContextList->AppendL( context );

   163 

   164         CleanupStack::Pop( context );

   165         }

   166     iContextCount = iContextList->Count();

   167 

   168     // Check if there are tags in the contexts.

   169     // If there are, load a model bank. After that, further initializations

   170     // follow: Loading lexicons and grammars.

   171 	// Check for Tags in contexts and continue recognition

   172 	TRAPD( err, HandleTagCheckL() );

   173 

   174 	if ( err != KErrNone )

   175 	    {

   176         RUBY_DEBUG0( "CNssRecognitionHandler: TRAPD HandleTagCheckL() failed" );

   177 		// Notify P&S

   178         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   179 		Cleanup();

   180         return EVasRecognitionInitFailed;

   181 	    }

   182 

   183     return( EVasErrorNone );

   184     }

   185 

   186 // -----------------------------------------------------------------------------

   187 // CNssRecognitionHandler::RecognizeInitL

   188 // Method to perform initialization for the recognize funtion.

   189 // -----------------------------------------------------------------------------

   190 //

   191 MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::RecognizeInitL(

   192 		                   MNssRecognizeInitCompleteHandler* aInitCompleteHandler,

   193 						   TInt aMaxResults)

   194     {

   195     RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::RecognizeInitL" );

   196 

   197     MNssRecognitionHandler::TNssRecognitionResult res = EVasErrorNone;

   198 

   199     // Vocabulary independent initialization:

   200     // CSISpeechRecognitionUtility and CSIClientResultSet.

   201     res = CommonRecognizeInitL( aInitCompleteHandler, aMaxResults );

   202 

   203     if ( res != EVasErrorNone )

   204         {

   205         return( res );

   206         }

   207 

   208     // Agenda for vocab dependent init:

   209     // 1. Get the list of global contexts from VAS DB.

   210     //    The information we need is:

   211     //     * Model Bank ID, which is the same for all contexts

   212     //     * Grammar ID for each context

   213     // 2. Load a model bank from SRS DB.

   214     // 3. Load the grammars from SRS DB. Each context has one grammar.

   215 

   216     if ( iContextList )

   217         {

   218         iContextList->Reset();

   219         delete iContextList;

   220         }

   221 

   222 	// Get Global Context List from Vas Db

   223     iContextList = iContextMgr->GetGlobalContexts();

   224     

   225     if ( !iContextList )

   226         {

   227         return EVasRecognitionInitFailed;

   228         }

   229 

   230     iContextCount = iContextList->Count();

   231 

   232 

   233 	// Check for Tags in contexts and continue recognition

   234 	TRAPD( err, HandleTagCheckL() );

   235 

   236 	if ( err != KErrNone )

   237 	    {

   238         RUBY_DEBUG0( "CNssRecognitionHandler: TRAPD HandleTagCheckL() failed" );

   239 

   240 		// Notify P&S

   241         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   242 		Cleanup();

   243         return EVasRecognitionInitFailed;

   244 	    }

   245 

   246 	return EVasErrorNone;

   247     }

   248 

   249 // -----------------------------------------------------------------------------

   250 // CNssRecognitionHandler::Recognize

   251 // Method to perform the recognize function.

   252 // -----------------------------------------------------------------------------

   253 //

   254 MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::Recognize(

   255                                         MNssRecognizeEventHandler* aEventHandler )

   256     {

   257     RUBY_DEBUG0( "CNssRecognitionHandler::Recognize" );

   258     

   259     if ( iRState != EVasWaitingForRecognize )

   260         {

   261         RUBY_DEBUG0( "CNssRecognitionHandler::Recognize - Unexpected Request" );

   262         // Notify P&S

   263         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   264         Cleanup();

   265         return EVasUnexpectedRequest;

   266         }

   267     

   268     iEventHandler = aEventHandler;

   269 	   

   270     iRState = EVasWaitingForRecordStarted;

   271     

   272     RUBY_DEBUG0( "CNssRecognitionHandler: SRSF Record()" );

   273     

   274     // Asynchronous call: next expected event: ERecordStarted

   275     

   276     TInt errorCode = iSrsApi->Record( KNssVASRecordTime );

   277     

   278     if ( errorCode != KErrNone )

   279         {

   280         RUBY_DEBUG1( "CNssRecognitionHandler: Record Err = %d", errorCode );

   281 

   282         // Notify P&S

   283         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   284         Cleanup();

   285         return EVasRecognitionFailed;

   286         }

   287     

   288     return EVasErrorNone;

   289     }

   290 

   291 // -----------------------------------------------------------------------------

   292 // CNssRecognitionHandler::PreStartSampling

   293 // Method to start pre-sampling before the actual recognition start.

   294 // -----------------------------------------------------------------------------

   295 //

   296 MNssRecognitionHandler::TNssRecognitionResult 

   297 CNssRecognitionHandler::PreStartSampling( MNssRecognizeInitCompleteHandler* aInitCompleteHandler )

   298     {

   299     RUBY_DEBUG0( "" ); 

   300     

   301     // State check

   302     if ( iRState != EVasIdle )

   303         {

   304         RUBY_DEBUG0( "Unexpected Request" );

   305         return EVasUnexpectedRequest;

   306         }

   307     

   308     // Check callback

   309     if ( !aInitCompleteHandler )

   310         {

   311         return EVasInvalidParameter;

   312         }    

   313     

   314     iInitCompleteHandler = aInitCompleteHandler;

   315     

   316     if ( !iSrsApi )

   317         {		

   318         TRAPD( err, CreateSrfL() );

   319         if ( err != KErrNone )

   320             {

   321             RUBY_DEBUG0( "SRS creation fails" );

   322             iSrsApi = NULL;

   323             Cleanup();

   324             return EVasRecognitionInitFailed;

   325             }    

   326         }

   327       

   328     iSrsApi->SetAudioPriority( KAudioPriorityVoiceDial, 

   329                                KAudioPrefVocosTrain, 

   330                                KAudioPrefVocosPlayback, 

   331                                KAudioPrefVocosRecog );               

   332     

   333     TInt errorCode = iSrsApi->PreStartSampling();

   334     

   335     if ( errorCode != KErrNone )

   336         {

   337         RUBY_DEBUG1( "PreStartSampling Err = %d", errorCode );

   338         Cleanup();

   339         return EVasRecognitionInitFailed;

   340         }    

   341     

   342     return EVasErrorNone;

   343     }

   344 

   345 // -----------------------------------------------------------------------------

   346 // CNssRecognitionHandler::SelectTagL

   347 // Method to initiate the Select Tag event.

   348 // -----------------------------------------------------------------------------

   349 //

   350 MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::SelectTagL(

   351 															   MNssTag *aClientTag)

   352     {

   353     return SelectTagL( aClientTag, ETrue );

   354     }

   355 

   356 // -----------------------------------------------------------------------------

   357 // CNssRecognitionHandler::SelectTagL

   358 // Method to initiate the Select Tag event.

   359 // -----------------------------------------------------------------------------

   360 //

   361 MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::SelectTagL( 

   362                                                             MNssTag* aClientTag, 

   363                                                             TBool aNotifyHandlers )

   364     {

   365     RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::SelectTagL" );

   366     

   367     if ( iRState != EVasWaitingForSelectTag )

   368         {

   369         RUBY_DEBUG0( "CNssRecognitionHandler::SelectTagL - Unexpected Request" );

   370 

   371         // Notify P&S

   372         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   373         

   374         Cleanup();

   375         return EVasUnexpectedRequest;

   376         }

   377     

   378     if ( !aClientTag )

   379         {

   380         RUBY_DEBUG0( "CNssRecognitionHandler: Invalid Parameter" );

   381 

   382         // Notify P&S

   383         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   384         

   385         Cleanup();

   386         return EVasInvalidParameter;

   387         }

   388     

   389     // Check if we want to notify GlobalContext handlers

   390     if ( !aNotifyHandlers )

   391         {

   392         // No; just cleanup

   393         Cleanup();

   394         }

   395     else

   396         { // Yes

   397         // make a copy of the client tag, aClientTag, so the client can delete it

   398         CNssTag* internalTag = ((CNssTag*)aClientTag)->CopyL();

   399         

   400         Cleanup();

   401         

   402         CNssDBTagSelectNotifier *selectNotifier = iVasDBBuilder->GetTagSelectNotifier();

   403         

   404         selectNotifier->HandleSelection(internalTag);

   405         

   406         delete internalTag;

   407         }

   408     

   409     return EVasErrorNone;

   410     }

   411 

   412 // -----------------------------------------------------------------------------

   413 // CNssRecognitionHandler::RejectTagL

   414 // Method to perform Reject Tag, i.e. blacklisting.

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

   416 //

   417 MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::RejectTagL(

   418 						   MNssRejectTagCompleteHandler* aRejectTagCompleteHandler,

   419 		                   CArrayPtrFlat<MNssTag>* aClientTagList)

   420     {

   421     RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::RejectTagL" );

   422     

   423     if ( iRState != EVasWaitingForSelectTag )

   424         {

   425         RUBY_DEBUG0( "CNssRecognitionHandler::RejectTagL - Unexpected Request" );

   426 

   427         // Notify P&S

   428         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 	

   429         Cleanup();

   430         return EVasUnexpectedRequest;

   431         }

   432     

   433     // Begin a Loop to unload rules. A rule is contained in a tag.

   434     // The unload rule requests are Asynchronous. The 

   435     // loop is continued and completed in the event handler logic, 

   436     // MsruoEvent(aEvent=UnloadRuleComplete).

   437     // Loop through the input client tag list to build a Rule List, one rule 	

   438     // for each tag. Unload the rule corresponding to each tag.

   439     // iRejectTagCurrentLoopCount and iRejectTagCount control the loop.

   440     

   441     iRejectTagCompleteHandler = aRejectTagCompleteHandler;

   442     

   443     if (aClientTagList == 0)

   444         {

   445         // client tag list is NULL error

   446         RUBY_DEBUG0( "CNssRecognitionHandler: Invalid Parm: Tag List Null" );

   447 

   448         // Notify P&S

   449         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   450         Cleanup();

   451         return EVasInvalidParameter;

   452         }

   453     iRejectTagCount = aClientTagList->Count(); 

   454     

   455     if (iRejectTagCount == 0)

   456         {

   457         // tag list is empty error

   458         RUBY_DEBUG0( "NssRecognitionHandler: Invalid Parm: Tag List Empty" );

   459 

   460         // Notify P&S

   461         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   462         Cleanup();

   463         return EVasInvalidParameter;

   464         }

   465     

   466     iRejectTagCurrentLoopCount = 0; 

   467     

   468     if (!iRuleList)

   469         {

   470         iRuleList = new (ELeave) CArrayFixFlat<TRuleEntry>(iRejectTagCount);

   471         }

   472     

   473     TRuleEntry ruleEntry;

   474     

   475     for ( TInt index=0; index < iRejectTagCount; index++ )

   476         {

   477         CNssTag* tempTag = (CNssTag*)aClientTagList->At(index);

   478         CNssSpeechItem* speechItem = (CNssSpeechItem*)tempTag->SpeechItem();

   479         TUint32 ruleID = speechItem->RuleID();

   480         

   481         CNssContext* context = (CNssContext*)tempTag->Context();

   482         TUint32 grammarID = context->GrammarId();

   483         

   484         ruleEntry.ruleId = ruleID; 

   485         ruleEntry.grammarId = grammarID;

   486         

   487         iRuleList->AppendL(ruleEntry);

   488         }

   489     

   490     // get the first iRuleList entry = 0. The rest of the entries are

   491     // processed in the event handler, MsruoEvent(aEvent=UnloadRuleComplete)

   492     ruleEntry = iRuleList->At(iRejectTagCurrentLoopCount);

   493     TUint32 ruleID = ruleEntry.ruleId;

   494     TUint32 grammarID = ruleEntry.grammarId;

   495     

   496     iRState = EVasWaitingForUnloadRuleComplete;

   497     

   498     RUBY_DEBUG0( "CNssRecognitionHandler: SRSF UnloadRule()" );

   499     

   500     TInt errorCode = iSrsApi->UnloadRule( (TSIGrammarID)grammarID, ruleID );

   501     if ( errorCode )

   502         {

   503         RUBY_DEBUG1( "CNssRecognitionHandler: UnloadRule Err = %d", errorCode );

   504 

   505         // Notify P&S

   506         RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   507         Cleanup();

   508         return EVasRejectTagFailed;

   509         }

   510     

   511     return EVasErrorNone;

   512     }

   513 

   514 // -----------------------------------------------------------------------------

   515 // CNssRecognitionHandler::Cancel

   516 // Method to cancel the last recognition function.

   517 // -----------------------------------------------------------------------------

   518 //

   519 MNssRecognitionHandler::TNssRecognitionResult CNssRecognitionHandler::Cancel()

   520     {

   521     RUBY_DEBUG1( "CNssRecognitionHandler::Cancel() iRState = %d", iRState );

   522 

   523 	// a Cancel request for the Idle state requires no action.	

   524     if ( iRState == EVasIdle )

   525         {

   526 		return EVasErrorNone;    

   527         }

   528  

   529     // Notify P&S

   530     RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   531 

   532 	// for all states except Idle call Cleanup which calls SRF cancel and 

   533 	// transitions to Idle state.

   534     Cleanup();

   535     return EVasErrorNone;

   536     }

   537 

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

   539 // CNssRecognitionHandler::GetAdaptationItemL

   540 // Method to get the adaptation data.

   541 // -----------------------------------------------------------------------------

   542 //

   543 MNssAdaptationItem* CNssRecognitionHandler::GetAdaptationItemL(void)

   544     {

   545     RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::GetAdaptationItemL" );

   546 	

   547     // Check state

   548 	if ( iRState != EVasWaitingForSelectTag )

   549     	{

   550         User::Leave( KErrNotReady );

   551     	}

   552 

   553     // Client Result Set should be there since the state is what it is.

   554     if ( !iSIClientResultSet )

   555         {

   556         User::Leave( KErrCorrupt );

   557         }

   558 

   559     // Construct adaptation item

   560     CNssAdaptationItem* adaptationItem = CNssAdaptationItem::NewL( this, iSIClientResultSet );

   561     // Adaptation item now owns the previous Client Result Set.

   562     iSIClientResultSet = 0; 

   563 

   564     // Add the item to our catalog of adaptation items.

   565     CleanupStack::PushL( adaptationItem );

   566     User::LeaveIfError( iAdaptItemArray.Append( adaptationItem ) );

   567     CleanupStack::Pop( adaptationItem );

   568 

   569     return( adaptationItem );

   570     }

   571 

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

   573 // CNssRecognitionHandler::GetAdaptationItemL

   574 // Method to get the adaptation data.

   575 // -----------------------------------------------------------------------------

   576 //

   577 void CNssRecognitionHandler::RemoveAdaptationItem(CNssAdaptationItem* anItem)

   578     {

   579     for ( TInt k( 0 ); k < iAdaptItemArray.Count(); k++ )

   580         {

   581         if ( iAdaptItemArray[k] == anItem )

   582             {

   583             iAdaptItemArray.Remove( k );

   584             break;

   585             }

   586         }

   587     }

   588 

   589 // -----------------------------------------------------------------------------

   590 // CNssRecognitionHandler::MsruoEvent

   591 // Method to process the events from SRS utility object

   592 // -----------------------------------------------------------------------------

   593 //

   594 void CNssRecognitionHandler::MsruoEvent( TUid aEvent, TInt aResult )

   595     {

   596     RUBY_DEBUG2( "CNssRecognitionHandler::MsruoEvent Event = 0x%x, Result = %d", aEvent.iUid, aResult );

   597 

   598     switch ( aEvent.iUid )

   599         {

   600         case KUidAsrEventLoadModelsVal:

   601             {

   602             if (aResult == KErrNone)

   603                 {

   604                 DoLoadModelsComplete();

   605                 }

   606             else

   607                 {

   608                 DoLoadModelsFailed();

   609                 }

   610             break;

   611             }

   612             

   613         case KUidAsrEventLoadGrammarVal:

   614             {

   615             if (aResult == KErrNone)

   616                 {

   617                 DoLoadGrammarComplete();

   618                 }

   619             else

   620                 {

   621                 DoLoadGrammarFailed();

   622                 }

   623             break;

   624             }	

   625         case KUidAsrEventRecognitionReadyVal:

   626             {

   627             if (aResult == KErrNone)

   628                 {

   629                 DoRecognitionReady();                

   630                 }

   631             else

   632                 {

   633                 DoRecognitionFailed();

   634                 }

   635             break;

   636             }	

   637         case KUidAsrEventRecognitionVal:

   638             {

   639             

   640             if (aResult == KErrNone)

   641                 {

   642                 DoRecognitionComplete();

   643                 }

   644             else if ((aResult == KErrAsrNoSpeech) ||

   645                 (aResult == KErrAsrSpeechTooEarly) ||

   646                 (aResult == KErrAsrSpeechTooLong) ||

   647                 (aResult == KErrAsrSpeechTooShort))

   648                 {

   649                 DoRecognitionFailedNoSpeech(aResult);

   650                 }

   651             else if (aResult == KErrAsrNoMatch)

   652                 {

   653                 DoRecognitionFailedNoMatch();

   654                 }

   655             // Handle Cancelled the same as Failed

   656             else

   657                 {

   658                 DoRecognitionFailed();

   659                 }

   660             break;

   661             }	

   662         case KUidAsrEventRecordStartedVal:

   663             {

   664             DoRecordStarted();

   665             break;

   666             }

   667         case KUidAsrEventRecordVal:

   668             {

   669             if (aResult != KErrNone)

   670                 {

   671                 DoRecordFailed(aResult);

   672                 }

   673             // ignore Record KErrNone

   674             break;

   675             }

   676         case KUidAsrEventEouDetectedVal:

   677             {

   678             DoEouDetected();

   679             break;

   680             }

   681             

   682         case KUidAsrEventUnloadRuleVal:

   683             {

   684             if (aResult == KErrNone)

   685                 {

   686                 DoUnloadRuleComplete();

   687                 }

   688             else

   689                 {

   690                 DoUnloadRuleFailed();

   691                 }

   692             break;

   693             }	

   694             

   695         case KUidAsrEventAdaptVal:

   696             {

   697             if ( iRState != EVasDirectAdaptation && iRState != EVasIdleAdaptation )

   698                 {

   699 #ifdef _DEBUG

   700                 User::Panic( KRecognitionHandlerPanic, __LINE__ );

   701 #endif

   702                 return;

   703                 }

   704             

   705             if ( iRState == EVasIdleAdaptation )

   706                 {

   707                 Cleanup();

   708                 }

   709             

   710             if ( aResult == KErrNone )

   711                 {

   712                 iAdaptationHandler->HandleAdaptComplete( KErrNone );

   713                 }

   714             else{

   715                 iAdaptationHandler->HandleAdaptComplete( KErrGeneral );

   716                 }

   717             iRState = EVasWaitingForSelectTag;

   718             break;

   719             }

   720             

   721         case KUidAsrEventRemoveRuleVal:

   722             {

   723             if ( iRState == EVasCorrectingPluginDatabase )

   724                 {

   725                 if ( iWait.IsStarted() )

   726                     {

   727                     iWait.AsyncStop();

   728                     }

   729                 }

   730             else

   731                 {

   732                 Cleanup();

   733                 }

   734             break;

   735             }

   736             

   737         case KUidAsrEventPreStartSamplingVal:

   738             {

   739             DoPreStartSamplingComplete( aResult );

   740             break;

   741             }     

   742                

   743         default:

   744             {

   745             UnexpectedEvent();

   746             }

   747         }

   748     }

   749 

   750 // -----------------------------------------------------------------------------

   751 // CNssRecognitionHandler::CNssRecognitionHandler

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

   753 // might leave.

   754 // -----------------------------------------------------------------------------

   755 //

   756 CNssRecognitionHandler::CNssRecognitionHandler()

   757     {

   758     }

   759 

   760 // -----------------------------------------------------------------------------

   761 // CNssRecognitionHandler::ConstructL

   762 // Symbian 2nd phase constructor can leave.

   763 // -----------------------------------------------------------------------------

   764 //

   765 void CNssRecognitionHandler::ConstructL()

   766     {

   767     RUBY_DEBUG_BLOCK( "CNssRecognitionHandler::ConstructL" );

   768     iVasDBBuilder = CNssVASDBBuilder::InstanceL();

   769     iVasDBBuilder->InitializeL();

   770     

   771     iContextMgr = iVasDBBuilder->GetContextMgr();

   772     

   773     iTagMgr = iVasDBBuilder->GetTagMgr();

   774     

   775     iRState = EVasIdle;

   776     

   777     // Define P&S property

   778     TInt err = RProperty::Define( KSINDUID, ERecognitionState, RProperty::EInt); 

   779     if ( err != KErrNotFound && err != KErrAlreadyExists )

   780         {

   781         User::LeaveIfError( err );

   782         }

   783     }

   784 

   785 // -----------------------------------------------------------------------------

   786 // CNssRecognitionHandler::CleanupRecognizeInitFailed

   787 // Perform required cleanup to get back to the Idle state and issue the

   788 // HandleRecognizeInitError event with RecognizeInitFailed error code

   789 // -----------------------------------------------------------------------------

   790 //

   791 void CNssRecognitionHandler::CleanupRecognizeInitFailed()

   792     {

   793     RUBY_DEBUG0( "CNssRecognitionHandler::CleanupRecognizeInitFailed" );

   794     

   795     // Notify P&S

   796     RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   797     

   798     Cleanup();

   799     iInitCompleteHandler->HandleRecognizeInitComplete(

   800         MNssRecognizeInitCompleteHandler::EVasRecognizeInitFailed );

   801     }	

   802 

   803 // -----------------------------------------------------------------------------

   804 // CNssRecognitionHandler::CleanupRecognizeFailed

   805 // Perform required cleanup to get back to the Idle state and issue the

   806 // HandleRecognizeError event with RecognizeFailed error code

   807 // -----------------------------------------------------------------------------

   808 //

   809 void CNssRecognitionHandler::CleanupRecognizeFailed()

   810     {

   811     RUBY_DEBUG0( "CNssRecognitionHandler::CleanupRecognizeFailed" );

   812     

   813     // Notify P&S

   814     RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

   815     

   816     Cleanup();

   817     iEventHandler->HandleRecognizeComplete( NULL,

   818         MNssRecognizeEventHandler::EVasRecognizeFailed);

   819     }

   820 

   821 // -----------------------------------------------------------------------------

   822 // CNssRecognitionHandler::CleanupRejectTagFailed

   823 // Perform required cleanup to get back to the Idle state and issue the

   824 // HandleRejectTagError event with RejectTagFailed error code

   825 // -----------------------------------------------------------------------------

   826 //

   827 void CNssRecognitionHandler::CleanupRejectTagFailed()

   828     {

   829     RUBY_DEBUG0( "CNssRecognitionHandler::CleanupRejectTagFailed" );

   830     

   831     // Notify P&S

   832     RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 	

   833     

   834     Cleanup();

   835     iRejectTagCompleteHandler->HandleRejectTagComplete(

   836         MNssRejectTagCompleteHandler::EVasRejectTagFailed);

   837     }

   838 

   839 // -----------------------------------------------------------------------------

   840 // CNssRecognitionHandler::Cleanup

   841 // Perform required cleanup to get back to the Idle state

   842 // -----------------------------------------------------------------------------

   843 //

   844 void CNssRecognitionHandler::Cleanup()

   845     {

   846     RUBY_DEBUG0( "CNssRecognitionHandler::Cleanup" );

   847     

   848     if ( iTagMgr )

   849         {

   850         iTagMgr->CancelGetTag();

   851         }

   852     if ( iContextMgr )

   853         {

   854         iContextMgr->CancelGetContext();

   855         }

   856     DeleteSrf();

   857     ClearContextList();

   858     ClearTagList();

   859     ClearRuleList();

   860     ClearContextStatus();

   861     

   862     iRState = EVasIdle;

   863     }

   864 

   865 // -----------------------------------------------------------------------------

   866 // CNssRecognitionHandler:: DeleteSrf

   867 // Gracefully terminate and delete the SRF object, iSrsApi.

   868 // -----------------------------------------------------------------------------

   869 //

   870 void CNssRecognitionHandler::DeleteSrf()

   871     {

   872     if ( iSrsApi )

   873         {

   874         RUBY_DEBUG0( "CNssRecognitionHandler::DeleteSrf" );

   875         

   876         iSrsApi->CancelUtility();

   877         

   878         iSrsApi->EndRecSession();  // no need to check return code

   879         

   880         iSrsApi->SetEventHandler(NULL);

   881         

   882         delete iSrsApi;

   883         

   884         iSrsApi=NULL;

   885         }

   886 

   887     if ( iSIClientResultSet )

   888         {

   889         delete iSIClientResultSet;

   890         iSIClientResultSet = NULL;

   891         }

   892     }

   893 

   894 // -----------------------------------------------------------------------------

   895 // CNssRecognitionHandler::ClearContextList

   896 // Delete the context objects from iContextList

   897 // -----------------------------------------------------------------------------

   898 //

   899 void CNssRecognitionHandler::ClearContextList()

   900     {

   901     if (iContextList)

   902         {

   903         iContextList->ResetAndDestroy();

   904         delete iContextList;

   905         iContextList = NULL;

   906         }

   907     }

   908 

   909 // -----------------------------------------------------------------------------

   910 // CNssRecognitionHandler::ClearTagList

   911 // Delete the tag objects and tag list, iTagList

   912 // -----------------------------------------------------------------------------

   913 //

   914 void CNssRecognitionHandler::ClearTagList()

   915     {

   916     // The client deletes iTagList, its pointers,  and its tags

   917     // There is a window in RecognitionComplete while looping

   918     // through the ClientResultData and getting corresponding tags from

   919     // VasDb (GetTag). If a VasDb error occurs during this loop, 

   920     // Recognition still owns the iTagList tags and must delete them.

   921     // Otherwise at the end of the GetTag loop the list is given to the

   922     // client, and the client deletes the tags.

   923     

   924     // if iTagList is not NULL, delete iTagList and its tags.

   925     

   926     if ( iTagList )

   927         {

   928         iTagList->ResetAndDestroy();

   929         delete iTagList;

   930         iTagList = NULL;

   931         }

   932     }

   933 

   934 // -----------------------------------------------------------------------------

   935 // CNssRecognitionHandler::ClearRuleList

   936 // Delete the TRuleEntry objects from iRuleList

   937 // -----------------------------------------------------------------------------

   938 //

   939 void CNssRecognitionHandler::ClearRuleList()

   940     {

   941     if ( iRuleList )

   942         {

   943         iRuleList->Reset();

   944         delete iRuleList;

   945         iRuleList = NULL;

   946         }

   947     }

   948 

   949 // -----------------------------------------------------------------------------

   950 // CNssRecognitionHandler::ClearContextStatus

   951 // Delete the entries from iContextStatus

   952 // -----------------------------------------------------------------------------

   953 //

   954 void CNssRecognitionHandler::ClearContextStatus()

   955     {

   956     if ( iContextStatus )

   957         {

   958         iContextStatus->Reset();

   959         delete iContextStatus;

   960         iContextStatus = NULL;

   961         }

   962     }

   963 

   964 // -----------------------------------------------------------------------------

   965 // CNssRecognitionHandler::UnexpectedEvent

   966 // Unexpected event occurred. . 

   967 // -----------------------------------------------------------------------------

   968 //

   969 void CNssRecognitionHandler::UnexpectedEvent()

   970     {

   971     RUBY_DEBUG1( "CNssRecognitionHandler - UnexpectedEvent() iRState = %d", iRState );

   972     

   973     switch ( iRState )

   974         {

   975         case EVasIdle:

   976             {

   977             RUBY_DEBUG0( "CNssRecognitionHandler - Idle, Unexpected Srs Event" );

   978             break;

   979             }

   980             

   981             // RecognitionInit

   982         case EVasWaitingForLoadModelsComplete:

   983         case EVasWaitingForLoadLexiconComplete:

   984         case EVasWaitingForLoadGrammarComplete:

   985         case EVasWaitingForRecognitionReadyRecognitionInit:

   986             {

   987             CleanupRecognizeInitFailed();

   988             break;

   989             }

   990             

   991             // Recognition

   992         case EVasWaitingForRecordStarted:

   993         case EVasWaitingForEouDetected:

   994         case EVasWaitingForRecognitionComplete:

   995             {

   996             CleanupRecognizeFailed();

   997             break;

   998             }

   999             

  1000             // RejectTag

  1001         case EVasWaitingForUnloadRuleComplete:

  1002         case EVasWaitingForRecognitionReadyRejectTag:

  1003             {

  1004             CleanupRejectTagFailed();

  1005             break;

  1006             }

  1007         case EVasWaitingForRecognize:

  1008         case EVasWaitingForSelectTag:

  1009             {

  1010             // There is no event handler to return to.

  1011             // Notify P&S

  1012             RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 			

  1013             Cleanup();

  1014             RUBY_DEBUG1( "CNssRecognitionHandler - Invalid State = %d", iRState );

  1015             break;

  1016             }

  1017         default:

  1018             {

  1019             // unknown state - do not know event handler to return to

  1020             // Notify P&S

  1021             RProperty::Set( KSINDUID, ERecognitionState, ERecognitionFail ); 

  1022             Cleanup();

  1023             RUBY_DEBUG1( "CNssRecognitionHandler - Unknown State = %d", iRState );

  1024             }

  1025         }

  1026     }

  1027 

  1028 // -----------------------------------------------------------------------------

  1029 // CNssRecognitionHandler::DoPreStartSamplingComplete

  1030 // Handle PreStartSampling SRSF event 

  1031 // -----------------------------------------------------------------------------

  1032 //

  1033 void CNssRecognitionHandler::DoPreStartSamplingComplete( TInt aError )

  1034     {

  1035     iInitCompleteHandler->HandlePreSamplingStarted( aError );

  1036     }

  1037 

  1038 // -----------------------------------------------------------------------------

  1039 // CNssRecognitionHandler::DoLoadModelsComplete

  1040 // Handle LoadModelsComplete SRF event 

  1041 // -----------------------------------------------------------------------------

  1042 //

  1043 void CNssRecognitionHandler::DoLoadModelsComplete()

  1044     {

  1045     if ( iRState != EVasWaitingForLoadModelsComplete )

  1046         {

  1047         UnexpectedEvent();

  1048         return;

  1049         }

  1050     /*	iRState = EVasWaitingForLoadLexiconComplete;

  1051     TUint32 lexiconId = iContextList->

  1052     At(iContextCurrentLoopCount)->LexiconId();

  1053       

  1054     TInt errorCode = iSrsApi->LoadLexicon( (TSILexiconID)lexiconId );

  1055     if (errorCode)

  1056         {

  1057         CleanupRecognizeInitFailed();	

  1058         }

  1059     */

  1060     iRState = EVasWaitingForLoadGrammarComplete;

  1061     

  1062     // iContextCurrentLoopCount is 0

  1063     // set loop count to -1 so Load Grammar Complete converts it back to 0

  1064     iContextCurrentLoopCount = -1;

  1065     DoLoadGrammarComplete();

  1066     }

  1067 

  1068 // -----------------------------------------------------------------------------

  1069 // CNssRecognitionHandler::DoLoadModelsFailed

  1070 // Handle LoadModelsFailed SRF event 

  1071 // -----------------------------------------------------------------------------

  1072 //

  1073 void CNssRecognitionHandler::DoLoadModelsFailed()

  1074     {

  1075     if ( iRState != EVasWaitingForLoadModelsComplete )

  1076         {

  1077         UnexpectedEvent();

  1078         return;

  1079         }

  1080     CleanupRecognizeInitFailed();	

  1081     }

  1082 

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

  1084 // CNssRecognitionHandler::DoLoadLexiconComplete

  1085 // Handle LoadLexiconComplete SRF event 

  1086 // -----------------------------------------------------------------------------

  1087 //

  1088 void CNssRecognitionHandler::DoLoadLexiconComplete()

  1089     {

  1090     if ( iRState != EVasWaitingForLoadLexiconComplete )

  1091         {

  1092         UnexpectedEvent();

  1093         return;

  1094         }

  1095     iRState = EVasWaitingForLoadGrammarComplete;

  1096     

  1097     // iContextCurrentLoopCount is 0

  1098     // set loop count to -1 so Load Grammar Complete converts it back to 0

  1099     iContextCurrentLoopCount--;

  1100     DoLoadGrammarComplete();

  1101     }

  1102 

  1103 // -----------------------------------------------------------------------------

  1104 // CNssRecognitionHandler::DoLoadLexiconFailed

  1105 // Handle LoadLexiconFailed SRF event 

  1106 // -----------------------------------------------------------------------------

  1107 //

  1108 void CNssRecognitionHandler::DoLoadLexiconFailed()

  1109     {

  1110     if ( iRState != EVasWaitingForLoadLexiconComplete )

  1111         {

  1112         UnexpectedEvent();

  1113         return;

  1114         }

  1115     CleanupRecognizeInitFailed();			

  1116     }

  1117 

  1118 // -----------------------------------------------------------------------------

  1119 // CNssRecognitionHandler::DoLoadGrammarComplete

  1120 // Handle LoadGrammarComplete SRF event 

  1121 // -----------------------------------------------------------------------------

  1122 //

  1123 void CNssRecognitionHandler::DoLoadGrammarComplete()

  1124     {

  1125     if ( iRState != EVasWaitingForLoadGrammarComplete )

  1126         {

  1127         UnexpectedEvent();

  1128         return;

  1129         }

  1130     // if there are more contexts, 

  1131     // continue loading Grammars, into the SRS

  1132     iContextCurrentLoopCount++;

  1133     

  1134     while ( iContextCurrentLoopCount < iContextCount )