|
1 /* |
|
2 * Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: This is the main implementation of the SI Controller Plugin. |
|
15 * Finite State Machine is implemented here. |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 #ifndef SICONTROLLERPLUGIN_H |
|
21 #define SICONTROLLERPLUGIN_H |
|
22 |
|
23 // ============================================================================ |
|
24 // Uncomment the following directive for Bit Exact Testing. |
|
25 // ============================================================================ |
|
26 // |
|
27 |
|
28 // INCLUDES |
|
29 #include "srsfbldvariant.hrh" |
|
30 #include <nsssispeechrecognitiondataclient.h> |
|
31 #include <nsssispeechrecognitiondatacommon.h> |
|
32 #include <nssdevasr.h> |
|
33 #include <d32dbms.h> |
|
34 |
|
35 // FORWARD DECLARATIONS |
|
36 class CSIControllerPluginInterface; |
|
37 class CDevASR; |
|
38 class CSIResourceHandler; |
|
39 class CSDClientResultSet; |
|
40 |
|
41 class CSIGrammarDB; |
|
42 class CSIModelBankDB; |
|
43 class CSILexiconDB; |
|
44 class CDataLoader; |
|
45 class CSIDatabase; |
|
46 |
|
47 #ifdef __SINDE_TRAINING |
|
48 class CSindeTrainer; |
|
49 #endif // __SINDE_TRAINING |
|
50 |
|
51 // CLASS DECLARATION |
|
52 |
|
53 /** |
|
54 * This is the main class of SI Controller Plugin |
|
55 * |
|
56 * @lib SIControllerPlugin.lib |
|
57 * @since 2.0 |
|
58 */ |
|
59 class CSIControllerPlugin : public CActive, public MDevASRObserver |
|
60 { |
|
61 public: // Constructors and destructor |
|
62 |
|
63 /** |
|
64 * Two-phased constructor. CSIControllerPluginInterface& aControllerIf |
|
65 */ |
|
66 static CSIControllerPlugin* NewL( CSIControllerPluginInterface& aControllerInterface ); |
|
67 |
|
68 /** |
|
69 * Destructor. |
|
70 */ |
|
71 virtual ~CSIControllerPlugin(); |
|
72 |
|
73 public: // Functions from base classes |
|
74 |
|
75 /** |
|
76 * From MDevASRObserver |
|
77 * Spontaneous or non-spontaneous event received from DevASR. |
|
78 * @since 2.0 |
|
79 * @param aEvent event code |
|
80 * @param aError error code |
|
81 */ |
|
82 void DevASREvent( TDevASREvent aEvent, TDevASRError aError ); |
|
83 |
|
84 /** |
|
85 * From MDevASRObserver |
|
86 * Notification from DevASR when feature vectors are available. |
|
87 * @since 2.0 |
|
88 * @param aFV buffer containing the feature vector data |
|
89 * @param aSNR signal-to-noise ratio |
|
90 * @param aPosition indicates whether the feature vector is the first, middle, or end. |
|
91 */ |
|
92 void FeatureVectorDataRcvd( const TDesC8& aFV, TInt32 aSNR, TInt32 aPosition ); |
|
93 |
|
94 /** |
|
95 * From MDevASRObserver |
|
96 * A message in response to a custom command. |
|
97 * @since 2.0 |
|
98 * @param aMsg buffer containing the message |
|
99 */ |
|
100 void DevASRMessage( TDesC8& aMsg ); |
|
101 |
|
102 /** |
|
103 * From MDevASRObserver |
|
104 * DevASR calls this method to get lexicon data. |
|
105 * @since 2.8 |
|
106 * @param anID lexicon ID |
|
107 * @return Lexicon object |
|
108 */ |
|
109 CSILexicon* SILexiconL( TSILexiconID anID ); |
|
110 |
|
111 /** |
|
112 * DevASR calls this method to get configuration data. |
|
113 * |
|
114 * @since 2.8 |
|
115 * @param "TUint32 aPackageType" Type identifier. |
|
116 * @param "TUint32 aPackageID" Identifier of package. |
|
117 * @param "TUint32 aStartPosition" Starting position within package in bytes. |
|
118 * @param "TUint32 aEndPosition" Ending position within package in bytes. |
|
119 * @return Pointer to created buffer containing the request data. |
|
120 */ |
|
121 HBufC8* ConfigurationData( TUint32 aPackageType, |
|
122 TUint32 aPackageID, |
|
123 TUint32 aStartPosition, |
|
124 TUint32 aEndPosition ); |
|
125 |
|
126 /** |
|
127 * Get speech data from audio buffer |
|
128 * |
|
129 * @since 2.8 |
|
130 */ |
|
131 void RequestSpeechData(); |
|
132 |
|
133 #ifdef DEVASR_KEEP_SD |
|
134 CSDLexicon* SDLexiconL( TSILexiconID anID ) ; |
|
135 #endif |
|
136 |
|
137 public: // New functions |
|
138 |
|
139 /** |
|
140 * Adds a new pronunciation for the given model into the specified lexicon. |
|
141 * @since 2.0 |
|
142 * @param aLexiconID lexicon Id, where the new pronunciation is added to |
|
143 * @param aModelBankID model bank Id |
|
144 * @param aModelID model Id |
|
145 * @param aPronunciationID reference where a new pronunciation Id is assigned to |
|
146 */ |
|
147 void AddPronunciationL( TSILexiconID aLexiconID, TSIModelBankID aModelBankID, |
|
148 TSIModelID aModelID, TSIPronunciationID& aPronunciationID ); |
|
149 |
|
150 void AddPronunciationL( TSILexiconID aLexiconID, TSIModelBankID aModelBankID, |
|
151 const TDesC8& aPronunciationPr, TSIPronunciationID& aPronunciationID ); |
|
152 |
|
153 /** |
|
154 * Adds a new rule for the given pronunciation into the specified grammar. |
|
155 * @since 2.0 |
|
156 * @param aGrammarID grammar Id, where the new rule is added to |
|
157 * @param aLexiconID lexicon Id |
|
158 * @param aPronunciationID pronunciation Id |
|
159 * @param aRuleID reference where a new rule Id is assigned to |
|
160 */ |
|
161 void AddRuleL( TSIGrammarID aGrammarID, TSILexiconID aLexiconID, |
|
162 TSIPronunciationID aPronunciationID, TSIRuleID& aRuleID ); |
|
163 |
|
164 /** |
|
165 * Cancels the current activity and returns the plugin to Idle state. |
|
166 * @since 2.0 |
|
167 */ |
|
168 void Cancel(); |
|
169 |
|
170 /** |
|
171 * Commits (saves) the current trained model into a permanent storage. |
|
172 * @since 2.0 |
|
173 */ |
|
174 void CommitChangesL( TBool aCompact ); |
|
175 |
|
176 /** |
|
177 * Creates a new grammar. |
|
178 * @since 2.0 |
|
179 * @param aGrammarID reference where a new rule Id is assigned to |
|
180 */ |
|
181 void CreateGrammarL( TSIGrammarID& aGrammarID ); |
|
182 |
|
183 /** |
|
184 * Creates a new lexicon. |
|
185 * @since 2.0 |
|
186 * @param aLexiconID reference where a new lexicon Id is assigned to |
|
187 */ |
|
188 void CreateLexiconL( TSILexiconID& aLexiconID ); |
|
189 |
|
190 /** |
|
191 * Creates a new model bank. |
|
192 * @since 2.0 |
|
193 * @param aModelBankID reference where a new model bank Id is assigned to |
|
194 */ |
|
195 void CreateModelBankL( TSIModelBankID& aModelBankID ); |
|
196 |
|
197 /** |
|
198 * Ends the current recognition session. Resources allocated for recognition are freed. |
|
199 * @since 2.0 |
|
200 * @param - |
|
201 */ |
|
202 void EndRecSessionL(); |
|
203 |
|
204 /** |
|
205 * Returns all grammar Ids that belong to the current client, whose UID was set |
|
206 * with SetClientUidL(). |
|
207 * @since 2.0 |
|
208 * @param aGrammarIDs reference where grammar Ids are stored |
|
209 */ |
|
210 void GetAllClientGrammarIDsL( RArray<TSIGrammarID>& aGrammarIDs ); |
|
211 |
|
212 /** |
|
213 * Returns all lexicon Ids that belong to the current client, whose UID was set |
|
214 * with SetClientUidL(). |
|
215 * @since 2.0 |
|
216 * @param aLexiconIDs reference where lexicon Ids are stored |
|
217 */ |
|
218 void GetAllClientLexiconIDsL( RArray<TSILexiconID>& aLexiconIDs ); |
|
219 |
|
220 /** |
|
221 * Returns all model bank Ids that belong to the current client, whose UID was set |
|
222 * with SetClientUidL(). |
|
223 * @since 2.0 |
|
224 * @param aModelBankIDs reference where model bank Ids are stored |
|
225 */ |
|
226 void GetAllClientModelBankIDsL( RArray<TSIModelBankID>& aModelBankIDs ); |
|
227 |
|
228 /** |
|
229 * Returns all grammar Ids that exist (for all clients). |
|
230 * @since 2.0 |
|
231 * @param aGrammarIDs reference where grammar Ids are stored |
|
232 */ |
|
233 void GetAllGrammarIDsL( RArray<TSIGrammarID>& aGrammarIDs ); |
|
234 |
|
235 /** |
|
236 * Returns all lexicon Ids that exist (for all clients). |
|
237 * @since 2.0 |
|
238 * @param aLexiconIDs reference where lexicon Ids are stored |
|
239 */ |
|
240 void GetAllLexiconIDsL( RArray<TSILexiconID>& aLexiconIDs ); |
|
241 |
|
242 /** |
|
243 * Returns all model bank Ids that exist (for all clients). |
|
244 * @since 2.0 |
|
245 * @param aModelBankIDs reference where model bank Ids are stored |
|
246 */ |
|
247 void GetAllModelBankIDsL( RArray<TSIModelBankID>& aModelBankIDs ); |
|
248 |
|
249 /** |
|
250 * Returns all model Ids that exist in the specified model bank. |
|
251 * @since 2.0 |
|
252 * @param aModelBankID model bank Id |
|
253 * @param aModelIDs reference where model Ids are stored |
|
254 */ |
|
255 void GetAllModelIDsL( TSIModelBankID aModelBankID, RArray<TSIModelID>& aModelIDs ); |
|
256 |
|
257 /** |
|
258 * Returns all pronunciation Ids that exist in the specified lexicon. |
|
259 * @since 2.0 |
|
260 * @param aLexiconID lexicon Id |
|
261 * @param aPronunciationIDs reference where pronunciation Ids are stored |
|
262 */ |
|
263 void GetAllPronunciationIDsL( TSILexiconID aLexiconID, |
|
264 RArray<TSIPronunciationID>& aPronunciationIDs ); |
|
265 |
|
266 /** |
|
267 * Returns all rule Ids that exist in the specified grammar. |
|
268 * @since 2.0 |
|
269 * @param aGrammarID grammar Id |
|
270 * @param aRuleIDs reference where rule Ids are stored |
|
271 */ |
|
272 void GetAllRuleIDsL( TSIGrammarID aGrammarID, RArray<TSIRuleID>& aRuleIDs ); |
|
273 |
|
274 /** |
|
275 * Returns the number of models available for training system wide, based on |
|
276 * available disk space. |
|
277 * @since 2.0 |
|
278 * @param aCount reference where the number of available models is set |
|
279 */ |
|
280 void GetAvailableStorageL( TInt& aCount ); |
|
281 |
|
282 /** |
|
283 * Returns the engine properties specified by the engine property ID array. |
|
284 * On return aPropertyValue contains an array of engine properties. |
|
285 * @since 2.0 |
|
286 * @param aPropertyId constant reference to array of engine property Ids |
|
287 * @param aPropertyValue reference to array of engine property values |
|
288 */ |
|
289 void GetEnginePropertiesL( const RArray<TInt>& aPropertyId, |
|
290 RArray<TInt>& aPropertyValue ); |
|
291 |
|
292 /** |
|
293 * Returns the number of models in the specified model bank. |
|
294 * @since 2.0 |
|
295 * @param aModelBankID model bank Id |
|
296 * @param aCount reference where the number of models is set |
|
297 */ |
|
298 void GetModelCountL( TSIModelBankID aModelBankID, TInt& aCount ); |
|
299 |
|
300 /** |
|
301 * Returns the number of pronunciationin the specified lexicon. |
|
302 * @since 2.0 |
|
303 * @param aLexiconID lexicon Id |
|
304 * @param aCount reference where the number of models is set |
|
305 */ |
|
306 |
|
307 void GetPronunciationCountL(TSILexiconID aLexiconID, TInt& aCount ); |
|
308 |
|
309 /** |
|
310 * Returns the number of rules in the specified grammar. |
|
311 * @since 2.0 |
|
312 * @param aGrammarID Grammar Id |
|
313 * @param aCount reference where the number of models is set |
|
314 */ |
|
315 void GetRuleCountL(TSIGrammarID aGrammarID, TInt& aCount ); |
|
316 |
|
317 /** |
|
318 * Checks if the rule is valid or not. |
|
319 * @since 2.0 |
|
320 * @param aGrammarID grammar Id |
|
321 * @param aRuleID rule Id |
|
322 * @param aValid reference where the validity of the rule is set |
|
323 */ |
|
324 void GetRuleValidityL( TSIGrammarID aGrammarID, TSIRuleID aRuleID, TBool& aValid ); |
|
325 |
|
326 /** |
|
327 * Returns the duration of the utterance for the specified model. |
|
328 * @since 2.0 |
|
329 * @param aModelBankID model bank Id |
|
330 * @param aModelID model Id |
|
331 * @param aDuration reference where the duration of utterance is set |
|
332 */ |
|
333 void GetUtteranceDurationL( TSIModelBankID aModelBankID, TSIModelID aModelID, |
|
334 TTimeIntervalMicroSeconds32& aDuration ); |
|
335 |
|
336 /** |
|
337 * Loads the specified recognizer parameter(s). These parameters are used to |
|
338 * alter the recognizer's default parameters. The parameters are specified as |
|
339 * attribute and value pairs. |
|
340 * @since 2.0 |
|
341 * @param aParameterID list of parameter Ids |
|
342 * @param aParameterValue list of parameter values |
|
343 */ |
|
344 void LoadEngineParametersL( const RArray<TInt>& aParameterId, |
|
345 const RArray<TInt>& aParameterValue ); |
|
346 |
|
347 /** |
|
348 * Loads the specified grammar into the recognizer; done prior to recognition. |
|
349 * @since 2.0 |
|
350 * @param aGrammarID grammar Id |
|
351 */ |
|
352 void LoadGrammarL( TSIGrammarID aGrammarID ); |
|
353 |
|
354 /** |
|
355 * Loads the specified lexicon into the recognizer; done prior to recognition. |
|
356 * @since 2.0 |
|
357 * @param aLexiconID lexicon Id |
|
358 */ |
|
359 void LoadLexiconL( TSILexiconID aLexiconID ); |
|
360 |
|
361 /** |
|
362 * Loads the specified model bank into the recognizer; done prior to recognition. |
|
363 * @since 2.0 |
|
364 * @param aModelBankID model bank Id |
|
365 */ |
|
366 void LoadModelsL( TSIModelBankID aModelBankID ); |
|
367 |
|
368 /** |
|
369 * Plays the previously trained utterance. |
|
370 * @since 2.0 |
|
371 * @param aModelBankID model bank Id |
|
372 * @param aModelID model Id, whose utterance is played |
|
373 */ |
|
374 void PlayUtteranceL( TSIModelBankID aModelBankID, TSIModelID aModelID ); |
|
375 |
|
376 /** |
|
377 * Initiates recognition; performed following loading of model bank, lexicon, and grammar. |
|
378 * @since 2.0 |
|
379 * @param aClientResultSet reference where the recognition result is set |
|
380 */ |
|
381 void RecognizeL( CSDClientResultSet& aClientResultSet ); |
|
382 |
|
383 /** |
|
384 * Records uder utterance for training and recognition. |
|
385 * @since 2.0 |
|
386 * @param aRecordTime recording time in microseconds |
|
387 */ |
|
388 void RecordL( TTimeIntervalMicroSeconds32 aRecordTime ); |
|
389 |
|
390 /** |
|
391 * Pre-starts sampling. |
|
392 * @since 3.2 |
|
393 */ |
|
394 void PreStartSamplingL(); |
|
395 |
|
396 /** |
|
397 * Removes the specified grammar from the permanent storage. |
|
398 * Removing a grammar will remove all rules within the grammar. |
|
399 * @since 2.0 |
|
400 * @param aGrammarID grammar Id |
|
401 */ |
|
402 void RemoveGrammarL( TSIGrammarID aGrammarID ); |
|
403 |
|
404 /** |
|
405 * Removes the specified lexicon from the permanent storage. |
|
406 * Removing a lexicon will remove all pronunciations within the lexicon. |
|
407 * @since 2.0 |
|
408 * @param aLexiconID lexicon Id |
|
409 */ |
|
410 void RemoveLexiconL( TSILexiconID aLexiconID ); |
|
411 |
|
412 /** |
|
413 * Removes the specified model bank from the permanent storage. |
|
414 * Removing a model bank will remove all models within the model bank. |
|
415 * @since 2.0 |
|
416 * @param aModelBankID model bank Id |
|
417 */ |
|
418 void RemoveModelBankL( TSIModelBankID aModelBankID ); |
|
419 |
|
420 /** |
|
421 * Removes the specified model from the specified model bank permanently. |
|
422 * @since 2.0 |
|
423 * @param aModelBankID model bank Id |
|
424 * @param aModelID model Id |
|
425 */ |
|
426 void RemoveModelL( TSIModelBankID aModelBankID, TSIModelID aModelID ); |
|
427 |
|
428 /** |
|
429 * Removes the specified pronunciation from the specified lexicon permanently. |
|
430 * @since 2.0 |
|
431 * @param aLexiconID lexicon Id |
|
432 * @param aPronunciationID pronunciation Id |
|
433 */ |
|
434 void RemovePronunciationL( TSILexiconID aLexiconID, TSIPronunciationID aPronunciationID ); |
|
435 |
|
436 /** |
|
437 * Removes the specified rule from the specified grammar permanently. |
|
438 * @since 2.0 |
|
439 * @param aGrammarID grammar Id |
|
440 * @param aRuleID rule Id |
|
441 */ |
|
442 void RemoveRuleL( TSIGrammarID aGrammarID, TSIRuleID aRuleID ); |
|
443 |
|
444 /** |
|
445 * Removes the specified rules from the specified grammar permanently. |
|
446 * @since 2.0 |
|
447 * @param aGrammarID grammar Id |
|
448 * @param aRuleIDs rule Ids |
|
449 */ |
|
450 void RemoveRulesL(TSIGrammarID aGrammarID,RArray<TSIRuleID>& aRuleIDs ); |
|
451 |
|
452 /** |
|
453 * Sets the client's UID for data ownership identification. |
|
454 * @since 2.0 |
|
455 * @param aClientUid client's UID |
|
456 */ |
|
457 void SetClientUid( TUid aClientUid ); |
|
458 |
|
459 /** |
|
460 * Sets the priority settings for this controller. |
|
461 * @since 2.0 |
|
462 * @param aPrioritySettings new priority settings |
|
463 */ |
|
464 void SetPrioritySettings( const TMMFPrioritySettings& aPrioritySettings ); |
|
465 |
|
466 /** |
|
467 * Starts a new recognition session. |
|
468 * @since 2.0 |
|
469 */ |
|
470 void StartRecSessionL(); |
|
471 |
|
472 /** |
|
473 * Trains a new model into the specified model bank. |
|
474 * @since 2.0 |
|
475 * @param aModelBankID model bank Id |
|
476 * @param aModelID reference where a new model Id is assigned to |
|
477 */ |
|
478 void TrainL( TSIModelBankID aModelBankID, TSIModelID& aModelID ); |
|
479 |
|
480 /** |
|
481 * Unloads the specified rule from the specified grammar in temporary memory, previously |
|
482 * loaded with LoadGrammarL. The rule in the permanent storage remains intact. |
|
483 * @since 2.0 |
|
484 * @param aGrammarID grammar Id |
|
485 * @param aRuleID rule Id |
|
486 */ |
|
487 void UnloadRuleL( TSIGrammarID aGrammarID, TSIRuleID aRuleID ); |
|
488 |
|
489 |
|
490 // SI component |
|
491 |
|
492 /** |
|
493 * |
|
494 * Does speaker adapation to speaker independent models |
|
495 * @since 2.8 |
|
496 * @param aResultSet a recognition result containing adaptation data |
|
497 * @param aCorrect identifies the correct recognition result from the N-best list. |
|
498 */ |
|
499 void AdaptL( CSIClientResultSet& aResultSet ,TInt aCorrect ); |
|
500 |
|
501 /** |
|
502 * Adds a new pronunciation for the given model into the specified lexicon. |
|
503 * @since 2.0 |
|
504 * @param aLexiconID lexicon Id |
|
505 * @param aTrainText: the text to be trained |
|
506 * @param aTrainText: the text to be trained |
|
507 * @param aLanguage the pronunciation language |
|
508 * @param aPronunciationID: reference where a new pronunciation identifier is set. |
|
509 */ |
|
510 void AddPronunciationL( TSILexiconID aLexiconID, |
|
511 const TDesC& aTrainText, |
|
512 TLanguage aLanguage, |
|
513 TSIPronunciationID& aPronunciationID ); |
|
514 |
|
515 /** |
|
516 * From MSpeechRecognitionCustomCommandImplementor |
|
517 * Adds a new rule variant for the given pronunciation into the specified grammar. |
|
518 * @since 2.0 |
|
519 * @param aGrammarID grammar Id, where the new rule is added to |
|
520 * @param aLexiconID lexicon Id |
|
521 * @param aPronunciationIDs pronunciation Id array |
|
522 * @param aRuleVariantID reference where a new rule Variant Id is assigned to |
|
523 */ |
|
524 void AddRuleVariantL( TSIGrammarID aGrammarID, |
|
525 TSILexiconID aLexiconID, |
|
526 RArray<TSIPronunciationID>& aPronunciationIDs, |
|
527 TSIRuleID aRuleID,TSIRuleVariantID& aRuleVariantID ); |
|
528 |
|
529 /** |
|
530 * Trains a new voice tag. The recognition phrase is the concatenation of words in the aTrainArray. |
|
531 * Pronunciations are created with all given languages, which are supported. |
|
532 * @since 2.8 |
|
533 * @param aTrainArray: Recognition phrase is formed by concatenating the descriptors in this array. |
|
534 * @param aLanguageArray Pronunciations are created with these languages. Not all languages are supported. The argument can be NULL. |
|
535 * @param aLexiconID lexicon Id |
|
536 * @param aGrammarID grammar Id, where the new rule is added to |
|
537 * @param aRuleID reference where a new rule Id is assigned to |
|
538 */ |
|
539 void AddVoiceTagL( MDesCArray& aTrainArray, |
|
540 RArray<TLanguage>& aLanguageArray, |
|
541 TSILexiconID aLexiconID, |
|
542 TSIGrammarID aGrammarID, |
|
543 TSIRuleID& aRuleID ); |
|
544 |
|
545 /** |
|
546 * Adds several new voice tags. |
|
547 * @since 2.8 |
|
548 * @param aTrainArray : An array of MDesCArrays. The recognition phrases are formed by concatenating the descriptors in the MDesCArrays. |
|
549 * @param aLanguageArray Pronunciations are created with these languages. Not all languages are supported. The argument can be NULL. |
|
550 * @param aLexiconID lexicon Id |
|
551 * @param aGrammarID grammar Id, where the new rule is added to |
|
552 * @param aRuleID reference where a new rule Id is assigned to |
|
553 */ |
|
554 void AddVoiceTagsL( RPointerArray<MDesCArray>& aTrainArray, |
|
555 RArray<TLanguage>& aLanguageArray, |
|
556 TSILexiconID aLexiconID, |
|
557 TSIGrammarID aGrammarID, |
|
558 RArray<TSIRuleID>& aRuleID ); |
|
559 |
|
560 #ifdef __SINDE_TRAINING |
|
561 /** |
|
562 * Trains one new SINDE voice tag. The recognition phrase is the |
|
563 * concatenation of words in the aTrainArray. Pronunciations are |
|
564 * created with all given languages, which are supported. |
|
565 * |
|
566 * @since 3.1 |
|
567 * @param aTrainArray Recognition phrase is formed by concatenating |
|
568 * the descriptors in this array. |
|
569 * @param aLanguageArray Pronunciations are created with these languages.. |
|
570 * @param aLexiconID Lexicon Id |
|
571 * @param aGrammarID Grammar Id, where the new rule is added to. |
|
572 * @param aRuleID Reference where a new rule Id is assigned to. |
|
573 */ |
|
574 void AddSindeVoiceTagL( MDesCArray& aTrainArray, |
|
575 RArray<RLanguageArray>& aLanguageArray, |
|
576 TSILexiconID aLexiconID, |
|
577 TSIGrammarID aGrammarID, |
|
578 TSIRuleID& aRuleID ); |
|
579 |
|
580 /** |
|
581 * Adds several new SINDE voice tags. |
|
582 * |
|
583 * @since 3.1 |
|
584 * @param aTrainArray Recognition phrase is formed by concatenating |
|
585 * the descriptors in this array. |
|
586 * @param aLanguageArray Pronunciations are created with these languages.. |
|
587 * @param aLexiconID Lexicon Id |
|
588 * @param aGrammarID Grammar Id, where the new rule is added to. |
|
589 * @param aRuleID Reference where a new rule Ids are assigned to. |
|
590 */ |
|
591 void AddSindeVoiceTagsL( RPointerArray<MDesCArray>& aTrainArray, |
|
592 RArray<RLanguageArray>& aLanguageArray, |
|
593 TSILexiconID aLexiconID, |
|
594 TSIGrammarID aGrammarID, |
|
595 RArray<TSIRuleID>& aRuleID ); |
|
596 |
|
597 #endif // __SINDE_TRAINING |
|
598 |
|
599 /** |
|
600 * Creates a new empty rule. |
|
601 * @since 2.8 |
|
602 * @param aGrammarID grammar Id, where the new rule is added to |
|
603 * @param aRuleID reference where a new rule Id is assigned to |
|
604 */ |
|
605 void CreateRuleL( TSIGrammarID aGrammarID, TSIRuleID& aRuleID ); |
|
606 |
|
607 /** |
|
608 * Initiates recognition; performed following loading of model bank, lexicon, and grammar. |
|
609 * @since 2.8 |
|
610 * @param aResultSet: reference where the recognition result is set. |
|
611 */ |
|
612 void RecognizeL( CSIClientResultSet& aResultSet ); |
|
613 |
|
614 /** |
|
615 * Ends recording. Unlike Cancel(), this function may return a recognition |
|
616 * result if adequate number of samples was already recorded. |
|
617 * @since 2.8 |
|
618 */ |
|
619 void EndRecordL(); |
|
620 |
|
621 /** |
|
622 * Unloads the specified grammar from the temporary memory, |
|
623 * previously loaded with MSrLoadGrammarL. The grammar in the permanent storage remains intact. |
|
624 * result if adequate number of samples was already recorded. |
|
625 * @since 2.0 |
|
626 * @param aGrammarID grammar Id, where the new rule is added to |
|
627 */ |
|
628 void UnloadGrammarL( TSIGrammarID aGrammarID ); |
|
629 |
|
630 /** |
|
631 * Activate the grammar for the recognition |
|
632 * @since 2.8 |
|
633 * @param aGrammarID grammar Id |
|
634 */ |
|
635 void ActivateGrammarL( TSIGrammarID aGrammarID ) ; |
|
636 /** |
|
637 * Deactivate the grammar |
|
638 * @since 2.8 |
|
639 * @param aGrammarID grammar Id |
|
640 */ |
|
641 void DeactivateGrammarL( TSIGrammarID aGrammarID ); |
|
642 |
|
643 /** |
|
644 * Create a empty rule into a given grammar |
|
645 * @since 2.8 |
|
646 * @param aGrammar : a compiled grammar |
|
647 * @return Created rule |
|
648 */ |
|
649 CSIRule* CreateNewRuleL( CSICompiledGrammar* aGrammar ); |
|
650 |
|
651 /** |
|
652 * Create a pronunciation into a given lexicon |
|
653 * @since 2.8 |
|
654 * @param aLexicon : a lexicon |
|
655 * @param aPronunciationPr : phoneme sequence of the pronunciation |
|
656 * @param aModelBankID : modelbank id |
|
657 * @return Created pronunciation id |
|
658 */ |
|
659 TSIPronunciationID CreateNewPronunciationL( CSILexicon* aLexicon, |
|
660 TDesC8& aPronunciationPr, |
|
661 TSIModelBankID aModelBankID ); |
|
662 |
|
663 /** |
|
664 * Add rule variants into a given rule |
|
665 * @since 2.8 |
|
666 * @param aRule : a given rule |
|
667 * @param aLexiconID : a lexicon ID, the added rule variant's pronunciations belong to this lexicon |
|
668 * @param aPronunciationIDs : array of Pronunciation IDs, |
|
669 * @param aParameters : other parameters,such as language ID, for rule variants |
|
670 */ |
|
671 void AddNewRuleVariantL( CSIRule& aRule, |
|
672 TSILexiconID aLexiconID, |
|
673 RArray<TSIPronunciationID>& aPronunciationIDs, |
|
674 CSIParameters& aParameters ); |
|
675 |
|
676 // Test functions |
|
677 CSIRule* CreateRule1L(void); |
|
678 CSIRule* CreateRule2L(void); |
|
679 void CheckRule1L(const CSIRule* aRule); |
|
680 void CheckRule2L(const CSIRule* aRule); |
|
681 #ifdef __CONSOLETEST__ |
|
682 |
|
683 // Unit Test |
|
684 public: |
|
685 |
|
686 // Returns reference to a database |
|
687 RDbNamedDatabase& GetDb(); |
|
688 |
|
689 // Returns reference to model bank array |
|
690 RPointerArray<CSIModelBank>& ModelBankArray(); |
|
691 |
|
692 // Returns current plugin state |
|
693 TInt PluginState(); |
|
694 #endif |
|
695 |
|
696 private: |
|
697 |
|
698 /** |
|
699 * C++ default constructor. |
|
700 */ |
|
701 CSIControllerPlugin( CSIControllerPluginInterface& aControllerIf ); |
|
702 |
|
703 /** |
|
704 * By default Symbian 2nd phase constructor is private. |
|
705 */ |
|
706 void ConstructL(); |
|
707 |
|
708 /** |
|
709 * RunL from CActive class. |
|
710 */ |
|
711 void RunL(); |
|
712 |
|
713 /** |
|
714 * Cancel handle from CActive class. |
|
715 */ |
|
716 void DoCancel(); |
|
717 |
|
718 /** |
|
719 * This method completes the request status and set the object active |
|
720 * to provide asynchronous behavior. |
|
721 * @since 2.0 |
|
722 */ |
|
723 void DoAsynch(); |
|
724 |
|
725 /** |
|
726 * Plays the previously trained utterance. |
|
727 * @since 2.0 |
|
728 * @param aModelBankID model bank Id |
|
729 * @param aModelID model Id, whose utterance is played |
|
730 */ |
|
731 void PlayL( TSIModelBankID aModelBankID, TSIModelID aModelID ); |
|
732 |
|
733 /** |
|
734 * Handles DevASR events received while in Training state. |
|
735 * @since 2.0 |
|
736 * @param aEvent event code |
|
737 * @param aError error code |
|
738 */ |
|
739 void HandleEventTrainL( TDevASREvent aEvent, TDevASRError aError ); |
|
740 |
|
741 /** |
|
742 * Handles DevASR events received while in Recognition state. |
|
743 * @since 2.0 |
|
744 * @param aEvent event code |
|
745 * @param aError error code |
|
746 */ |
|
747 void HandleEventRecognize( TDevASREvent aEvent, TDevASRError aError ); |
|
748 |
|
749 /** |
|
750 * Handles DevASR events received while in remove rule state. |
|
751 * @since 2.8 |
|
752 * @param aEvent event code |
|
753 * @param aError error code |
|
754 */ |
|
755 void HandleEventRemoveRule( TDevASREvent aEvent, TDevASRError aError ); |
|
756 |
|
757 /** |
|
758 * Handles DevASR events received while in remove rules state. |
|
759 * @since 2.8 |
|
760 * @param aEvent event code |
|
761 * @param aError error code |
|
762 */ |
|
763 void HandleEventRemoveRules( TDevASREvent aEvent, TDevASRError aError ); |
|
764 |
|
765 /** |
|
766 * Handles DevASR events received while in TTP state. |
|
767 * @since 2.8 |
|
768 * @param aEvent event code |
|
769 * @param aError error code |
|
770 */ |
|
771 void HandleEventTTP( TDevASREvent aEvent, |
|
772 TDevASRError aError ); |
|
773 |
|
774 /** |
|
775 * Handles DevASR events received while in Play state. |
|
776 * @since 2.0 |
|
777 * @param aEvent event code |
|
778 * @param aError error code |
|
779 */ |
|
780 void HandleEventPlayL( TDevASREvent aEvent, TDevASRError aError ); |
|
781 |
|
782 /** |
|
783 * Frees memory allocated during recognition and resets the state to Idle. |
|
784 * @since 2.0 |
|
785 */ |
|
786 void RecognitionReset(); |
|
787 |
|
788 /** |
|
789 * Handles the acoustic model and the user utterance from DevASR received upon |
|
790 * TrainComplete event. |
|
791 * @since 2.0 |
|
792 */ |
|
793 void ProcessTrainCompleteL(); |
|
794 |
|
795 /** |
|
796 * Handles the transfer of recognition result from DevASR into client's |
|
797 * recognition result. |
|
798 * @since 2.0 |
|
799 * @return Number of results to the client |
|
800 */ |
|
801 TInt ProcessRecognitionComplete(); |
|
802 |
|
803 /** |
|
804 * Save TTP result into the given grammar and lexicon of the plugin database |
|
805 * @since 2.8 |
|
806 * @param aSITtpWordList : data structure contains ttp results, word entries and their corresponding prounication |
|
807 * @param aLexiconID : a lexicon ID, the added rule variant's pronunciations belong to this lexicon |
|
808 * @param aRuleIDs : array of generated Rule IDs, |
|
809 * @param aParameters : other parameters,such as language ID, for rule variants |
|
810 */ |
|
811 // void UpdateGrammarAndLexiconL(CSITtpWordList* aSITtpWordList , TSILexiconID aLexiconID, TSIGrammarID aGrammarID, RArray<TSIRuleID>& aRuleIDs); |
|
812 |
|
813 /** |
|
814 * Save TTP result into the given grammar and lexicon of the plugin database |
|
815 * @since 2.8 |
|
816 * @param aSITtpWordList : data structure contains ttp results, word entries and their corresponding prounication |
|
817 * @param aLexiconID : a lexicon ID, the added rule variant's pronunciations belong to this lexicon |
|
818 * @param aGrammarID : a grammar Id |
|
819 * @param aRuleIDs : array of generated Rule IDs, |
|
820 */ |
|
821 void UpdateGrammarAndLexiconDBL( CSITtpWordList* aSITtpWordList, |
|
822 TSILexiconID aLexiconID, |
|
823 TSIGrammarID aGrammarID, |
|
824 RArray<TSIRuleID>& aRuleIDs ); |
|
825 |
|
826 /** |
|
827 * Is the lexicon id valid in the database |
|
828 * @since 2.8 |
|
829 * @param aLexiconID : a lexicon ID, |
|
830 * @return True or false |
|
831 */ |
|
832 TBool IsLexiconIDInvalid( TSILexiconID aLexiconID ); |
|
833 |
|
834 /** |
|
835 * Is the Grammar id valid in the database |
|
836 * @since 2.8 |
|
837 * @param aGrammarID : a grammar Id |
|
838 * @return True or false |
|
839 */ |
|
840 TBool IsGrammarIDInvalid( TSIGrammarID aGrammarID ); |
|
841 |
|
842 // ============================================================================ |
|
843 // These methods are handlers for asynchronous messages that are called from |
|
844 // the RunL. The parameters are identical to how they were initially received |
|
845 // under Public section of this class, therefore not repeated here. |
|
846 // ============================================================================ |
|
847 // |
|
848 // void HandleAddPronunciationL( TSILexiconID aLexiconID, TSIModelBankID aModelBankID, |
|
849 // TSIModelID aModelID, TSIPronunciationID& aPronunciationID ); |
|
850 |
|
851 // void HandleAddPronunciationL( TSILexiconID aLexiconID, TSIModelBankID aModelBankID, |
|
852 // TDesC8& aPronunciationPr, TSIPronunciationID& aPronunciationID ); |
|
853 |
|
854 void HandleAddRuleL( TSIGrammarID aGrammarID, TSILexiconID aLexiconID, |
|
855 TSIPronunciationID aPronunciationID, TSIRuleID& aRuleID ); |
|
856 |
|
857 void HandleCreateGrammarL( TSIGrammarID& aGrammarID ); |
|
858 |
|
859 void HandleCreateLexiconL( TSILexiconID& aLexiconID ); |
|
860 |
|
861 void HandleCreateModelBankL( TSIModelBankID& aModelBankID ); |
|
862 |
|
863 void HandleGetAllClientGrammarIDsL( RArray<TSIGrammarID>& aGrammarIDs ); |
|
864 |
|
865 void HandleGetAllClientLexiconIDsL( RArray<TSILexiconID>& aLexiconIDs ); |
|
866 |
|
867 void HandleGetAllClientModelBankIDsL( RArray<TSIModelBankID>& aModelBankIDs ); |
|
868 |
|
869 void HandleGetAllGrammarIDsL( RArray<TSIGrammarID>& aGrammarIDs ); |
|
870 |
|
871 void HandleGetAllLexiconIDsL( RArray<TSILexiconID>& aLexiconIDs ); |
|
872 |
|
873 void HandleGetAllModelBankIDsL( RArray<TSIModelBankID>& aModelBankIDs ); |
|
874 |
|
875 void HandleGetAllModelIDsL( TSIModelBankID aModelBankID, RArray<TSIModelID>& aModelIDs ); |
|
876 |
|
877 void HandleGetAllPronunciationIDsL( TSILexiconID aLexiconID, |
|
878 RArray<TSIPronunciationID>& aPronunciationIDs ); |
|
879 |
|
880 void HandleGetAllRuleIDsL( TSIGrammarID aGrammarID, RArray<TSIRuleID>& aRuleIDs ); |
|
881 |
|
882 void HandleGetAvailableStorageL( TInt& aCount ); |
|
883 |
|
884 void HandleGetModelCountL( TSIModelBankID aModelBankID, TInt& aCount ); |
|
885 |
|
886 void HandleGetPronunciationCountL(TSIModelBankID aLexiconID,TInt& aCount ); |
|
887 |
|
888 void HandleGetRuleCountL(TSIGrammarID aGrammarID,TInt& aCount ); |
|
889 |
|
890 void HandleGetRuleValidityL( TSIGrammarID aGrammarID, TSIRuleID aRuleID, TBool& aValid ); |
|
891 |
|
892 void HandleGetUtteranceDurationL( TSIModelBankID aModelBankID, TSIModelID aModelID, |
|
893 TTimeIntervalMicroSeconds32& aDuration ); |
|
894 |
|
895 void HandleLoadGrammarL( TSIGrammarID aGrammarID ); |
|
896 |
|
897 void HandleLoadLexiconL( TSILexiconID aLexiconID ); |
|
898 |
|
899 void HandleLoadModelsL( TSIModelBankID aModelBankID ); |
|
900 |
|
901 void HandleRecognizeL(); |
|
902 |
|
903 void HandleRecordL( TTimeIntervalMicroSeconds32 aRecordTime ); |
|
904 |
|
905 void HandleRemoveGrammarL( TSIGrammarID aGrammarID ); |
|
906 |
|
907 void HandleRemoveLexiconL( TSILexiconID aLexiconID ); |
|
908 |
|
909 void HandleRemoveModelBankL( TSIModelBankID aModelBankID ); |
|
910 |
|
911 void HandleRemoveModelL( TSIModelBankID aModelBankID, TSIModelID aModelID ); |
|
912 |
|
913 void HandleRemovePronunciationL( TSILexiconID aLexiconID, TSIPronunciationID aPronunciationID ); |
|
914 |
|
915 void HandleRemoveRuleL( TSIGrammarID aGrammarID, TSIRuleID aRuleID ); |
|
916 |
|
917 void HandleRemoveRulesL( TSIGrammarID aGrammarID,RArray<TSIRuleID>& aRuleIDs ); |
|
918 |
|
919 void HandleTrainL( TSIModelBankID aModelBankID ); |
|
920 |
|
921 void HandleUnloadRuleL( TSIGrammarID aGrammarID, TSIRuleID aRuleID ); |
|
922 |
|
923 void HandlePlayUtteranceL(TSIModelBankID aModelBankID, TSIModelID aModelID); |
|
924 // SI component |
|
925 |
|
926 void HandleAdaptL(CSIClientResultSet& aResultSet ,TInt aCorrect); |
|
927 |
|
928 |
|
929 // void HandleAddPronunciationL(TSILexiconID aLexiconID, TPtrC& aTrainText, |
|
930 // TLanguage aLanguage, TSIPronunciationID* aPronunciationID) ; |
|
931 |
|
932 void HandleAddRuleVariantL(TSIGrammarID aGrammarID, TSILexiconID aLexiconID, |
|
933 RArray<TSIPronunciationID>& aPronunciationIDs,TSIRuleID aRuleID, TSIRuleVariantID& aRuleVariantID ); |
|
934 |
|
935 void HandleAddVoiceTagL( MDesCArray& aTrainArray, RArray<TLanguage>& aLanguageArray, |
|
936 TSILexiconID aLexiconID, TSIGrammarID aGrammarID, TSIRuleID* aRuleIDPtr); |
|
937 |
|
938 void HandleAddVoiceTagsL( RPointerArray<MDesCArray>* aTrainArray, RArray<TLanguage>& aLanguageArray, TSILexiconID aLexiconID, |
|
939 TSIGrammarID aGrammarID/*, |
|
940 RArray<TSIRuleID>& aRuleID*/); |
|
941 |
|
942 #ifdef __SINDE_TRAINING |
|
943 void HandleAddSindeVoiceTagsL( RPointerArray<MDesCArray>* aTrainArrays, |
|
944 RArray<RLanguageArray>& aLanguageArray, |
|
945 TSILexiconID aLexiconID, |
|
946 TSIGrammarID aGrammarID ); |
|
947 #endif // __SINDE_TRAINING |
|
948 |
|
949 void HandleCreateRuleL(TSIGrammarID aGrammarID, TSIRuleID& aRuleID) ; |
|
950 |
|
951 // void HandleRecognizeL( CSIClientResultSet& aResultSet ); |
|
952 |
|
953 void HandleEndRecordL(); |
|
954 |
|
955 void HandleUnloadGrammarL( TSIGrammarID aGrammarID ); |
|
956 |
|
957 // void HandleUpdateGrammarAndLexiconL(CSITtpWordList* iSITtpWordList , TSILexiconID aLexiconID, TSIGrammarID aGrammarID, RArray<TSIRuleID>& aRuleID); |
|
958 |
|
959 void HandlePreStartSamplingL(); |
|
960 |
|
961 private: // Data |
|
962 |
|
963 // SI Controller Plugin states |
|
964 enum TControllerState |
|
965 { |
|
966 ESiPluginIdle, |
|
967 ESdPluginTrain, |
|
968 ESiPluginRecognize, |
|
969 ESiPluginAdapt, |
|
970 ESiPluginTrainText, |
|
971 ESiPluginRemoveRule , |
|
972 ESiPluginRemoveRules, |
|
973 ESiPluginPlay, |
|
974 ESiPluginTrainSinde |
|
975 }; |
|
976 |
|
977 |
|
978 // SI Controller Plugin state |
|
979 TControllerState iState; |
|
980 // Result to be sent to the client |
|
981 TInt iResult; |
|
982 |
|
983 // Reference to Controller Interface |
|
984 CSIControllerPluginInterface& iControllerIf; |
|
985 |
|
986 // SI Database |
|
987 CSIDatabase* iSIDatabase; |
|
988 |
|
989 |
|
990 // SI part |
|
991 // Model Bank database |
|
992 CSIModelBankDB* iSIModelBankDB; |
|
993 // Lexicon database |
|
994 CSILexiconDB* iSILexiconDB; |
|
995 // Grammar database |
|
996 CSIGrammarDB* iSIGrammarDB; |
|
997 TBool iVoiceTagDBLocked; |
|
998 // Resource file handler |
|
999 CSIResourceHandler* iResourceHandler; |
|
1000 |
|
1001 // Client's UID for data ownership identification |
|
1002 TUid iClientUid; |
|
1003 TBool iClientRegistered; |
|
1004 |
|
1005 // DevASR |
|
1006 CDevASR* iDevASR; |
|
1007 |
|
1008 CSIResultSet* iSIResultSet; // Used during recognition |
|
1009 |
|
1010 /// Begin: data used in async handling of requests |
|
1011 TInt iRequestFunction; |
|
1012 TSIGrammarID iGrammarID; |
|
1013 TSILexiconID iLexiconID; |
|
1014 TSIModelBankID iModelBankID; |
|
1015 TSIRuleID iRuleID; |
|
1016 TSIRuleVariantID iRuleVariantID; |
|
1017 TSIPronunciationID iPronunciationID; |
|
1018 //RArray<TSIPronunciationID> iPronunciationIDs; |
|
1019 TSIModelID iModelID; |
|
1020 TTimeIntervalMicroSeconds32 iRecordTime; |
|
1021 TSIGrammarID* iGrammarIDPtr; |
|
1022 TSILexiconID* iLexiconIDPtr; |
|
1023 |
|
1024 TSIModelBankID* iModelBankIDPtr; |
|
1025 TSIRuleID* iRuleIDPtr; |
|
1026 TSIRuleVariantID* iRuleVariantIDPtr; |
|
1027 TSIPronunciationID* iPronunciationIDPtr; |
|
1028 TSIModelID* iModelIDPtr; |
|
1029 TInt* iCountPtr; |
|
1030 TBool* iValidPtr; |
|
1031 TTimeIntervalMicroSeconds32* iDurationPtr; |
|
1032 |
|
1033 |
|
1034 |
|
1035 RArray<TSIGrammarID>* iGrammarIDs; |
|
1036 RArray<TSILexiconID>* iLexiconIDs; |
|
1037 |
|
1038 RArray<TSIModelBankID>* iModelBankIDs; |
|
1039 RArray<TSIModelID>* iModelIDs; |
|
1040 RArray<TSIPronunciationID>* iPronunciationIDs; |
|
1041 RArray<TSIRuleID>* iRuleIDs; |
|
1042 |
|
1043 // End: data used in async handling of requests |
|
1044 |
|
1045 |
|
1046 // SI componet |
|
1047 CSIClientResultSet* iSIClientResultSet ; |
|
1048 |
|
1049 TInt iCorrect; |
|
1050 TPtrC iTrainTextPtr; |
|
1051 TLanguage iLanguage; |
|
1052 RArray<TLanguage>* iLanguageArray; |
|
1053 RArray<RLanguageArray>* iLanguageArrayArray; |
|
1054 MDesCArray *iTrainArray ; |
|
1055 RPointerArray<MDesCArray>* iTrainArrays; |
|
1056 CSITtpWordList* iSITtpWordList; |
|
1057 RArray<TUint32> iMaxNPronunsForWord; |
|
1058 TPtrC8 iPronunciationPr; |
|
1059 CSICompiledGrammar *iSICompiledGrammar; |
|
1060 TSIPronunciationID* iLastAddedPronunciationIDPtr; |
|
1061 TSIRuleID* iLastAddedRuleIDPtr; |
|
1062 |
|
1063 // recompile grammar during remove rule . |
|
1064 CSICompiledGrammar* iSICompiledGrammarRecompile; // Pointer to grammar to in remove rule |
|
1065 TSIGrammarID iGrammarIDRecompile; |
|
1066 TBool iIsGrammarRecompile; |
|
1067 TSIRuleID iRuleIDRemove; |
|
1068 TBool iIsRecompileGrammarActive; |
|
1069 |
|
1070 // TTP data loader |
|
1071 |
|
1072 //CTTPDataLoader* iTtpLoader; |
|
1073 CDataLoader* iDataLoader; |
|
1074 |
|
1075 // Audio |
|
1076 HBufC8* iAudioBuffer; |
|
1077 TInt iNSamplesSent; |
|
1078 TPtrC8 iCurrentAudioBuffer; |
|
1079 |
|
1080 TTimeIntervalMicroSeconds32 iRecordDurations; |
|
1081 //TSIRuleVariantID iRuleVariantID; |
|
1082 RDbNotifier iRDbNotifier; |
|
1083 |
|
1084 #ifdef __SINDE_TRAINING |
|
1085 // Class which takes care of SINDE type of training process |
|
1086 CSindeTrainer* iSindeTrainer; |
|
1087 #endif // __SINDE_TRAINING |
|
1088 }; |
|
1089 |
|
1090 #endif // __CSIControllerPlugin_H__ |
|
1091 |
|
1092 // End of File |