--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/srsf/sisrscontrollerplugin/src/sicontrollerplugin.cpp Wed Sep 01 12:29:17 2010 +0100
@@ -0,0 +1,3929 @@
+/*
+* Copyright (c) 2004-2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: This is the main implementation of the SI Controller Plugin.
+* Finite State Machine is implemented here.
+*
+*/
+
+
+// INCLUDE FILES
+#include <mmfcodec.h>
+#include <nsssispeechrecognitiondatadevasr.h>
+
+#include <badesca.h>
+#include <mmfbase.h>
+
+#include "sicontrollerplugin.h"
+#include "sicontrollerplugininterface.h"
+#include "sidatabase.h"
+
+#include "siresourcehandler.h"
+#include "asrplugindataloader.h"
+
+#include "sigrammardb.h"
+#include "silexicondb.h"
+#include "simodelbankdb.h"
+
+#include "rubydebug.h"
+
+#ifdef __SINDE_TRAINING
+#include "sindetraining.h"
+#endif // __SINDE_TRAINING
+
+// Package types for general & language specific TTP data
+
+// CONSTANTS
+
+// Message types used in RunL
+//const TInt KAddPronunciation = 1; // Commented out to remove "not referenced" warning
+const TInt KAddRule = 2;
+const TInt KCreateGrammar = 3;
+const TInt KCreateLexicon = 4;
+const TInt KCreateModelBank = 5;
+const TInt KGetAllClientGrammarIDs = 6;
+const TInt KGetAllClientLexiconIDs = 7;
+const TInt KGetAllClientModelBankIDs = 8;
+const TInt KGetAllGrammarIDs = 9;
+const TInt KGetAllLexiconIDs = 10;
+const TInt KGetAllModelBankIDs = 11;
+const TInt KGetAllModelIDs = 12;
+const TInt KGetAllPronunciationIDs = 13;
+const TInt KGetAllRuleIDs = 14;
+const TInt KGetAvailableStorage = 15;
+const TInt KGetModelCount = 16;
+const TInt KGetRuleValidity = 17;
+const TInt KGetUtteranceDuration = 18;
+const TInt KLoadGrammar = 19;
+const TInt KLoadLexicon = 20;
+const TInt KLoadModels = 21;
+const TInt KPlayUtterance = 22;
+const TInt KRecognize = 23;
+const TInt KRecord = 24;
+const TInt KRemoveGrammar = 25;
+const TInt KRemoveLexicon = 26;
+const TInt KRemoveModelBank = 27;
+const TInt KRemoveModel = 28;
+const TInt KRemovePronunciation = 29;
+const TInt KRemoveRule = 30;
+const TInt KTrain = 31;
+const TInt KUnloadRule = 32;
+
+// SI only functionalities
+const TInt KAdapt = 33;
+//const TInt KSIAddPronunciation = 34; // Commented out to remove "not referenced" warning
+const TInt KAddRuleVariant = 35;
+//const TInt KAddVoiceTag = 36; // Commented out to remove "not referenced" warning
+const TInt KAddVoiceTags = 37;
+const TInt KCreateRule = 38;
+//const TInt KSIRecognize = 39; // Commented out to remove "not referenced" warning
+const TInt KEndRecord = 40;
+const TInt KUnloadGrammar = 41;
+//const TInt KUpdateGrammarAndLexicon = 42; // Commented out to remove "not referenced" warning
+const TInt KGetPronunciationCount = 43;
+const TInt KGetRuleCount = 44;
+const TInt KRemoveRules = 45;
+
+//const TInt KAddSIPronunciation = 43; // Commented out to remove "not referenced" warning
+//const TInt KAddOneSIPronunciation = 44; // Commented out to remove "not referenced" warning
+
+#ifdef __SINDE_TRAINING
+// SINDE voice tags creation
+const TInt KAddSindeVoiceTags = 46;
+//const TInt KAddSindeVoiceTag = 47; // Commented out to remove "not referenced" warning
+#endif // __SINDE_TRAINING
+
+const TInt KPreStartSampling = 48;
+
+// Define this if SINDE lexicon optimization is on
+#define __SIND_LEXICON_OPT
+
+// Secure ID of voice commands application process
+_LIT_SECURE_ID( KVoiceCommandsAppUid, 0x101f8555 );
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+
+// -----------------------------------------------------------------------------
+// Panic
+// User panic when an unrecoverable error occurs.
+// Returns: -
+// -----------------------------------------------------------------------------
+//
+void Panic( TInt aPanicCode ) // Panic code
+ {
+ _LIT( KSDControllerPanicCategory, "SIControllerPlugin" );
+ User::Panic( KSDControllerPanicCategory, aPanicCode );
+ }
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::CSIControllerPlugin
+// C++ default constructor can NOT contain any code, that might leave.
+// -----------------------------------------------------------------------------
+//
+CSIControllerPlugin::CSIControllerPlugin( CSIControllerPluginInterface& aControllerIf )
+ : CActive( EPriorityLess ),
+ iState( ESiPluginIdle ),
+ iControllerIf( aControllerIf ),
+ iClientRegistered( EFalse ),
+ iGrammarID( 0 ),
+ iDataLoader( NULL )
+ {
+ RUBY_DEBUG0( "CSIControllerPlugin::CSIControllerPlugin" );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::ConstructL()
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::ConstructL" );
+
+ iResourceHandler = CSIResourceHandler::NewL();
+
+ // Data loader
+ iDataLoader = CDataLoader::NewL( *(iResourceHandler->iDataFilenamePrefix),
+ *(iResourceHandler->iDataFilenameSeperator),
+ *(iResourceHandler->iDataFilenamePostfix ) );
+
+ TFileName dbFileName( *(iResourceHandler->iDbFileName ));
+
+ // Database instances
+ iSIDatabase = CSIDatabase::NewL( dbFileName );
+ RDbNamedDatabase& database = iSIDatabase->SIDatabase();
+ RDbs& dbSession = iSIDatabase->DbSession();
+ TInt drive = iSIDatabase->DbDrive();
+ iSIGrammarDB = CSIGrammarDB::NewL( database, dbSession, drive );
+ iSILexiconDB = CSILexiconDB::NewL( database, dbSession, drive );
+ iSIModelBankDB = CSIModelBankDB::NewL( database, dbSession, drive );
+
+ iSIDatabase->BeginTransactionL();
+
+ if ( !( iSIDatabase->DoesLockTableExistL() ) )
+ {
+ iSIDatabase->CreateLockTableL();
+ }
+
+ // Need to create all 3 ID tables at single transaction
+
+
+ // Create tables if they don't already exist
+ if ( !( iSIDatabase->DoesModelBankTableExistL() ) )
+ {
+ iSIModelBankDB->CreateIDTableL();
+ }
+
+ if ( !( iSIDatabase->DoesLexiconTableExistL() ) )
+ {
+ iSILexiconDB->CreateIDTableL();
+ }
+
+ if ( !( iSIDatabase->DoesGrammarTableExistL() ) )
+ {
+ iSIGrammarDB->CreateIDTableL();
+ }
+
+ iSIDatabase->CommitChangesL( ETrue );
+
+
+ iSITtpWordList = CSITtpWordList::NewL();
+
+ iDevASR = CDevASR::NewL( *this );
+
+ RUBY_DEBUG2( "[%d] CSIControllerPlugin::ConstructL - DevASR[%d]", this, iDevASR );
+
+#ifdef __SINDE_TRAINING
+ iSindeTrainer = CSindeTrainer::NewL( *iDevASR, iControllerIf, *this,
+ *iSIDatabase, *iSIGrammarDB, *iSILexiconDB );
+#endif // __SINDE_TRAINING
+
+ // Add active object to active scheduler
+ CActiveScheduler::Add( this );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+CSIControllerPlugin* CSIControllerPlugin::NewL( CSIControllerPluginInterface& aControllerIf )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::NewL" );
+ CSIControllerPlugin* self = new( ELeave ) CSIControllerPlugin( aControllerIf );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::~CSIControllerPlugin
+// Destructor
+// -----------------------------------------------------------------------------
+//
+CSIControllerPlugin::~CSIControllerPlugin()
+ {
+ RUBY_DEBUG0( "CSIControllerPlugin::~CSIControllerPlugin" );
+
+ RThread().SetPriority( EPriorityNormal );
+
+ Cancel();
+
+ // if there is any outstanding request, cancel it.
+ if ( iDevASR )
+ {
+ iDevASR->Cancel();
+ }
+
+ delete iDevASR;
+ delete iResourceHandler;
+ delete iSIGrammarDB;
+ delete iSILexiconDB; // Handled by Grcompiler
+ delete iSIModelBankDB;
+ delete iDataLoader;
+
+ delete iSIDatabase;
+ delete iSICompiledGrammarRecompile;
+
+ iMaxNPronunsForWord.Close();
+ delete iSITtpWordList;
+
+#ifdef __SINDE_TRAINING
+ delete iSindeTrainer;
+#endif // __SINDE_TRAINING
+
+ if ( iTrainArrays != NULL )
+ {
+ iTrainArrays->ResetAndDestroy();
+ iTrainArrays->Close();
+ delete iTrainArrays;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AddPronunciationL
+// Calls the lexicon database handler to add a new pronunciation into the lexicon.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AddPronunciationL( TSILexiconID /*aLexiconID*/,
+ TSIModelBankID /*aModelBankID*/,
+ const TDesC8& /*aPronunciationPr*/,
+ TSIPronunciationID& /*aPronunciationID*/ )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AddPronunciationL 1" );
+ User::Leave( KErrNotSupported );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AddPronunciationL
+// Calls the lexicon database handler to add a new pronunciation into the lexicon.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AddPronunciationL( TSILexiconID /*aLexiconID*/,
+ TSIModelBankID /*aModelBankID*/,
+ TSIModelID /*aModelID*/,
+ TSIPronunciationID& /*aPronunciationID*/ )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AddPronunciationL 2" );
+ User::Leave( KErrNotSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::SDLexiconL
+// -----------------------------------------------------------------------------
+//
+#ifdef DEVASR_KEEP_SD
+CSDLexicon* CSIControllerPlugin::SDLexiconL( TSILexiconID anID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::SDLexiconL" );
+
+ User::Leave( KErrNotSupported );
+ return NULL;
+ }
+#endif
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AddRuleL
+// Calls the grammar database handler to add a new rule into the grammar.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AddRuleL( TSIGrammarID aGrammarID,
+ TSILexiconID aLexiconID,
+ TSIPronunciationID aPronunciationID,
+ TSIRuleID& aRuleID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AddRuleL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KAddRule;
+ iGrammarID = aGrammarID;
+ iLexiconID = aLexiconID;
+ iPronunciationID = aPronunciationID;
+ iRuleIDPtr = &aRuleID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleAddRule
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleAddRuleL( TSIGrammarID /*aGrammarID*/,
+ TSILexiconID /*aLexiconID*/,
+ TSIPronunciationID /*aPronunciationID*/,
+ TSIRuleID& /*aRuleID*/ )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleAddRuleL" );
+
+ User::Leave( KErrNotSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::Cancel
+// Cancels the current activity and returns the plugin to Idle state.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::Cancel()
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::Cancel (State=%d)", iState );
+
+ this->iSIDatabase->Rollback();
+ switch ( iState )
+ {
+ case ESdPluginTrain:
+ iDevASR->Cancel();
+
+ TRAP_IGNORE(
+ iSIDatabase->BeginTransactionL();
+ iSIModelBankDB->Reset();
+ iSIDatabase->CommitChangesL( ETrue );
+ ); // TRAP_IGNORE
+
+ break;
+
+ case ESiPluginRecognize:
+ iDevASR->Cancel();
+ iState = ESiPluginRecognize;
+ break;
+ case ESiPluginTrainText:
+#ifdef __SINDE_TRAINING
+ case ESiPluginTrainSinde:
+#endif // __SINDE_TRAINING
+ iDevASR->Cancel();
+ iState = ESiPluginIdle;
+ break;
+ case ESiPluginPlay:
+ iDevASR->Cancel();
+ break;
+
+ case ESiPluginIdle:
+ // Nothing to cancel
+ break;
+
+ default:
+ // Unknown state - should never be here
+ break;
+ }
+
+ // Cancel the active object
+ CActive::Cancel();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::CommitChangesL
+// Commits (saves) all database changes since the last commit request.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::CommitChangesL( TBool aCommit )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::CommitChangesL" );
+ iSIDatabase->CommitChangesL( aCommit );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::CreateGrammarL
+// Calls the grammar database handler to create a new grammar.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::CreateGrammarL( TSIGrammarID& aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::CreateGrammarL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KCreateGrammar;
+ iGrammarIDPtr = &aGrammarID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleCreateGrammarL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleCreateGrammarL( TSIGrammarID& aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleCreateGrammarL" );
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+
+ // update model banks if they are not valid anymore
+ RArray<TSIModelBankID> modelBankIDs;
+ CleanupClosePushL( modelBankIDs );
+ iSIModelBankDB->GetAllClientModelBankIDsL( iClientUid, modelBankIDs );
+ for ( TInt i(0); i < modelBankIDs.Count(); i++ )
+ {
+ iSIModelBankDB->UpdateModelBankIfInvalidL( modelBankIDs[i] );
+ }
+ CleanupStack::PopAndDestroy( &modelBankIDs );
+ aGrammarID = iSIGrammarDB->CreateGrammarL(iClientUid);
+ iSIDatabase->CommitChangesL( ETrue );
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::CreateLexiconL
+// Calls the lexicon database handler to create a new lexicon.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::CreateLexiconL( TSILexiconID& aLexiconID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::CreateLexiconL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KCreateLexicon;
+ iLexiconIDPtr = &aLexiconID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleCreateLexiconL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleCreateLexiconL( TSILexiconID& aLexiconID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleCreateLexiconL");
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ aLexiconID = iSILexiconDB->CreateLexiconL(iClientUid);
+ iSIDatabase->CommitChangesL( ETrue );
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::CreateModelBankL
+// Calls the model database handler to create a new model bank.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::CreateModelBankL( TSIModelBankID& aModelBankID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::CreateModelBankL");
+
+ if ( IsActive() )
+ {
+ User::Leave(KErrServerBusy);
+ }
+ iRequestFunction = KCreateModelBank;
+ iModelBankIDPtr = &aModelBankID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleCreateModelBankL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleCreateModelBankL( TSIModelBankID& aModelBankID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleCreateModelBankL");
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ aModelBankID = iSIModelBankDB->CreateModelBankL(iClientUid);
+ iSIDatabase->CommitChangesL( ETrue );
+ }
+ else
+ {
+ User::Leave(KErrAsrNotRegisted);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::EndRecSessionL
+// Ends recognition session and releases resources. If not in recognition state,
+// no action is taken.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::EndRecSessionL()
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::EndRecSessionL");
+
+ switch ( iState )
+ {
+ case ESiPluginRecognize:
+ iDevASR->EndRecSession();
+ // Save the changes during model adaption.
+ iSIDatabase->CommitChangesL( ETrue );
+ RecognitionReset();
+ break;
+ case ESiPluginIdle:
+ // Ignore if already Idle
+ break;
+ default:
+ // Wrong state
+ User::Leave( KErrNotReady );
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::ActivateGrammarL
+// Activate the grammar for the recognition
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::ActivateGrammarL( TSIGrammarID aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::ActivateGrammarL");
+ iDevASR->ActivateGrammarL(aGrammarID);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::DeactivateGrammarL
+// Deactivate the grammar for the recognition
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::DeactivateGrammarL(TSIGrammarID aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::DeactivateGrammarL");
+ iDevASR->DeactivateGrammarL(aGrammarID);
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetAllClientGrammarIDsL
+// Returns all grammar Ids that belong to the current client.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetAllClientGrammarIDsL( RArray<TSIGrammarID>& aGrammarIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::GetAllClientGrammarIDsL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetAllClientGrammarIDs;
+
+ iGrammarIDs = &aGrammarIDs;
+
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetAllClientGrammarIDsL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetAllClientGrammarIDsL( RArray<TSIGrammarID>& aGrammarIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleGetAllClientGrammarIDsL");
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ iSIGrammarDB->GetAllClientGrammarIDsL(iClientUid, aGrammarIDs);
+ iSIDatabase->CommitChangesL( EFalse );
+
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetAllClientLexiconIDsL
+// Returns all lexicon Ids that belong to the current client.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetAllClientLexiconIDsL( RArray<TSILexiconID>& aLexiconIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::GetAllClientLexiconIDsL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetAllClientLexiconIDs;
+ iLexiconIDs = &aLexiconIDs;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetAllClientLexiconIDsL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetAllClientLexiconIDsL( RArray<TSILexiconID>& aLexiconIDs )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleGetAllClientLexiconIDsL" );
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ iSILexiconDB->GetAllClientLexiconIDsL( iClientUid, aLexiconIDs );
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetAllClientModelBankIDsL
+// Returns all model bank Ids that belong to the current client.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetAllClientModelBankIDsL( RArray<TSIModelBankID>& aModelBankIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::GetAllClientModelBankIDsL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetAllClientModelBankIDs;
+ iModelBankIDs = &aModelBankIDs;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetAllClientModelBankIDsL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetAllClientModelBankIDsL( RArray<TSIModelBankID>& aModelBankIDs )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleGetAllClientModelBankIDsL" );
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ iSIModelBankDB->GetAllClientModelBankIDsL( iClientUid, aModelBankIDs );
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetAllGrammarIDsL
+// Returns all grammar Ids that exist (for all clients).
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetAllGrammarIDsL( RArray<TSIGrammarID>& aGrammarIDs )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::GetAllGrammarIDsL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetAllGrammarIDs;
+ iGrammarIDs = &aGrammarIDs;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetAllGrammarIDsL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetAllGrammarIDsL( RArray<TSIGrammarID>& aGrammarIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleGetAllGrammarIDsL");
+
+ iSIDatabase->BeginTransactionL();
+ iSIGrammarDB->GetAllGrammarIDsL(aGrammarIDs);
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetAllLexiconIDsL
+// Returns all lexicon Ids that exist (for all clients).
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetAllLexiconIDsL( RArray<TSILexiconID>& aLexiconIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::GetAllLexiconIDsL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetAllLexiconIDs;
+ iLexiconIDs = &aLexiconIDs;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetAllLexiconIDsL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetAllLexiconIDsL( RArray<TSILexiconID>& aLexiconIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleGetAllLexiconIDsL");
+
+ iSIDatabase->BeginTransactionL();
+ iSILexiconDB->GetAllLexiconIDsL(aLexiconIDs);
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetAllModelBankIDsL
+// Returns all model bank Ids that exist (for all clients).
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetAllModelBankIDsL( RArray<TSIModelBankID>& aModelBankIDs )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::GetAllModelBankIDsL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetAllModelBankIDs;
+ iModelBankIDs = &aModelBankIDs;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetAllModelBankIDsL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetAllModelBankIDsL( RArray<TSIModelBankID>& aModelBankIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleGetAllModelBankIDsL");
+
+ iSIDatabase->BeginTransactionL();
+ iSIModelBankDB->GetAllModelBankIDsL( aModelBankIDs );
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetAllModelIDsL
+// Calls the model database handler to get all model IDs in the model bank.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetAllModelIDsL( TSIModelBankID aModelBankID,
+ RArray<TSIModelID>& aModelIDs )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::GetAllModelIDsL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetAllModelIDs;
+ iModelBankID = aModelBankID;
+ iModelIDs = &aModelIDs;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetAllModelIDsL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetAllModelIDsL( TSIModelBankID aModelBankID,
+ RArray<TSIModelID>& aModelIDs )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleGetAllModelIDsL" );
+
+ iSIDatabase->BeginTransactionL();
+ iSIModelBankDB->GetAllModelIDsL(aModelBankID, aModelIDs);
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetAllPronunciationIDsL
+// Calls the lexicon database handler to get all pronunciation IDs in the lexicon.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetAllPronunciationIDsL( TSILexiconID aLexiconID,
+ RArray<TSIPronunciationID>& aPronunciationIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::GetAllPronunciationIDsL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetAllPronunciationIDs;
+ iLexiconID = aLexiconID;
+ iPronunciationIDs = &aPronunciationIDs;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetAllPronunciationIDsL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetAllPronunciationIDsL( TSILexiconID aLexiconID,
+ RArray<TSIPronunciationID>& aPronunciationIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleGetAllPronunciationIDsL");
+
+ iSIDatabase->BeginTransactionL();
+ iSILexiconDB->GetAllPronunciationIDsL(aLexiconID, aPronunciationIDs);
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetAllRuleIDsL
+// Calls the grammar database handler to get all rule IDs in the grammar.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetAllRuleIDsL( TSIGrammarID aGrammarID,
+ RArray<TSIRuleID>& aRuleIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::GetAllRuleIDsL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetAllRuleIDs;
+ iGrammarID = aGrammarID;
+ iRuleIDs = &aRuleIDs;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetAllRuleIDsL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetAllRuleIDsL( TSIGrammarID aGrammarID,
+ RArray<TSIRuleID>& aRuleIDs )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleGetAllRuleIDsL");
+
+ iSIDatabase->BeginTransactionL();
+ iSIGrammarDB->GetAllRuleIDsL(aGrammarID, aRuleIDs);
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetAvailableStorageL
+// Calculates the available number of models that can be trained by subtracting
+// the current total from the system defined max.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetAvailableStorageL( TInt& aCount )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::GetAvailableStorageL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetAvailableStorage;
+ iCountPtr = &aCount;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetAvailableStorageL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetAvailableStorageL( TInt& aCount )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleGetAvailableStorageL");
+
+ iSIDatabase->BeginTransactionL();
+ TInt count = iSIModelBankDB->AllModelCountL();
+ iSIDatabase->CommitChangesL( EFalse );
+
+ if ( count > iResourceHandler->iMaxModelsSystem )
+ {
+ aCount = 0;
+ }
+ else
+ {
+ aCount = iResourceHandler->iMaxModelsSystem - count;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetEnginePropertiesL
+// Returns the current recognition engine properties.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetEnginePropertiesL( const RArray<TInt>& aPropertyId,
+ RArray<TInt>& aPropertyValue )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::GetEnginePropertiesL" );
+
+ for ( TInt index = 0; index < aPropertyId.Count(); index++ )
+ {
+ switch( aPropertyId[index] )
+ {
+ case KModelStorageCapacity:
+ aPropertyValue.Append( iResourceHandler->iMaxModelsSystem );
+ break;
+
+ case KMaxLoadableModels:
+ aPropertyValue.Append( iResourceHandler->iMaxModelsPerBank );
+ break;
+
+ default:
+ aPropertyValue.Append( KErrNotSupported );
+ break;
+ }
+ }
+
+ iDevASR->GetEnginePropertiesL( aPropertyId, aPropertyValue );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetModelCountL
+// Calls the model database handler for the number of models in a model bank.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetModelCountL( TSIModelBankID aModelBankID,
+ TInt& aCount )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::GetModelCountL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetModelCount;
+ iModelBankID = aModelBankID;
+ iCountPtr = &aCount;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetModelCountL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetModelCountL( TSIModelBankID aModelBankID,
+ TInt& aCount )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleGetModelCountL" );
+
+ iSIDatabase->BeginTransactionL();
+ aCount = iSIModelBankDB->ModelCountL( aModelBankID );
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetPronunciationCountL
+// Calls the model database handler for the number of Pronunciation in a lexicon
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetPronunciationCountL( TSILexiconID aLexiconID,
+ TInt& aCount )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::GetPronunciationCountL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetPronunciationCount;
+ iLexiconID = aLexiconID;
+ iCountPtr = &aCount;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetPronunciationCountL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetPronunciationCountL( TSIModelBankID aLexiconID,
+ TInt& aCount )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleGetPronunciationCountL" );
+
+ iSIDatabase->BeginTransactionL();
+ aCount = iSILexiconDB->PronunciationCountL( aLexiconID );
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetRuleCountL
+// Calls the model database handler for the number of Pronunciation in a lexicon
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetRuleCountL( TSIGrammarID aGrammarID,
+ TInt& aCount )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::GetRuleCountL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetRuleCount;
+ iGrammarID = aGrammarID;
+ iCountPtr = &aCount;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetRuleCountL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetRuleCountL( TSIGrammarID aGrammarID,
+ TInt& aCount )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleGetRuleCountL");
+
+ iSIDatabase->BeginTransactionL();
+ aCount = iSIGrammarDB->RuleCountL(aGrammarID);
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetRuleValidityL
+// Calls the grammar database handler to see if the rule exists in the specified
+// grammar.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetRuleValidityL( TSIGrammarID aGrammarID,
+ TSIRuleID aRuleID,
+ TBool& aValid )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::GetRuleValidityL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetRuleValidity;
+ iGrammarID = aGrammarID;
+ iRuleID = aRuleID;
+ iValidPtr = &aValid;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetRuleValidityL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetRuleValidityL( TSIGrammarID aGrammarID,
+ TSIRuleID aRuleID,
+ TBool& aValid )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleGetRuleValidityL");
+
+ iSIDatabase->BeginTransactionL();
+ aValid = iSIGrammarDB->IsRuleValidL(aGrammarID, aRuleID);
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::GetUtteranceDurationL
+// Calls the model database handler to get the duration of an utterance.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::GetUtteranceDurationL( TSIModelBankID aModelBankID,
+ TSIModelID aModelID,
+ TTimeIntervalMicroSeconds32& aDuration )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::GetUtteranceDurationL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KGetUtteranceDuration;
+ iModelBankID = aModelBankID;
+ iModelID = aModelID;
+ iDurationPtr = &aDuration;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleGetUtteranceDurationL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleGetUtteranceDurationL( TSIModelBankID /*aModelBankID*/,
+ TSIModelID /*aModelID*/,
+ TTimeIntervalMicroSeconds32& /*aDuration*/ )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleGetUtteranceDurationL" );
+ User::Leave( KErrNotSupported );
+ }
+
+
+ // -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandlePlayUtteranceL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandlePlayUtteranceL( TSIModelBankID /*aModelBankID*/,
+ TSIModelID /*aModelID*/ )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandlePlayUtteranceL" );
+ User::Leave( KErrNotSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::LoadEngineParametersL
+// Loads the specified recognizer parameter(s). These parameters are used to
+// alter the recognizer's default parameters. The parameters are specified as
+// attribute and value pairs.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::LoadEngineParametersL( const RArray<TInt>& aParameterId,
+ const RArray<TInt>& aParameterValue )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::LoadEngineParametersL" );
+ iDevASR->LoadEngineParametersL( aParameterId, aParameterValue );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::LoadGrammarL
+// Requests the grammar database handler for a grammar object to be loaded into
+// the recognizer for recognition purpose.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::LoadGrammarL( TSIGrammarID aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::LoadGrammarL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+
+ iRequestFunction = KLoadGrammar;
+ iGrammarID = aGrammarID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleLoadGrammarL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleLoadGrammarL( TSIGrammarID aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleLoadGrammarL" );
+
+ if ( iState == ESiPluginRecognize )
+ {
+ const CSICompiledGrammar* grammar = NULL;
+ // iGrammarDB keeps a reference to the grammar object so we don't
+ // have to push it onto a cleanupstack.
+
+ iSIDatabase->BeginTransactionL();
+ grammar = iSIGrammarDB->LoadGrammarL(aGrammarID);
+ iSIDatabase->CommitChangesL( EFalse );
+
+ iDevASR->LoadGrammar( *grammar );
+ }
+ else
+ {
+ User::Leave( KErrAsrInvalidState );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::LoadLexiconL
+// Requests the lexicon database handler for a lexicon object to be loaded into
+// the recognizer for recognition purpose.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::LoadLexiconL( TSILexiconID aLexiconID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::LoadLexiconL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KLoadLexicon;
+ iLexiconID = aLexiconID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleLoadLexiconL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleLoadLexiconL( TSILexiconID aLexiconID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleLoadLexiconL" );
+
+ if ( iState == ESiPluginRecognize )
+ {
+ const CSILexicon* lexicon = NULL;
+ // iGrammarDB keeps a reference to the grammar object so we don't
+ // have to push it onto a cleanupstack.
+
+ iSIDatabase->BeginTransactionL();
+ lexicon = iSILexiconDB->LexiconL( aLexiconID );
+ iSIDatabase->CommitChangesL( EFalse );
+
+ iDevASR->LoadLexicon( *lexicon );
+ }
+ else
+ {
+ // Wrong state
+ User::Leave( KErrAsrInvalidState );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::LoadModelsL
+// Requests the model database handler for a model bank object to be loaded into
+// the recognizer for recognition purpose.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::LoadModelsL( TSIModelBankID aModelBankID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::LoadModelsL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KLoadModels;
+ iModelBankID = aModelBankID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleLoadModelsL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleLoadModelsL( TSIModelBankID aModelBankID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleLoadModelsL" );
+
+ if ( iState == ESiPluginRecognize )
+ {
+
+ const CSIModelBank* modelBank = NULL;
+ // iModelBankDB keeps a reference to the modelBank object so we don't
+ // have to push it onto a cleanupstack.
+ iSIDatabase->BeginTransactionL();
+ modelBank = iSIModelBankDB->AllAcousticModelsL( aModelBankID );
+ iSIDatabase->CommitChangesL( EFalse );
+
+ iDevASR->LoadModels( *modelBank );
+
+ }
+ else
+ {
+ // Wrong state
+ User::Leave( KErrAsrInvalidState );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::PlayUtteranceL
+// Plays the user utterance.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::PlayUtteranceL( TSIModelBankID aModelBankID,
+ TSIModelID aModelID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::PlayUtteranceL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KPlayUtterance;
+ iModelBankID = aModelBankID;
+ iModelID = aModelID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RecognizeL
+// Initiates recognition towards the recognizer.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RecognizeL( CSDClientResultSet& /*aClientResultSet*/ )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::RecognizeL(sd)" );
+ User::Leave( KErrNotSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RecognizeL
+// Initiates recognition towards the recognizer.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RecognizeL( CSIClientResultSet& aResultSet )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::RecognizeL(si)");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KRecognize ;
+
+ iSIClientResultSet=&aResultSet;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleRecognizeL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleRecognizeL()
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleRecognizeL" );
+
+ if ( iState == ESiPluginRecognize )
+ {
+ iSIDatabase->BeginTransactionL();
+
+ if ( iSIGrammarDB->IsGrammarLoaded() )
+ {
+ // ClientResultSet was already saved by RunL
+ iSIResultSet = &( iSIClientResultSet->SIResultSet() );
+ iDevASR->InitRecognizerBE( *iSIResultSet );
+ }
+ else
+ {
+ // Either the loaded grammars are empty (contains no rule) or
+ // all rules have been unloaded. No need to proceed any further.
+ iSIDatabase->CommitChangesL( ETrue );
+ User::Leave( KErrNotReady );
+ }
+
+ iSIDatabase->CommitChangesL( ETrue );
+ }
+ else
+ {
+ // Wrong state
+ User::Leave( KErrAsrInvalidState );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RecordL
+// Initiates recording of user utterance.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RecordL( TTimeIntervalMicroSeconds32 aRecordTime )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::RecordL" );
+
+ RUBY_DEBUG0( "CSIControllerPlugin::RecognizeL Returning thread priority back to normal" );
+ // the priority was lowered in the StartRecSessionL as a quick fix (voice ui
+ // tone player had too low priority to run. Toi minimize the poorly tested
+ // consequences of the quick-fix, we return priority back to normal
+ // as soon as possible
+
+// Temporary fix that makes voiceui work in wk36-> sdks
+// RThread().SetPriority( EPriorityNormal );
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KRecord;
+ iRecordTime = aRecordTime;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleRecordL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleRecordL( TTimeIntervalMicroSeconds32 aRecordTime )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleRecordL");
+
+ if ( iState == ESdPluginTrain || iState == ESiPluginRecognize )
+ {
+ iDevASR->Record(aRecordTime);
+ }
+ else
+ {
+ // Wrong state
+ User::Leave( KErrAsrInvalidState );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::PreStartSamplingL
+// Pre-starts sampling before recognition start.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::PreStartSamplingL()
+ {
+ RUBY_DEBUG_BLOCK( "" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KPreStartSampling;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandlePreStartSamplingL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandlePreStartSamplingL()
+ {
+ RUBY_DEBUG_BLOCK( "" );
+ iDevASR->PreStartSamplingL();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RemoveGrammarL
+// Calls the grammar database handler to remove a grammar.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RemoveGrammarL( TSIGrammarID aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::RemoveGrammarL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KRemoveGrammar;
+ iGrammarID = aGrammarID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleRemoveGrammarL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleRemoveGrammarL( TSIGrammarID aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleRemoveGrammarL");
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ iSIGrammarDB->RemoveGrammarL( iClientUid, aGrammarID );
+ iSIDatabase->CommitChangesL( ETrue ) ;
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RemoveLexiconL
+// Calls the lexicon database handler to remove a lexicon.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RemoveLexiconL( TSILexiconID aLexiconID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::RemoveLexiconL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KRemoveLexicon;
+ iLexiconID = aLexiconID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleRemoveLexiconL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleRemoveLexiconL( TSILexiconID aLexiconID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleRemoveLexiconL");
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ iSILexiconDB->RemoveLexiconL( iClientUid, aLexiconID );
+ iSIDatabase->CommitChangesL( ETrue ) ;
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RemoveModelBankL
+// Calls the model database handler to remove a model bank.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RemoveModelBankL( TSIModelBankID aModelBankID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::RemoveModelBankL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KRemoveModelBank;
+ iModelBankID = aModelBankID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleRemoveModelBankL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleRemoveModelBankL( TSIModelBankID aModelBankID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleRemoveModelBankL" );
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ iSIModelBankDB->RemoveModelBankL( iClientUid, aModelBankID );
+ iSIDatabase->CommitChangesL( ETrue ) ;
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RemoveModelL
+// Calls the model database handler to remove a model from a model bank.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RemoveModelL( TSIModelBankID aModelBankID,
+ TSIModelID aModelID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::RemoveModelL" );
+
+ if ( IsActive() )
+ {
+
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KRemoveModel;
+ iModelBankID = aModelBankID;
+ iModelID = aModelID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleRemoveModelL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleRemoveModelL( TSIModelBankID /*aModelBankID*/,
+ TSIModelID /*aModelID*/ )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleRemoveModelL" );
+ User::Leave( KErrNotSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RemovePronunciationL
+// Calls the lexicon database handler to remove a pronunciation from a lexicon.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RemovePronunciationL( TSILexiconID aLexiconID,
+ TSIPronunciationID aPronunciationID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::RemovePronunciationL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KRemovePronunciation;
+ iLexiconID = aLexiconID;
+ iPronunciationID = aPronunciationID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleRemovePronunciationL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleRemovePronunciationL( TSILexiconID aLexiconID,
+ TSIPronunciationID aPronunciationID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleRemovePronunciationL" );
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ iSILexiconDB->RemovePronunciationL( iClientUid, aLexiconID, aPronunciationID );
+ iSIDatabase->CommitChangesL( ETrue ) ;
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RemoveRuleL
+// Calls the grammar database handler to remove a rule from a grammar.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RemoveRuleL( TSIGrammarID aGrammarID,
+ TSIRuleID aRuleID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::RemoveRuleL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iState=ESiPluginRemoveRule; // handled by database modify function
+ iRequestFunction = KRemoveRule;
+ iGrammarID = aGrammarID;
+ iRuleID = aRuleID;
+ DoAsynch();
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleRemoveRuleL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleRemoveRuleL( TSIGrammarID aGrammarID,
+ TSIRuleID aRuleID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleRemoveRuleL" );
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+
+ iSICompiledGrammarRecompile = ( CSICompiledGrammar* )iSIGrammarDB->GrammarL( aGrammarID );
+ // if leave as KErrArgument
+
+ CSIRule* aRule = &iSICompiledGrammarRecompile->AtL( iSICompiledGrammarRecompile->Find( aRuleID ) );
+
+
+ // in a rule , all the variant have same lexicon ID, that is because
+ // the way it was added in addvoicetags()
+ CSIRuleVariant* rv = &aRule->AtL( 0 );
+ TSILexiconID lexiconId = rv->LexiconID();
+
+ TSIPronunciationIDSequence pronunciationIdSequence;
+ CleanupClosePushL( pronunciationIdSequence );
+
+ CSILexicon* lexicon = iSILexiconDB->LexiconL( lexiconId );
+ CleanupStack::PushL( lexicon );
+
+ for ( TInt i = 0; i < aRule->Count(); i++ )
+ {
+ pronunciationIdSequence.Reset();
+ CSIRuleVariant* rv = &aRule->AtL( i );
+ rv->GetPronunciationIDsL( pronunciationIdSequence );
+ for ( TInt k = 0; k < pronunciationIdSequence.Count(); k++ )
+ {
+ lexicon->DeleteL( pronunciationIdSequence[k] );
+ }
+ }
+
+ // Update the lexicon
+ iSILexiconDB->UpdateLexiconL( iClientUid, lexicon );
+
+ CleanupStack::PopAndDestroy( lexicon );
+ CleanupStack::PopAndDestroy( &pronunciationIdSequence );
+
+
+ // Recompile the grammar after a deletion
+ // Async call, callback handled in handleeventtp
+
+ iSICompiledGrammarRecompile->DeleteL( aRuleID );
+ if ( iSICompiledGrammarRecompile->Count() == 0 )
+ {
+ // Reset compiled data to null
+ iSICompiledGrammarRecompile->SetCompiledData( NULL );
+ delete iSICompiledGrammarRecompile;
+ iSICompiledGrammarRecompile = NULL;
+ // Special case, do the callback now since we're not expecting
+ // anything from the lower layers
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveRule, iResult );
+ }
+ else
+ {
+ iDevASR->CompileGrammarL( *iSICompiledGrammarRecompile );
+ }
+
+ iSIDatabase->CommitChangesL( ETrue );
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RemoveRulesL
+// Calls the grammar database handler to remove a set of rules from a grammar.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RemoveRulesL( TSIGrammarID aGrammarID,
+ RArray<TSIRuleID>& aRuleIDs )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::RemoveRulesL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iState=ESiPluginRemoveRules; // handled by database modify function
+ iRequestFunction = KRemoveRules;
+ iGrammarID = aGrammarID;
+ iRuleIDs = &aRuleIDs;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleRemoveRulesL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// (other items were commented in a header).
+// Note, that request to remove a non-existing rule completes successfully
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleRemoveRulesL( TSIGrammarID aGrammarID,
+ RArray<TSIRuleID>& aRuleIDs )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleRemoveRulesL" );
+ TInt i( 0 );
+
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleRemoveRulesL grammarId [%d]", aGrammarID );
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleRemoveRulesL aRuleIDs.Count() = [%d]", aRuleIDs.Count() );
+
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+
+ // 1.Get the lexion id
+ // 2. For each rule, delete it's varant's prounication from lexicon and then delete the rule from grammar
+ // 3. Update lexicon DB.
+ // 4. Recompile the grammar
+ // Get the grammar ,use all rules, so it clean up when iSIGrammarDB is deleted
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleRemoveRulesL Getting All rules for grammarID [%d]", aGrammarID );
+
+ iSICompiledGrammarRecompile = ( CSICompiledGrammar* )iSIGrammarDB->GrammarL( aGrammarID );
+ __UHEAP_MARK;
+ RPointerArray<CSILexicon> aLexiconArray;
+ CleanupClosePushL( aLexiconArray );
+ RArray<TSILexiconID> aLexiconIDs;
+ CleanupClosePushL( aLexiconIDs );
+ CSILexicon* aLexicon;
+
+ // if leave as KErrArgument
+ for ( i = 0; i < aRuleIDs.Count(); i++ )
+ {
+ TSIRuleID aRuleID = aRuleIDs[i];
+ TInt removeRuleIndex = iSICompiledGrammarRecompile->Find( aRuleID );
+ CSIRule* aRule = NULL; // rule to remove
+ if ( removeRuleIndex == KErrNotFound )
+ {
+ RUBY_DEBUG1("CSIControllerPlugin::HandleRemoveRulesL RuleID [%d] not found. Probably already deleted", aRuleID );
+ // Nothing to delete in this round.
+ // Proceed to the next one
+ continue;
+ }
+ else if ( removeRuleIndex >= 0 )
+ {
+ aRule = &iSICompiledGrammarRecompile->AtL( removeRuleIndex );
+ }
+ else
+ {
+ // Unknown error
+ User::Leave( removeRuleIndex );
+ }
+ // in a rule , all the variant have same lexicon ID,
+ // and all the rule's rule variant have same lexicon ID,
+ // one lexicon corresponding to one grammar
+ // that is because the way it was added in addvoicetags()
+ CSIRuleVariant* aRv = &aRule->AtL( 0 );
+ TSILexiconID aLexiconID = aRv->LexiconID();
+
+ // This hack ensures 4 byte alignment in winscw
+ TSILexiconID* lexID = new ( ELeave ) TSILexiconID;
+ CleanupStack::PushL( lexID );
+ *lexID = aRv->LexiconID();
+ // Uniq ids array
+ aLexiconIDs.InsertInSignedKeyOrder( *lexID );
+ CleanupStack::PopAndDestroy( lexID );
+ }
+ // collect the lexicon according to the uniq lexicon array
+ for ( i = 0; i < aLexiconIDs.Count(); i++ )
+ {
+ aLexicon = iSILexiconDB->LexiconL( aLexiconIDs[i] );
+ aLexiconArray.Append( aLexicon );
+ }
+
+ for ( i = 0; i < aRuleIDs.Count(); i++ )
+ {
+ TSIRuleID aRuleID = aRuleIDs[i];
+
+ TInt removeRuleIndex = iSICompiledGrammarRecompile->Find( aRuleID );
+ CSIRule* aRule = NULL; // rule to remove
+ if ( removeRuleIndex == KErrNotFound )
+ {
+ RUBY_DEBUG1("CSIControllerPlugin::HandleRemoveRulesL RuleID [%d] not found. Probably already deleted", aRuleID );
+ // Nothing to delete in this round.
+ // Proceed to the next one
+ continue;
+ }
+ else if ( removeRuleIndex >= 0 )
+ {
+ aRule = &iSICompiledGrammarRecompile->AtL( removeRuleIndex );
+ }
+ else
+ {
+ // Unknown error
+ User::Leave( removeRuleIndex );
+ }
+
+ // in a rule , all the variant have same lexicon ID, that is because
+ // the way it was added in addvoicetags()
+
+ TSIPronunciationIDSequence aIPronunciationIDSequence;
+ CleanupClosePushL( aIPronunciationIDSequence );
+
+ for ( TInt i = 0 ; i < aRule->Count() ; i++ )
+ {
+ aIPronunciationIDSequence.Reset();
+ CSIRuleVariant* aRv = &aRule->AtL( i );
+ aRv->GetPronunciationIDsL( aIPronunciationIDSequence );
+ TSILexiconID aLexiconID = aRv->LexiconID();
+ TInt aLocation = 0;
+ for ( TInt s = 0 ; s < aLexiconIDs.Count() ; s++ )
+ {
+ if ( aLexiconIDs[s] == aLexiconID )
+ {
+ aLocation = s;
+ break;
+ }
+ }
+
+ CSILexicon* aLexicon =aLexiconArray[aLocation];
+ for ( TInt k = 0 ; k < aIPronunciationIDSequence.Count() ; k++ )
+ {
+ aLexicon->DeleteL( aIPronunciationIDSequence[k] );
+ }
+ }
+
+ // delete aIPronunciationIDSequence
+ CleanupStack::PopAndDestroy( &aIPronunciationIDSequence );
+
+ // Recompile the grammar after a deletion
+ // Async call, callback handled in handleeventtp
+ //delete iSICompiledGrammarRecompile;
+ iSICompiledGrammarRecompile->DeleteL( aRuleID );
+ }
+
+ // Update the lexicon
+ for ( i = 0; i < aLexiconArray.Count(); i++ )
+ {
+ iSILexiconDB->UpdateLexiconL( iClientUid, aLexiconArray[i] );
+ }
+
+ // clean up
+ // Close the arrays
+ //aLexiconIDs.Close();
+ CleanupStack::PopAndDestroy( &aLexiconIDs ); // CleanupClosePushL aLexiconIDs
+ aLexiconArray.ResetAndDestroy();
+ CleanupStack::PopAndDestroy( &aLexiconArray ); //aLexiconArray
+ __UHEAP_MARKEND;
+
+ if ( iSICompiledGrammarRecompile->Count() == 0 )
+ {
+ // Reset compiled data to null
+ iSICompiledGrammarRecompile->SetCompiledData( NULL );
+
+ iSIDatabase->BeginTransactionL();
+ // save the compiled grammar
+ TRAPD( error, iSIGrammarDB->UpdateGrammarL( iClientUid,iSICompiledGrammarRecompile ) );
+ iSIDatabase->CommitChangesL( ETrue );
+ if ( error )
+ {
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveRules, error );
+ delete iSICompiledGrammarRecompile;
+ iState = ESiPluginIdle;
+ return;
+ }
+ TRAP( error, iSIDatabase->CommitChangesL( ETrue ) );
+
+ delete iSICompiledGrammarRecompile;
+ iSICompiledGrammarRecompile = NULL;
+ iState = ESiPluginIdle;
+
+ // Special case, do the callback now since we're not expecting
+ // anything from the lower layers
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveRules, error );
+ } // if ( iSICompiledGrammarRecompile->Count() == 0 )
+ else
+ {
+ iDevASR->CompileGrammarL( *iSICompiledGrammarRecompile );
+ }
+
+ } // if ( iClientRegistered )
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::SetClientUid
+// Sets the client's UID for data ownership identification.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::SetClientUid( TUid aClientUid )
+ {
+ RUBY_DEBUG0( "CSIControllerPlugin::SetClientUid") ;
+ iClientUid = aClientUid;
+ iClientRegistered = ETrue;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::SetPrioritySettings
+// Set the priority settings for this controller. This is used during recording
+// and playback.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::SetPrioritySettings( const TMMFPrioritySettings& aPrioritySettings )
+ {
+ RUBY_DEBUG0( "CSIControllerPlugin::SetPrioritySettings" );
+ iDevASR->SetPrioritySettings( aPrioritySettings );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::StartRecSessionL
+// Initiates a recognition session.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::StartRecSessionL()
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::StartRecSessionL" );
+ RThread().SetPriority( EPriorityAbsoluteLow );
+ RUBY_DEBUG0( "CSIControllerPlugin::StartRecSessionL Lowered thread priority to absolute low" );
+ //RUBY_DEBUG1( "CSIControllerPlugin::StartRecSessionL Thread id is [%x]", RThread().Id() );
+
+ if ( iState == ESiPluginIdle )
+ {
+
+ User::LeaveIfError( iDevASR->StartRecSession( ESiRecognition ) );
+ iState = ESiPluginRecognize;
+ }
+ else
+ {
+ // Wrong state
+ User::Leave( KErrAsrInvalidState );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::TrainL
+// Initiates a speaker depedent training session.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::TrainL( TSIModelBankID aModelBankID,
+ TSIModelID& aModelID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::TrainL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KTrain;
+ iModelBankID = aModelBankID;
+ iModelIDPtr = &aModelID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleTrainL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleTrainL( TSIModelBankID /*aModelBankID*/ )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleTrainL" );
+ User::Leave( KErrNotSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::UnloadRuleL
+// Unloads a rule from the recognizer for this recognition session.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::UnloadRuleL( TSIGrammarID aGrammarID,
+ TSIRuleID aRuleID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::UnloadRuleL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KUnloadRule;
+ iGrammarID = aGrammarID;
+ iRuleID = aRuleID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleUnloadRuleL
+// This is the asynchronous handle called from the CSIAsyncHandler object.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleUnloadRuleL( TSIGrammarID aGrammarID,
+ TSIRuleID aRuleID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleUnloadRuleL" );
+ iDevASR->UnloadRule( aGrammarID, aRuleID ); // for blacklisting only
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleUnloadRuleL
+// Notification from DevASR when feature vectors are available.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::FeatureVectorDataRcvd( const TDesC8& /*aFV*/,
+ TInt32 /*aSNR*/,
+ TInt32 /*aPosition*/ )
+ {
+ RUBY_DEBUG0( "CSIControllerPlugin::FeatureVectorDataRcvd" );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::DevASREvent
+// Event from DevASR interface.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::DevASREvent( TDevASREvent aEvent,
+ TDevASRError aError )
+ {
+ RUBY_DEBUG2( "CSIControllerPlugin::DevASREvent (Event=%d, Error=%d)", aEvent, aError );
+
+ switch ( iState )
+ {
+ case ESdPluginTrain:
+ TRAP_IGNORE( HandleEventTrainL( aEvent, aError ) );
+ break;
+ case ESiPluginRecognize:
+ HandleEventRecognize( aEvent, aError );
+ break;
+ case ESiPluginPlay:
+ TRAP_IGNORE( HandleEventPlayL( aEvent, aError ) );
+ break;
+ case ESiPluginTrainText:
+ HandleEventTTP( aEvent, aError );
+ break;
+#ifdef __SINDE_TRAINING
+ case ESiPluginTrainSinde:
+ iSindeTrainer->HandleEvent( aEvent, aError );
+ break;
+#endif // __SINDE_TRAINING
+ case ESiPluginRemoveRule:
+ HandleEventRemoveRule( aEvent, aError );
+ break;
+ case ESiPluginRemoveRules:
+ RUBY_DEBUG0( "CSIControllerPlugin::DevASREvent case iState ESiPluginRemoveRules" );
+ HandleEventRemoveRules( aEvent, aError );
+ break;
+ case ESiPluginIdle:
+ break;
+ default:
+ // Unexpected or cancelled message
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RequestSpeechData
+// Get speech data from audio buffer
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RequestSpeechData()
+ {
+ const TInt KBufferMaxLength( 4000 );
+ TInt sizeLeft( iAudioBuffer->Size() - iNSamplesSent * 2 );
+ if ( sizeLeft == 0 )
+ {
+ // nothing
+ }
+ else if ( sizeLeft < KBufferMaxLength*2 )
+ {
+ // last buffer
+ iCurrentAudioBuffer.Set( iAudioBuffer->Right( sizeLeft ) );
+ iDevASR->SendSpeechData( iCurrentAudioBuffer, ETrue );
+
+ iNSamplesSent += sizeLeft/2;
+ }
+ else
+ {
+ iCurrentAudioBuffer.Set( iAudioBuffer->Mid( 2*iNSamplesSent, 2*KBufferMaxLength ) );
+
+ iDevASR->SendSpeechData( iCurrentAudioBuffer, EFalse );
+ iNSamplesSent += KBufferMaxLength;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::SILexiconL
+// Load lexicon by this call back functionDevAsr Take the owner ship of the lexicon
+// -----------------------------------------------------------------------------
+//
+CSILexicon* CSIControllerPlugin::SILexiconL( TSILexiconID anID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::SILexiconL");
+
+ iSIDatabase->BeginTransactionL();
+ CSILexicon* lexicon = iSILexiconDB->LexiconL(anID);
+ iSIDatabase->CommitChangesL( EFalse );
+
+ return lexicon;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::ConfigurationData
+// DevASR calls this method to get configuration data.
+// -----------------------------------------------------------------------------
+//
+HBufC8* CSIControllerPlugin::ConfigurationData( TUint32 aPackageType,
+ TUint32 aPackageID,
+ TUint32 aStartPosition ,
+ TUint32 aEndPosition )
+ {
+ RUBY_DEBUG0( "ConfigurationData::MdtoConfigurationData" );
+ return ( iDataLoader->LoadData( aPackageType, aPackageID,
+ aStartPosition, aEndPosition ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::DevASRMessage
+// A message in response to a custom command. This controller never sends a
+// custom command.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::DevASRMessage( TDesC8& /*aMsg*/ )
+ {
+ // SI Controller Plugin does not implement this event.
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::PlayL
+// Plays the trained user utterance.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::PlayL( TSIModelBankID /*aModelBankID*/,
+ TSIModelID /*aModelID*/ )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::PlayL");
+ User::Leave(KErrNotSupported);
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleEventPlayL
+// Handling of DevASR event in Play state.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleEventPlayL( TDevASREvent/* aEvent*/,
+ TDevASRError/* aError*/ )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleEventPlayL" );
+ User::Leave( KErrNotSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleEventPlayL
+// Handling of DevASR event in RemoveRule state.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleEventRemoveRule( TDevASREvent aEvent,
+ TDevASRError aError )
+ {
+ iState = ESiPluginIdle;
+
+ if ( aError )
+ {
+ iControllerIf.SendSrsEvent(KUidAsrEventRemoveRule, aError);
+ delete iSICompiledGrammarRecompile;
+ iSICompiledGrammarRecompile = NULL;
+ return;
+ }
+
+ switch (aEvent)
+ {
+ case EDevASRGrammarCompile:
+ {
+ TRAPD( error,
+ iSIDatabase->BeginTransactionL();
+ // save the compiled grammar
+ iSIGrammarDB->UpdateGrammarL( iClientUid, iSICompiledGrammarRecompile );
+ iSIDatabase->CommitChangesL( ETrue );
+ ); // TRAPD
+ if ( error )
+ {
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveRule, error );
+ delete iSICompiledGrammarRecompile;
+ iSICompiledGrammarRecompile = NULL;
+ iState = ESiPluginIdle;
+ return;
+ }
+ TRAP( error, iSIDatabase->CommitChangesL( ETrue ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveRule, error );
+
+ delete iSICompiledGrammarRecompile;
+ iSICompiledGrammarRecompile = NULL;
+ iState = ESiPluginIdle;
+ break;
+
+ }
+ default:
+ // Unexpected or cancelled message
+ RUBY_DEBUG0( "CSIControllerPlugin::HandleEventRemoveRule. Unexpected.") ;
+ break;
+ }
+
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleEventRemoveRules
+// Handling of DevASR event in RemoveRules state.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleEventRemoveRules( TDevASREvent aEvent,
+ TDevASRError aError )
+ {
+ RUBY_DEBUG2( "CSIControllerPlugin::HandleEventRemoveRules. Event [%d], Error [%d]", aEvent, aError );
+
+ iState = ESiPluginIdle;
+
+ if ( aError )
+ {
+ iControllerIf.SendSrsEvent(KUidAsrEventRemoveRules, aError);
+ delete iSICompiledGrammarRecompile;
+ iSICompiledGrammarRecompile = NULL;
+ return;
+ }
+
+ switch ( aEvent )
+ {
+ case EDevASRGrammarCompile:
+ {
+ TRAPD( error,
+ iSIDatabase->BeginTransactionL();
+ // save the compiled grammar
+ iSIGrammarDB->UpdateGrammarL( iClientUid, iSICompiledGrammarRecompile );
+ iSIDatabase->CommitChangesL( ETrue );
+ ); // TRAPD
+
+ if ( error )
+ {
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveRules, error );
+ delete iSICompiledGrammarRecompile;
+ iSICompiledGrammarRecompile = NULL;
+ iState = ESiPluginIdle;
+ return;
+ }
+ TRAP( error, iSIDatabase->CommitChangesL( ETrue ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveRules, error );
+
+ delete iSICompiledGrammarRecompile;
+ iSICompiledGrammarRecompile = NULL;
+ iState = ESiPluginIdle;
+ break;
+
+ }
+ default:
+ // Unexpected or cancelled message
+ RUBY_DEBUG0( "CSIControllerPlugin::HandleEventRemoveRules. Unexpected." );
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleEventTTP
+// Handling of DevASR event in TTP state.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleEventTTP( TDevASREvent aEvent,
+ TDevASRError aError )
+ {
+ if ( aError )
+ {
+ iControllerIf.SendSrsEvent(KUidAsrEventAddVoiceTags, aError);
+ iState = ESiPluginIdle;
+ return;
+ }
+
+ switch ( aEvent )
+ {
+ case EDevASRTrainFromText:
+ //case EDevASRTrainFromTextFinished:
+ {
+
+ TRAPD( error,
+ UpdateGrammarAndLexiconDBL( iSITtpWordList, iLexiconID, iGrammarID,*iRuleIDs );
+ iSIDatabase->BeginTransactionL();
+ iSICompiledGrammar = ( CSICompiledGrammar* )iSIGrammarDB->LoadGrammarL( iGrammarID );
+ iSIDatabase->CommitChangesL( EFalse );
+ iDevASR->CompileGrammarL( *iSICompiledGrammar );
+ );
+ if ( error )
+ {
+ iControllerIf.SendSrsEvent( KUidAsrEventAddVoiceTags, error );
+ iState = ESiPluginIdle;
+ return;
+ }
+
+ break;
+ }
+ case EDevASRGrammarCompile:
+ {
+ TInt error = KErrNone;
+ TRAP( error,
+ iSIDatabase->BeginTransactionL();
+ // save the compiled grammar
+ iSIGrammarDB->UpdateGrammarL( iClientUid, iSICompiledGrammar );
+ iSIDatabase->CommitChangesL( ETrue );
+ ); // TRAP
+ iControllerIf.SendSrsEvent( KUidAsrEventAddVoiceTags, error );
+ iState = ESiPluginIdle;
+ break;
+ }
+ default:
+ // Unexpected or cancelled message
+ RUBY_DEBUG0( "CSIControllerPlugin::HandleEventTTP. Unexpected." );
+ break;
+
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleEventRecognizeL
+// Handling of DevASR event in Recognition state.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleEventRecognize( TDevASREvent aEvent,
+ TDevASRError aError )
+ {
+ RUBY_DEBUG2( "CSIControllerPlugin::HandleEventRecognize - Event=%d, Error=%d", aEvent, aError);
+
+ switch ( aEvent )
+ {
+ case EDevASRLoadModels:
+ // case EDevASRModelsLoaded:
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRLoadModels failed with error [%d]", aError );
+
+ TRAP_IGNORE(
+ iSIDatabase->BeginTransactionL();
+ iSIModelBankDB->ResetAndDestroy();
+ iSIDatabase->CommitChangesL( ETrue );
+ ); // TRAP_IGNORE
+
+ iState = ESiPluginIdle;
+ }
+
+ iControllerIf.SendSrsEvent( KUidAsrEventLoadModels, aError );
+ break;
+ case EDevASRLoadLexicon:
+ // case EDevASRLexiconLoaded:
+
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRLoadLexicon failed with error [%d]", aError );
+ iSIModelBankDB->ResetAndDestroy();
+ iSILexiconDB->ResetAndDestroy();
+ iState = ESiPluginIdle;
+ }
+ iControllerIf.SendSrsEvent( KUidAsrEventLoadLexicon, aError );
+ break;
+
+ case EDevASRLoadGrammar:
+ // case EDevASRGrammarLoaded:
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRLoadGrammar failed with error [%d]", aError );
+
+ iSIModelBankDB->ResetAndDestroy();
+ iSILexiconDB->ResetAndDestroy();
+ iSIGrammarDB->ResetAndDestroy();
+ iState = ESiPluginIdle;
+ }
+ iControllerIf.SendSrsEvent( KUidAsrEventLoadGrammar, aError );
+ break;
+
+ case EDevASRInitRecognitionBackend:
+ //case EDevASRRecBEInitialized:
+ if ( aError == KErrNone )
+ {
+ iDevASR->InitFrontEnd( ESiRecognition );
+ }
+ else
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRInitRecognitionBackend failed with error [%d]", aError );
+
+ RecognitionReset();
+ iControllerIf.SendSrsEvent( KUidAsrEventRecognition, KErrAsrInitializationFailure );
+ }
+ break;
+
+ case EDevASRInitFrontend:
+ //case EDevASRFEInitialized:
+
+ if ( aError == KErrNone )
+ {
+ iControllerIf.SendSrsEvent( KUidAsrEventRecognitionReady, KErrNone );
+ }
+ else
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRInitFrontend failed with error [%d]", aError );
+
+ RecognitionReset();
+ iControllerIf.SendSrsEvent( KUidAsrEventRecognition, KErrAsrInitializationFailure );
+ }
+ break;
+
+ case EDevASRRecordStarted:
+ //case EDevASRRecordStarted:
+
+ iControllerIf.SendSrsEvent( KUidAsrEventRecordStarted, aError );
+ break;
+
+ case EDevASRRecord:
+ //case EDevASRRecordFinished:
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRRecord failed with error [%d]", aError );
+
+ RecognitionReset();
+ }
+ iControllerIf.SendSrsEvent( KUidAsrEventRecord, aError );
+ break;
+
+ case EDevASRAdapt: // adaptation finished
+ // case EDevASRAdaptFinished: // adaptation finished
+
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRAdapt failed with error [%d]", aError );
+
+ iControllerIf.SendSrsEvent( KUidAsrEventAdapt, aError );
+ }
+ else
+ {
+ // save the models , iModelBankID decided in loadmodel()
+ TRAPD( error,
+ iSIDatabase->BeginTransactionL();
+ iSIModelBankDB->SaveModelL( iModelBankID );
+ iSIDatabase->CommitChangesL( ETrue );
+ ); // TRAPD
+ iControllerIf.SendSrsEvent( KUidAsrEventAdapt, error );
+ }
+ break;
+ case EDevASREouDetected:
+ //case EDevASRRecordFinished:
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASREouDetected failed with error [%d]", aError );
+
+ RecognitionReset();
+ }
+ iControllerIf.SendSrsEvent( KUidAsrEventEouDetected, aError );
+ break;
+
+ // case EDevASREouDetected:
+
+ case EDevASRRecognize:
+
+ {
+ if ( aError == KErrNone )
+ {
+
+ // Copy result into client result
+ if ( ProcessRecognitionComplete() > 0 )
+ {
+ iResult = KErrNone;
+ }
+ else
+ {
+ iResult = KErrAsrNoMatch;
+ }
+ }
+ else if (aError ==KErrOverflow ||aError ==KErrArgument )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRRecognize failed with error [%d]", aError );
+
+ iResult = aError;
+ }
+ else
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRRecognize failed with error [%d]", aError );
+
+ if ( aError != KErrAsrNoSpeech &&
+ aError != KErrAsrSpeechTooEarly &&
+ aError != KErrAsrSpeechTooLong &&
+ aError != KErrAsrSpeechTooShort &&
+ aError != KErrTimedOut &&
+ aError !=KErrOverflow &&
+ aError !=KErrArgument
+ )
+ {
+ RecognitionReset();
+ }
+ iResult = aError;
+ }
+
+ iControllerIf.SendSrsEvent(KUidAsrEventRecognition, iResult);
+
+ // iControllerIf.SendSrsEvent(KUidAsrEventRecognition, iResult);
+ break;
+ }
+ case EDevASRPlayStarted:
+ iControllerIf.SendSrsEvent(KUidAsrEventPlayStarted, aError);
+ break;
+
+ case EDevASRPlay:
+ //case EDevASRPlayFinished:
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRPlay failed with error [%d]", aError );
+
+ RecognitionReset();
+ }
+ iControllerIf.SendSrsEvent(KUidAsrEventPlay, aError);
+ break;
+ case EDevASRActivateGrammar:
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRActivateGrammar failed with error [%d]", aError );
+
+ RecognitionReset();
+ }
+ iControllerIf.SendSrsEvent(KUidAsrEventActivateGrammar, aError);
+ break;
+ case EDevASRDeactivateGrammar:
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRDeactivateGrammar failed with error [%d]", aError );
+
+ RecognitionReset();
+ }
+ iControllerIf.SendSrsEvent(KUidAsrEventDeactivateGrammar, aError);
+ break;
+ case EDevASRUnloadGrammar:
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRUnloadGrammar failed with error [%d]", aError );
+
+ RecognitionReset();
+ }
+ else
+ {
+ TRAP_IGNORE(
+ iSIDatabase->BeginTransactionL();
+ iSIGrammarDB->UnloadGrammarL( iGrammarID );
+ iSIDatabase->CommitChangesL( ETrue );
+ ); // TRAP_IGNORE
+ }
+
+ iControllerIf.SendSrsEvent(KUidAsrEventUnloadGrammar, aError);
+ break;
+ case EDevASRUnloadRule:
+ if ( aError != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::HandleEventRecognize. EDevASRUnloadRule failed with error [%d]", aError );
+
+ //RecognitionReset();
+ }
+ else
+ {
+ TRAP_IGNORE(
+ iSIDatabase->BeginTransactionL();
+ iSIGrammarDB->UnloadRuleL( iGrammarID, iRuleID );
+ iSIDatabase->CommitChangesL( ETrue );
+ ); // TRAPD
+ }
+ iControllerIf.SendSrsEvent( KUidAsrEventUnloadRule, aError );
+ break;
+
+ default:
+ // Unexpected or cancelled message
+ RUBY_DEBUG0( "CSIControllerPlugin::HandleEventRecognize. Unexpected." );
+
+ break;
+ }
+
+}
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleEventTrainL
+// Handling of DevASR event in Train state.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleEventTrainL( TDevASREvent /*aEvent*/,
+ TDevASRError /*aError*/ )
+{
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleEventTrainL" );
+ User::Leave( KErrNotSupported );
+}
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::CreateNewRuleL
+// Create a empty rule into a given grammar
+// -----------------------------------------------------------------------------
+//
+CSIRule* CSIControllerPlugin::CreateNewRuleL( CSICompiledGrammar* aGrammar )
+ {
+ RUBY_DEBUG_BLOCKL("CSIControllerPlugin::CreateNewRuleL");
+ TInt aID=0;
+ TInt Count=aGrammar->Count();
+ // existing myRuleVariantID
+ RArray<TSIRuleID> myIDs;
+ myIDs.Reset();
+ for( TInt i = 0; i < Count; i++ )
+ {
+ CSIRule* aRule=&(aGrammar->AtL(i));
+ myIDs.Append(aRule->RuleID());
+ }
+ // Find a uniq new id
+ iSIDatabase->BeginTransactionL();
+ aID=iSIGrammarDB->GetNewID(myIDs);
+ iSIDatabase->CommitChangesL( EFalse );
+
+ myIDs.Close();
+ CSIRule* aRule = CSIRule::NewL(aID);
+ return( aRule );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AddNewRuleVariantL
+// Create new rule variant within a rule
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AddNewRuleVariantL( CSIRule& aRule,
+ TSILexiconID aLexiconID,
+ RArray<TSIPronunciationID>& aPronunciationIDs,
+ CSIParameters& aParameters )
+ {
+ RUBY_DEBUG_BLOCKL( "CSIControllerPlugin::AddNewRuleVariantL" );
+ // existing myRuleVariantID
+ RArray<TSIRuleID> myID;
+ myID.Reset();
+ TInt i( 0 );
+ for( i = 0; i < aRule.Count(); i++ ) {
+ CSIRuleVariant* aRuleVariant=&(aRule.AtL(i));
+ myID.Append(aRuleVariant->RuleVariantID());
+ }
+
+ iSIDatabase->BeginTransactionL();
+
+ // Find a uniq new id
+ TSIRuleVariantID aRuleVariantID=STATIC_CAST(TSIRuleVariantID,iSIGrammarDB->GetNewID(myID));
+ myID.Close();
+
+ iSIDatabase->CommitChangesL( ETrue );
+
+ // add the rule variant to the rule
+ CSIRuleVariant* ruleVariant= CSIRuleVariant::NewL(aRuleVariantID,aLexiconID);
+ CleanupStack::PushL( ruleVariant );
+ ruleVariant->SetPronunciationIDsL( aPronunciationIDs );
+ RArray<TInt> parameterIDs;
+ CleanupClosePushL( parameterIDs );
+ RArray<TInt> parameterValues;
+ CleanupClosePushL( parameterValues );
+
+ // copy parameters
+ aParameters.ListParametersL( parameterIDs, parameterValues );
+
+ if ( parameterIDs.Count() != parameterValues.Count() )
+ {
+ User::Leave( KErrCorrupt );
+ }
+ for ( i = 0; i < parameterIDs.Count(); i++ )
+ {
+ ruleVariant->SetParameterL( parameterIDs[i], parameterValues[i] );
+ }
+
+ CleanupStack::PopAndDestroy(); // parameterValues
+ CleanupStack::PopAndDestroy(); // parameterIDs
+ aRule.AddL( ruleVariant );
+ CleanupStack::Pop( ruleVariant );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::CreateNewPronunciationL
+// Create a empty pronunciation into a given lexicon
+// -----------------------------------------------------------------------------
+//
+TSIPronunciationID CSIControllerPlugin::CreateNewPronunciationL( CSILexicon* aLexicon,
+ TDesC8& aPronunciationPr,
+ TSIModelBankID aModelBankID)
+ {
+ RUBY_DEBUG_BLOCKL( "CSIControllerPlugin::CreateNewPronunciationL" );
+
+ TSIPronunciationID pronunciationID( 0 );
+
+ if ( aLexicon->Count() )
+ {
+ pronunciationID = aLexicon->AtL( aLexicon->Count() - 1 ).PronunciationID() + 1;
+ }
+
+ // RUBY_DEBUG1("pronunID = %i", pronunciationID );
+ // add the Pronunciation to the Pronunciation
+ CSIPronunciation* pronunciation = CSIPronunciation::NewL( pronunciationID, aModelBankID );
+
+ CleanupStack::PushL( pronunciation );
+ pronunciation->SetPhonemeSequenceL( aPronunciationPr );
+ TRAPD( error, aLexicon->AddL( pronunciation ) );
+ if ( error == KErrAlreadyExists )
+ {
+#ifdef __SIND_LEXICON_OPT
+ // Take the existing pronunciation ID
+ TInt index = aLexicon->Find( aPronunciationPr );
+ pronunciationID = aLexicon->AtL( index ).PronunciationID();
+
+ CleanupStack::PopAndDestroy( pronunciation );
+#else
+ // try to find non-existing id in the middle of range
+ RUBY_DEBUG0( "pronunID already exists" );
+ RArray<TSIPronunciationID> myPronunciationID;
+ myPronunciationID.Reset();
+ for ( TInt i = 0; i < aLexicon->Count(); i++ )
+ {
+ CSIPronunciation* tmpPronunciation=&( aLexicon->AtL( i ) );
+ myPronunciationID.Append( tmpPronunciation->PronunciationID() );
+ }
+
+ // Find a uniq new id
+ iSIDatabase->BeginTransactionL();
+ pronunciationID = iSILexiconDB->GetNewID( myPronunciationID );
+ iSIDatabase->CommitChangesL( ETrue );
+
+ pronunciation->SetPronunciationID( pronunciationID );
+
+ myPronunciationID.Close();
+ aLexicon->AddL( pronunciation );
+#endif // __SIND_LEXICON_OPT
+ }
+ else
+ {
+ User::LeaveIfError( error );
+#ifdef __SIND_LEXICON_OPT
+ CleanupStack::Pop( pronunciation );
+#endif // __SIND_LEXICON_OPT
+ }
+
+#ifndef __SIND_LEXICON_OPT
+ CleanupStack::Pop( pronunciation );
+#endif // __SIND_LEXICON_OPT
+
+ RUBY_DEBUG1( "CSIControllerPlugin::CreateNewPronunciationL pronunciationID=%x", pronunciationID );
+ return pronunciationID;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::UpdateGrammarAndLexiconDBL
+// Save TTP result into the given grammar and lexicon of the plugin database
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::UpdateGrammarAndLexiconDBL( CSITtpWordList* aSITtpWordList,
+ TSILexiconID aLexiconID,
+ TSIGrammarID aGrammarID,
+ RArray<TSIRuleID>& aRuleIDs )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::UpdateGrammarAndLexiconDBL" );
+ CleanupClosePushL( aRuleIDs );
+
+ iSITtpWordList = aSITtpWordList;
+ iLexiconID = aLexiconID;
+ iGrammarID = aGrammarID;
+ iRuleIDs = &aRuleIDs;
+
+ aRuleIDs.Reset();
+
+ iSIDatabase->BeginTransactionL();
+
+ // is grammar already in database?
+ iSIGrammarDB->VerifyOwnershipL( iClientUid, KGrammarIdTable, KGrammarIndex, iGrammarID );
+ CSICompiledGrammar* aGrammar = (CSICompiledGrammar* )iSIGrammarDB->GrammarL( iGrammarID );
+ CleanupStack::PushL( aGrammar );
+
+ //is lexicion already in database?
+ iSILexiconDB->VerifyOwnershipL( iClientUid, KLexiconIdTable, KLexiconIndex, iLexiconID );
+ CSILexicon* aLexicon = iSILexiconDB->LexiconL( iLexiconID );
+ CleanupStack::PushL( aLexicon );
+
+ iSIDatabase->CommitChangesL( EFalse );
+
+
+ // unpack the iSITtpWordList;
+ for ( TInt i = 0; i < iSITtpWordList->Count(); i++ )
+ {
+ //iSIDatabase->BeginTransactionL();
+ // Get pronunciations
+ RPointerArray<CSIPronunciationInfo> pronunciations;
+ RArray<TSIPronunciationID> pronunciationIDs;
+ CleanupClosePushL( pronunciationIDs );
+ CleanupClosePushL( pronunciations );
+ iSITtpWordList->GetPronunciationsL( i, pronunciations );
+
+ RUBY_DEBUG1( "CSIControllerPlugin::UpdateGrammarAndLexiconDBL pronunciations.Count=%d", pronunciations.Count() );
+
+ // if pronunciation generation failed, skip that word.
+ if ( pronunciations.Count() == 0 )
+ {
+ CleanupStack::PopAndDestroy( &pronunciations );
+ CleanupStack::PopAndDestroy( &pronunciationIDs );
+ User::LeaveIfError( aRuleIDs.Append( KInvalidRuleID ) );
+ continue;
+ }
+
+ // Create a empty rule into grammar, one name -> one rule;
+ TSIRuleID ruleID;
+
+
+ CSIRule* rule=CreateNewRuleL(aGrammar);
+ CleanupStack::PushL( rule );
+ ruleID=rule->RuleID();
+ User::LeaveIfError( aRuleIDs.Append( ruleID ) );
+
+ for(TInt k=0;k<pronunciations.Count();k++)
+ {
+ pronunciationIDs.Reset();
+
+ for ( TInt n = 0; n < pronunciations[k]->Count(); n++ )
+ {
+ // Add Prounication into lexicon
+
+ TSIPronunciationID aPronunciationID = CreateNewPronunciationL( aLexicon,pronunciations[k]->PronunciationL( n ),
+ iModelBankID );
+ User::LeaveIfError( pronunciationIDs.Append( aPronunciationID ) );
+ }
+
+ // Add RuleVariant into grammar
+ AddNewRuleVariantL(*rule, aLexiconID, pronunciationIDs, *pronunciations[k] );
+ }
+
+
+ aGrammar->AddL( rule );
+ CleanupStack::Pop( rule );
+
+ // Close the arrays
+ CleanupStack::PopAndDestroy( &pronunciations );
+ CleanupStack::PopAndDestroy( &pronunciationIDs );
+ }
+
+ RUBY_DEBUG0( "CSIControllerPlugin::UpdateGrammarAndLexiconDBL" );
+
+ iSIDatabase->BeginTransactionL();
+ iSIGrammarDB->UpdateGrammarL( iClientUid,aGrammar );
+ iSILexiconDB->UpdateLexiconL( iClientUid,aLexicon );
+ iSIDatabase->CommitChangesL( ETrue );
+ CleanupStack::PopAndDestroy( 2 ); // aGrammar aLexicon
+
+ CleanupStack::Pop(); //aRuleIDs
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RecognitionReset
+// Terminate recognition session. Free up resources and return to IDLE state.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RecognitionReset()
+ {
+ iSIModelBankDB->ResetAndDestroy();
+ iSILexiconDB->ResetAndDestroy(); // Grcompiler takes the ownership of it
+ iSIGrammarDB->ResetAndDestroy();
+ iState = ESiPluginIdle;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::ProcessTrainCompleteL
+// Training is complete. Store the acoustic model and user utterance into the
+// model bank.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::ProcessTrainCompleteL()
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::ProcessTrainCompleteL" );
+ // No need to train it at all
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::ProcessRecognitionCompleteL
+// Recogntion is complete. Transfer the result from the recognizer into the result
+// object sent by the client.
+// -----------------------------------------------------------------------------
+//
+TInt CSIControllerPlugin::ProcessRecognitionComplete()
+ {
+ RUBY_DEBUG0( "CSIControllerPlugin::ProcessRecognitionComplete" );
+
+ const CSIResult* result = 0;
+ CSIClientResult* clientResult = 0;
+
+ TInt resultsAvailable = iSIResultSet->Count();
+ TInt resultsWanted = iSIClientResultSet->MaxResults();
+ TInt count = Min( resultsAvailable, resultsWanted );
+
+ // Copy the results from the recognizer into client's result set object
+ TInt resCount = 0;
+
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ TRAPD( err, result = &( iSIResultSet->AtL( i ) ) );
+ if ( err )
+ {
+ return 0;
+ }
+ RUBY_DEBUG2( "CSIControllerPlugin::ProcessRecognitionComplete rank(%d): grammarId(%d)", i+1, result->GrammarID() );
+ RUBY_DEBUG2( "CSIControllerPlugin::ProcessRecognitionComplete ruleId(%d), score(%d)", result->RuleID(), result->Score() );
+
+ if ( result->Score() > 0 )
+ {
+ TRAP( err, clientResult = CSIClientResult::NewL( result->GrammarID(),
+ result->RuleID() ) );
+ if ( err )
+ {
+ return 0;
+ }
+ TRAP( err, iSIClientResultSet->AddL( clientResult ) );
+ if ( err )
+ {
+ return 0;
+ }
+ resCount++;
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ iSIClientResultSet->SetResultCount( resCount );
+ return resCount;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::DoCancel
+// Cancel handle from CActive class.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::DoCancel()
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::RunL
+// RunL from CActive class. Check which message got saved and call the
+// appropriate handle function.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::RunL()
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::RunL" );
+ switch ( iRequestFunction )
+ {
+ case KAddRule:
+ TRAP( iResult, HandleAddRuleL( iGrammarID, iLexiconID, iPronunciationID, *iRuleIDPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventAddRule, iResult );
+ break;
+
+ case KCreateGrammar:
+ TRAP( iResult, HandleCreateGrammarL( *iGrammarIDPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventCreateGrammar, iResult );
+ break;
+
+ case KCreateLexicon:
+ TRAP( iResult, HandleCreateLexiconL( *iLexiconIDPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventCreateLexicon, iResult );
+ break;
+
+ case KCreateModelBank:
+ TRAP( iResult, HandleCreateModelBankL( *iModelBankIDPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventCreateModelBank, iResult );
+ break;
+
+ case KGetAllClientGrammarIDs:
+ TRAP( iResult, HandleGetAllClientGrammarIDsL( *iGrammarIDs ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetAllClientGrammarIDs, iResult );
+ break;
+
+ case KGetAllClientLexiconIDs:
+ TRAP( iResult, HandleGetAllClientLexiconIDsL( *iLexiconIDs ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetAllClientLexiconIDs, iResult );
+ break;
+
+ case KGetAllClientModelBankIDs:
+ TRAP( iResult, HandleGetAllClientModelBankIDsL( *iModelBankIDs ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetAllClientModelBankIDs, iResult );
+ break;
+
+ case KGetAllGrammarIDs:
+ TRAP( iResult, HandleGetAllGrammarIDsL( *iGrammarIDs ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetAllGrammarIDs, iResult );
+ break;
+
+ case KGetAllLexiconIDs:
+ TRAP( iResult, HandleGetAllLexiconIDsL( *iLexiconIDs ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetAllLexiconIDs, iResult );
+ break;
+
+ case KGetAllModelBankIDs:
+ TRAP( iResult, HandleGetAllModelBankIDsL( *iModelBankIDs ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetAllModelBankIDs, iResult );
+ break;
+
+ case KGetAllModelIDs:
+ TRAP( iResult, HandleGetAllModelIDsL( iModelBankID, *iModelIDs ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetAllModelIDs, iResult );
+ break;
+
+ case KGetAllPronunciationIDs:
+ TRAP( iResult, HandleGetAllPronunciationIDsL( iLexiconID, *iPronunciationIDs ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetAllPronunciationIDs, iResult );
+ break;
+
+ case KGetAllRuleIDs:
+ TRAP( iResult, HandleGetAllRuleIDsL( iGrammarID, *iRuleIDs ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetAllRuleIDs, iResult );
+ break;
+
+ case KGetAvailableStorage:
+ TRAP( iResult, HandleGetAvailableStorageL( *iCountPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetAvailableStorage, iResult );
+ break;
+
+ case KGetModelCount:
+ TRAP( iResult, HandleGetModelCountL( iModelBankID, *iCountPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetModelCount, iResult );
+ break;
+
+ case KGetPronunciationCount:
+ TRAP( iResult, HandleGetPronunciationCountL( iLexiconID, *iCountPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetPronunciationCount, iResult );
+ break;
+
+ case KGetRuleCount:
+ TRAP( iResult, HandleGetRuleCountL( iGrammarID, *iCountPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetRuleCount, iResult );
+ break;
+ case KGetRuleValidity:
+ TRAP( iResult, HandleGetRuleValidityL( iGrammarID, iRuleID, *iValidPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetRuleValidity, iResult );
+ break;
+
+ case KGetUtteranceDuration:
+ TRAP( iResult, HandleGetUtteranceDurationL( iModelBankID, iModelID, *iDurationPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventGetUtteranceDuration, iResult );
+ break;
+
+ case KLoadGrammar:
+ TRAP( iResult, HandleLoadGrammarL( iGrammarID ) );
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KLoadGrammar. HandleLoadGrammarL Left with error [%d]", iResult );
+ // iGrammarDB needs to be reset also since multiple grammars can
+ // be loaded and this may not be the first grammar.
+ iSIModelBankDB->ResetAndDestroy();
+ iSILexiconDB->ResetAndDestroy();
+ iSIGrammarDB->ResetAndDestroy();
+ iState = ESiPluginIdle;
+ iControllerIf.SendSrsEvent( KUidAsrEventLoadGrammar, iResult );
+ }
+ break;
+
+ case KLoadLexicon:
+ TRAP(iResult, HandleLoadLexiconL( iLexiconID ) );
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KLoadLexicon. HandleLoadGrammarL Left with error [%d]", iResult );
+
+ // iLexiconDB needs to be reset also since multiple lexicons can
+ // be loaded and this may not be the first lexicon.
+ iSIModelBankDB->ResetAndDestroy();
+ iSILexiconDB->ResetAndDestroy();
+ iState = ESiPluginIdle;
+ iControllerIf.SendSrsEvent( KUidAsrEventLoadLexicon, iResult );
+ }
+ break;
+
+ case KLoadModels:
+ TRAP(iResult, HandleLoadModelsL( iModelBankID ) );
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KLoadModels. HandleLoadGrammarL Left with error [%d]", iResult );
+
+ if ( iResult == KErrCorrupt )
+ {
+ RUBY_DEBUG0( "CSIControllerPlugin::RunL. KLoadModels. Try to update models" );
+ TRAP( iResult,
+ iSIModelBankDB->UpdateModelBankIfInvalidL( iModelBankID );
+ HandleLoadModelsL( iModelBankID );
+ );
+ }
+
+ if ( iResult != KErrNone )
+ {
+ // iModelBankDB needs to be reset also since multiple model banks can
+ // be loaded and this may not be the first model bank.
+ iSIModelBankDB->ResetAndDestroy();
+ iState = ESiPluginIdle;
+
+ iControllerIf.SendSrsEvent( KUidAsrEventLoadModels, iResult );
+ }
+ }
+ break;
+
+ case KRecognize:
+ TRAP( iResult, HandleRecognizeL() );
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KRecognize. HandleLoadGrammarL Left with error [%d]", iResult );
+
+ if ( iResult != KErrAsrNoMatch )
+ {
+ RecognitionReset();
+ }
+ iControllerIf.SendSrsEvent( KUidAsrEventRecognition, iResult );
+ }
+ break;
+
+ case KRecord:
+ TRAP( iResult, HandleRecordL( iRecordTime ) );
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KRecord. HandleLoadGrammarL Left with error [%d]", iResult );
+
+ iControllerIf.SendSrsEvent( KUidAsrEventRecord, iResult );
+ }
+ break;
+
+ case KRemoveGrammar:
+ TRAP( iResult, HandleRemoveGrammarL( iGrammarID ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveGrammar, iResult );
+ break;
+
+ case KRemoveLexicon:
+ TRAP( iResult, HandleRemoveLexiconL( iLexiconID ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveLexicon, iResult );
+ break;
+
+ case KRemoveModelBank:
+ TRAP( iResult, HandleRemoveModelBankL( iModelBankID ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveModelBank, iResult );
+ break;
+
+ case KRemoveModel:
+ TRAP( iResult, HandleRemoveModelL( iModelBankID, iModelID ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveModel, iResult );
+ break;
+
+ case KRemovePronunciation:
+ TRAP( iResult, HandleRemovePronunciationL( iLexiconID, iPronunciationID ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventRemovePronunciation, iResult );
+ break;
+
+ case KRemoveRule:
+ TRAP( iResult, HandleRemoveRuleL( iGrammarID, iRuleID ) );
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KRemoveRule. HandleLoadGrammarL Left with error [%d]", iResult );
+
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveRule, iResult );
+ }
+ break;
+ case KRemoveRules:
+ TRAP( iResult, HandleRemoveRulesL( iGrammarID, *iRuleIDs ) );
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KRemoveRules. HandleLoadGrammarL Left with error [%d]", iResult );
+
+ iControllerIf.SendSrsEvent( KUidAsrEventRemoveRules, iResult );
+ }
+ break;
+
+ case KTrain:
+ TRAP( iResult, HandleTrainL( iModelBankID ) );
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KTrain. HandleLoadGrammarL Left with error [%d]", iResult );
+
+ iControllerIf.SendSrsEvent( KUidAsrEventTrain, iResult );
+ }
+ break;
+
+ case KUnloadRule:
+ TRAP( iResult, HandleUnloadRuleL(iGrammarID, iRuleID));
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KUnloadRule. HandleLoadGrammarL Left with error [%d]", iResult );
+
+ iControllerIf.SendSrsEvent( KUidAsrEventUnloadRule, iResult );
+ }
+ break;
+
+
+ // SI Component
+ case KAdapt:
+ TRAP( iResult, HandleAdaptL(*iSIClientResultSet ,iCorrect)) ;
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KAdapt. HandleLoadGrammarL Left with error [%d]", iResult );
+
+ iControllerIf.SendSrsEvent( KUidAsrEventAdapt , iResult );
+ }
+ break;
+ /* case KSIAddPronunciation:
+ TRAP(iResult, HandleAddPronunciationL(iLexiconID, iTrainTextPtr,
+ iLanguage, iPronunciationIDPtr)) ;
+ iControllerIf.SendSrsEvent(KUidAsrEventAddPronunciation, iResult);
+ break;
+ */
+ case KAddRuleVariant:
+ TRAP( iResult, HandleAddRuleVariantL( iGrammarID, iLexiconID, *iPronunciationIDs, iRuleID, *iRuleVariantIDPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventAddRuleVariant, iResult );
+ break;
+ /*
+ case KAddVoiceTag:
+ TRAP(iResult, HandleAddVoiceTagL( *iTrainArray, *iLanguageArray,
+ iLexiconID, iGrammarID, iRuleIDPtr)) ;
+ iControllerIf.SendSrsEvent(KUidAsrEventAddVoiceTag, iResult);
+ break;
+ */
+ case KAddVoiceTags:
+ TRAP( iResult, HandleAddVoiceTagsL( iTrainArrays, *iLanguageArray, iLexiconID,
+ iGrammarID /* ,*iRuleIDs */) );
+ // AddVoiceTags contain several async functions,
+ // KUidAsrEventAddVoiceTags will be sent when the AddVoiceTags complete
+ if ( iResult != KErrNone )
+ {
+ RUBY_DEBUG1( "CSIControllerPlugin::RunL. KAddVoiceTags. HandleLoadGrammarL Left with error [%d]", iResult );
+
+ // Clean up the iTrainArrays
+ if ( iTrainArrays )
+ {
+ iTrainArrays->ResetAndDestroy();
+ iTrainArrays->Close();
+ delete iTrainArrays;
+ iTrainArrays = NULL;
+ }
+ // Send error message
+ iControllerIf.SendSrsEvent( KUidAsrEventAddVoiceTags, iResult );
+ }
+ iTrainArrays = NULL;
+ break;
+
+#ifdef __SINDE_TRAINING
+ case KAddSindeVoiceTags:
+ RUBY_DEBUG0( "CSIControllerPlugin::RunL KAddSindeVoiceTags" );
+
+#ifdef _DEBUG
+ for ( TInt i = 0; i < iLanguageArrayArray->Count(); i++ )
+ {
+ RUBY_DEBUG1( "Contents of element %d:", i );
+ RLanguageArray langArr = (*iLanguageArrayArray)[i];
+ for ( TInt j = 0; j < langArr.Count(); j++ )
+ {
+ RUBY_DEBUG2( "Index: %d Language: %d", j, langArr[j] );
+ }
+ }
+#endif // _DEBUG
+
+ TRAP( iResult, HandleAddSindeVoiceTagsL( iTrainArrays, *iLanguageArrayArray, iLexiconID, iGrammarID ) );
+
+ if ( iResult != KErrNone )
+ {
+ iTrainArrays->ResetAndDestroy();
+ iTrainArrays->Close();
+ delete iTrainArrays;
+ iTrainArrays = NULL;
+
+ // Send error message
+ iControllerIf.SendSrsEvent( KUidAsrEventAddVoiceTags, iResult );
+ }
+ iTrainArrays = NULL;
+ break;
+#endif
+ case KCreateRule:
+ TRAP(iResult, HandleCreateRuleL( iGrammarID,*iRuleIDPtr ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventCreateRule, iResult );
+ break;
+ /* case KSIRecognize:
+ TRAP(iResult, HandleRecognizeL(*(CSIClientResultSet*)iSIClientResultSet)) ;
+ // iControllerIf.SendSrsEvent(KUidAsrEventSIRecognize, iResult);
+ break;
+ */
+ case KEndRecord:
+ TRAP( iResult, HandleEndRecordL( ) );
+ iControllerIf.SendSrsEvent( KUidAsrEventEndRecord, iResult );
+ break;
+ case KUnloadGrammar:
+ TRAP( iResult, HandleUnloadGrammarL( iGrammarID ) ) ;
+ // UnloadGrammar contain several async functions,
+ // KUidAsrEventUnloadGrammar will be sent when the UnloadGrammar complete
+ //iControllerIf.SendSrsEvent(KUidAsrEventUnloadGrammar, iResult);
+ break;
+ /*case KUpdateGrammarAndLexicon:
+ TRAP(iResult, HandleUpdateGrammarAndLexiconL(iSITtpWordList,iLexiconID,iGrammarID,*iRuleIDs));
+ iControllerIf.SendSrsEvent(KUidAsrEventUpdateGrammarAndLexicon, iResult);
+
+ break;
+ */
+
+ case KPreStartSampling:
+ TRAP( iResult, HandlePreStartSamplingL() );
+ iControllerIf.SendSrsEvent( KUidAsrEventPreStartSampling, iResult );
+ break;
+
+ default:
+ // No action
+ break;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::DoAsynch
+// This method completes the request status and set the object active
+// to provide asynchronous behavior.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::DoAsynch()
+ {
+ TRequestStatus* pRS = &iStatus;
+ User::RequestComplete( pRS, KErrNone );
+ SetActive();
+ }
+
+// ============================SI MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AdaptL
+// Calls the devasr for adaptation
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AdaptL( CSIClientResultSet& aResultSet ,TInt aCorrect )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AdaptL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KAdapt;
+
+ iSIClientResultSet = &aResultSet;
+ iCorrect = aCorrect;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleAdaptL
+// Calls the devasr for adaptation
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleAdaptL( CSIClientResultSet& aResultSet,
+ TInt aCorrect )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleAdaptL" );
+ if ( iState == ESiPluginRecognize )
+ {
+ iSIDatabase->BeginTransactionL();
+ if ( iSIGrammarDB->IsGrammarLoaded() )
+
+ {
+ iDevASR->AdaptL( aResultSet.SIResultSet(), aCorrect );
+ }
+ else
+ {
+ // Either the loaded grammars are empty (contains no rule) or
+ // all rules have been unloaded. No need to proceed any further.
+ iSIDatabase->CommitChangesL( EFalse );
+
+ User::Leave( KErrAsrNoMatch );
+ }
+
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+ else
+ {
+ // Wrong state
+ User::Leave( KErrAsrInvalidState );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AddPronunciationL
+// Adds a new pronunciation for the given model into the specified lexicon.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AddPronunciationL( TSILexiconID /*aLexiconID*/,
+ const TDesC& /*aTrainText*/,
+ TLanguage /*aLanguage*/,
+ TSIPronunciationID& /*aPronunciationID*/)
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AddPronunciationL" );
+ User::Leave( KErrNotSupported );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AddRuleVariantLtionL
+// Adds a new rule variant for the given pronunciation into the specified grammar.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AddRuleVariantL( TSIGrammarID aGrammarID,
+ TSILexiconID aLexiconID,
+ RArray<TSIPronunciationID>& aPronunciationIDs,
+ TSIRuleID aRuleID,
+ TSIRuleVariantID& aRuleVariantID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::AddRuleVariantL");
+
+ if ( IsActive() )
+ {
+ User::Leave(KErrServerBusy);
+ }
+ iRequestFunction = KAddRuleVariant;
+ iGrammarID = aGrammarID;
+ iRuleID = aRuleID;
+ iLexiconID = aLexiconID;
+ iRuleVariantIDPtr = &aRuleVariantID;
+ iPronunciationIDs = &aPronunciationIDs;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleAddRuleVariantL
+// Adds a new rule variant for the given pronunciation into the specified grammar.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleAddRuleVariantL( TSIGrammarID aGrammarID,
+ TSILexiconID aLexiconID,
+ RArray<TSIPronunciationID>& aPronunciationIDs,
+ TSIRuleID aRuleID,
+ TSIRuleVariantID& aRuleVariantID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleAddRuleVariantL" );
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ iSIGrammarDB->AddRuleVariantL( iClientUid, aGrammarID, aLexiconID,
+ aPronunciationIDs, aRuleID, aRuleVariantID );
+ iSIDatabase->CommitChangesL( ETrue );
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AddVoiceTagL
+// Trains a new voice tag.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AddVoiceTagL( MDesCArray& /*aTrainArray*/,
+ RArray<TLanguage>& /*aLanguageArray*/,
+ TSILexiconID /*aLexiconID*/,
+ TSIGrammarID /*aGrammarID*/,
+ TSIRuleID& /*aRuleID*/)
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AddVoiceTagL" );
+ User::Leave( KErrNotSupported );
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AddVoiceTagsL
+// Adds several new voice tags.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AddVoiceTagsL( RPointerArray<MDesCArray>& aTrainArrays,
+ RArray<TLanguage>& aLanguageArray,
+ TSILexiconID aLexiconID,
+ TSIGrammarID aGrammarID,
+ RArray<TSIRuleID>& aRuleIDs)
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::AddVoiceTagsL");
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+
+ // Use low priority for training (if training is not done from Voice Commands app)
+ if ( RProcess().SecureId() != KVoiceCommandsAppUid )
+ {
+ RThread().SetPriority( EPriorityAbsoluteLow );
+ }
+
+ iState = ESiPluginTrainText;
+ // iTtpState=EAddVoiceTags;
+
+ iRequestFunction = KAddVoiceTags ;
+ iLexiconID= aLexiconID;
+ iGrammarID = aGrammarID;
+
+ iRuleIDs = &aRuleIDs;
+ iLanguageArray = &aLanguageArray;
+ iTrainArrays = &aTrainArrays;
+
+ DoAsynch();
+ }
+
+#ifdef __SINDE_TRAINING
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AddSindeVoiceTagL
+// Trains a new voice tag.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AddSindeVoiceTagL( MDesCArray& /*aTrainArray*/,
+ RArray<RLanguageArray>& /*aLanguageArray*/,
+ TSILexiconID /*aLexiconID*/,
+ TSIGrammarID /*aGrammarID*/,
+ TSIRuleID& /*aRuleID*/ )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AddSindeVoiceTagL" );
+ User::Leave( KErrNotSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::AddSindeVoiceTagsL
+// Adds several new voice tags.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::AddSindeVoiceTagsL( RPointerArray<MDesCArray>& aTrainArrays,
+ RArray<RLanguageArray>& aLanguageArray,
+ TSILexiconID aLexiconID,
+ TSIGrammarID aGrammarID,
+ RArray<TSIRuleID>& aRuleIDs )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::AddSindeVoiceTagsL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+
+ // Use low priority for training (if training is not done from Voice Commands app)
+ if ( RProcess().SecureId() != KVoiceCommandsAppUid )
+ {
+ RThread().SetPriority( EPriorityAbsoluteLow );
+ }
+
+ iState = ESiPluginTrainSinde;
+
+ iRequestFunction = KAddSindeVoiceTags;
+ iLexiconID = aLexiconID;
+ iGrammarID = aGrammarID;
+
+ // Store parameters for asynchronous processing
+ iRuleIDs = &aRuleIDs;
+ iLanguageArrayArray = &aLanguageArray;
+ iTrainArrays = &aTrainArrays;
+
+ DoAsynch();
+ }
+#endif // __SINDE_TRAINING
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleAddVoiceTagsL
+// Adds several new voice tags.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleAddVoiceTagsL( RPointerArray<MDesCArray>* aTrainArrays,
+ RArray<TLanguage>& aLanguageArray,
+ TSILexiconID aLexiconID,
+ TSIGrammarID aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK("CSIControllerPlugin::HandleAddVoiceTagsL");
+ //
+ // first test if both KLexiconID lexicon and KGrammarID are created
+ if ( IsLexiconIDInvalid( aLexiconID ) || IsGrammarIDInvalid( aGrammarID ) )
+ {
+ User::Leave( KErrNotFound ); // no such grammar exist in Database
+ }
+ // Need to clean the iSITtpWordList before adding new arrays
+ delete iSITtpWordList;
+ iSITtpWordList = NULL;
+ iSITtpWordList = CSITtpWordList::NewL();
+ if ( iState == ESiPluginTrainText )
+ {
+ for ( TInt i=0; i < aTrainArrays->Count(); i++ )
+ {
+ iSITtpWordList->AddL( ( *aTrainArrays )[i] );
+ // If next AddL fails, we must not delete the objects twice - once in
+ // aTrainArray->ResetAndDestroy() and second time in ~CSITtpWordList.
+ ( *aTrainArrays )[i] = NULL;
+ }
+ aTrainArrays->ResetAndDestroy();
+ aTrainArrays->Close();
+ delete aTrainArrays;
+ aTrainArrays = NULL;
+
+ // Set Max prnounication per word
+ iMaxNPronunsForWord.Reset();
+ iMaxNPronunsForWord.Append( aLanguageArray.Count() );
+
+ RUBY_DEBUG1( "CSIControllerPlugin::AddVoiceTagsL(aLanguageArray.Count=%d)", aLanguageArray.Count() );
+
+ iDevASR->StartTrainingFromTextL(*iSITtpWordList,aLanguageArray,iMaxNPronunsForWord);
+ }
+ else
+ {
+ // Wrong state
+ User::Leave( KErrAsrInvalidState );
+ }
+ }
+
+#ifdef __SINDE_TRAINING
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleAddVoiceTagsL
+// Adds several new voice tags.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleAddSindeVoiceTagsL( RPointerArray<MDesCArray>* aTrainArrays,
+ RArray<RLanguageArray>& aLanguageArray,
+ TSILexiconID aLexiconID,
+ TSIGrammarID aGrammarID )
+ {
+ // First test if both KLexiconID lexicon and KGrammarID are created
+ if ( IsLexiconIDInvalid( aLexiconID ) || IsGrammarIDInvalid( aGrammarID ) )
+ {
+ User::Leave( KErrNotFound ); // no such grammar exist in Database
+ }
+
+ iSindeTrainer->AddSindeVoiceTagsL( aTrainArrays, aLanguageArray,
+ aLexiconID, aGrammarID, iModelBankID,
+ iClientUid, *iRuleIDs );
+
+ }
+#endif // __SINDE_TRAINING
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::IsGrammarIDInvalid
+// is the grammar id valid in the database
+// -----------------------------------------------------------------------------
+//
+TBool CSIControllerPlugin::IsGrammarIDInvalid( TSIGrammarID aGrammarID )
+ {
+ TInt i(0);
+ RArray<TSIGrammarID> aGrammarIDs;
+
+ TRAPD( error,
+ iSIDatabase->BeginTransactionL();
+ iSIGrammarDB->GetAllGrammarIDsL( aGrammarIDs );
+ iSIDatabase->CommitChangesL( EFalse );
+ ); // TRAPD
+
+ if ( error == KErrNone )
+ {
+ for( i = 0; i < aGrammarIDs.Count(); i++ )
+ {
+ if ( aGrammarIDs[i] == aGrammarID )
+ {
+ break;
+ }
+ if ( i == aGrammarIDs.Count() )
+ {
+ aGrammarIDs.Close();
+ return ETrue; // no such Lexicon exist in Database
+ }
+ }
+ }
+ aGrammarIDs.Close();
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::IsLexiconIDInvalid
+// is the lexicon id valid in the database
+// -----------------------------------------------------------------------------
+//
+TBool CSIControllerPlugin::IsLexiconIDInvalid( TSILexiconID aLexiconID )
+ {
+ // first test if both KLexiconID lexicon and KLexiconID are created
+ TInt i(0);
+ RArray<TSILexiconID> aLexiconIDs;
+
+ TRAPD( error,
+ iSIDatabase->BeginTransactionL();
+ iSILexiconDB->GetAllLexiconIDsL( aLexiconIDs );
+ iSIDatabase->CommitChangesL( EFalse );
+ ); //TRAPD
+
+ if ( error == KErrNone )
+ {
+ for( i = 0; i < aLexiconIDs.Count(); i++ )
+ {
+ if ( aLexiconIDs[i] == aLexiconID )
+ {
+ break;
+ }
+ if ( i == aLexiconIDs.Count() )
+ {
+ aLexiconIDs.Close();
+ return ETrue; // no such Lexicon exist in Database
+ }
+ }
+ }
+
+ aLexiconIDs.Close();
+ return EFalse;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::CreateRuleL
+// Creates a new empty rule.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::CreateRuleL( TSIGrammarID aGrammarID,
+ TSIRuleID& aRuleID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::CreateRuleL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KCreateRule ;
+ iGrammarID = aGrammarID;
+ iRuleIDPtr= &aRuleID;
+
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleCreateRuleL
+// Creates a new empty rule.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleCreateRuleL( TSIGrammarID aGrammarID,
+ TSIRuleID& aRuleID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleCreateRuleL" );
+ if ( iClientRegistered )
+ {
+ iSIDatabase->BeginTransactionL();
+ iSIGrammarDB->CreateRuleL( iClientUid, aGrammarID, aRuleID );
+ iSIDatabase->CommitChangesL( EFalse );
+ }
+ else
+ {
+ User::Leave( KErrAsrNotRegisted );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::EndRecordL
+// End recordingEnds recording. Unlike Cancel(), this function may return a
+// recognition result if adequate number of samples was already recorded.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::EndRecordL()
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::EndRecordL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KEndRecord ;
+ DoAsynch();
+}
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleEndRecordL
+// End recordingEnds recording. Unlike Cancel(), this function may return a
+// recognition result if adequate number of samples was already recorded.
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleEndRecordL()
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleEndRecordL" );
+ iDevASR->EndRecord();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::UnloadGrammarL
+// Unload a grammar from memory
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::UnloadGrammarL( TSIGrammarID aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::UnloadGrammarL" );
+
+ if ( IsActive() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iRequestFunction = KUnloadGrammar ;
+ iGrammarID=aGrammarID;
+ DoAsynch();
+ }
+
+// -----------------------------------------------------------------------------
+// CSIControllerPlugin::HandleUnloadGrammarL
+// Unload a grammar from memory
+// -----------------------------------------------------------------------------
+//
+void CSIControllerPlugin::HandleUnloadGrammarL( TSIGrammarID aGrammarID )
+ {
+ RUBY_DEBUG_BLOCK( "CSIControllerPlugin::HandleUnloadGrammarL" );
+
+ iSIDatabase->BeginTransactionL();
+ CSICompiledGrammar* LoadedGrammar =iSIGrammarDB->FindGrammarL( aGrammarID );
+ iSIDatabase->CommitChangesL( EFalse );
+
+ iDevASR->UnloadGrammar( *LoadedGrammar ); // async call to unload grammar in devasr
+ }
+
+// End of File