--- a/srsf/sisrscontrollerplugin/src/sicontrollerplugin.cpp Thu Aug 19 09:56:14 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,3929 +0,0 @@
-/*
-* 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