/*

* Copyright (c) 2004-2006 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 definition of the server side for the

*			    speaker independent controller.

*

*/

#ifndef NSSSISPEECHRECOGNITIONCUSTOMCOMMANDIMPLEMENTOR_H

#define NSSSISPEECHRECOGNITIONCUSTOMCOMMANDIMPLEMENTOR_H

// INCLUDES

#include <nsssispeechrecognitiondataclient.h>

#include <nsssispeechrecognitiondatacommon.h>

// CLASS DECLARATION

/**

*  This is the main class of Speaker Independent Custom Commands Implementor

*

*  @lib NssSiSpeechRecognitionCustomCommands.lib

*  @since 2.8

*/

class MSISpeechRecognitionCustomCommandImplementor

{

public:

		/**

		*	Adapts speaker independent models according using a correct recognition result.

        * 

        * @since	2.8

        * @param	aResultSet          The result N-Best containing feature vectors

		*			aCorrect            The correct index

		*/

        virtual void MSrAdaptL(CSIClientResultSet& aResultSet, TInt aCorrect) = 0;

		/**

		*	Adds a pronunciation to the given lexicon.

        * 

        * @since	2.8

		* @param	aLexiconID			The lexicon Id

        * @param    aTrainText          Text to be pronounced

        * @param    aLanguage           Pronunciation language

		* @param	aPronunciationID	Reference where a new pronunciation Id is assigned to.

		*/

        virtual void MSrAddPronunciationL(TSILexiconID aLexiconID,

                                          const TDesC& aTrainText,

                                          TLanguage aLanguage,

                                          TSIPronunciationID& aPronunciationID) = 0;

		/**

        *	Adds a rule variant to a grammar.

        * 

        * @since 2.8

        * @param 	aGrammarID          Grammar identifier

        * @param    aRuleID             Rule identifier; variant is added here.

        * @param    aPronunciations     Sequence of pronunciations; these get concatenated.

        *                               in the rule variant.

        * @param    aRuleVariantID      Reference where the new variant

        *                               identifier is assigned to.

		*/

		virtual void MSrAddRuleVariantL(

            TSIGrammarID aGrammarID,

            TSILexiconID aLexiconID,

            RArray<TSIPronunciationID>& aPronunciationIDs,

            TSIRuleID aRuleID,

            TSIRuleVariantID& aRuleVariantID ) = 0;

        /**

		*	Trains a voice tag. Adds the text to the lexicon, and creates the required

        *   rules and rule variants.

        * 

        * @since 2.8

        * @param	aTrainArray         The phrase to be trained, split into subwords

        * @param	aLanguageArray      The pronunciaiton languages

        * @param	aLexiconID          Lexicon identifier

        * @param	aGrammarID          Grammar identifier

        * @param	aRuleID             Reference, where the new rule identifier is assigned to.

        */

        virtual void MSrAddVoiceTagL(

            MDesCArray& aTrainArray,

            RArray<TLanguage>& aLanguageArray,

            TSILexiconID aLexiconID,

            TSIGrammarID aGrammarID,

            TSIRuleID& aRuleID) = 0;

        /**

		*	Trains voice tags. If the training fails for some of the names (but not all),

        *   it is signaled by setting the Rule ID to KInvalidRuleID.

        * 

        * @since 2.8

        * @param	aTrainArray         The phrase to be trained, split into subwords

        * @param	aLanguageArray      The pronunciation languages

        * @param	aLexiconID          Lexicon identifier

        * @param	aGrammarID          Grammar identifier

        * @param	aRuleID             Referenceto an array, where the new

        *                               Rule identifiers are assigned to.

        */

        virtual void MSrAddVoiceTagsL(

            RPointerArray<MDesCArray>* aTrainArray,

            RArray<TLanguage>& aLanguageArray,

            TSILexiconID aLexiconID,

            TSIGrammarID aGrammarID,

            RArray<TSIRuleID>& aRuleID) = 0;

        /**

        *	Creates a new rule.

        * 

        * @since 2.8

        * @param 	aGrammarID          Grammar identifier

        * @param 	aRuleID             Reference where rule ID is stored

        */

        virtual void MSrCreateRuleL(TSIGrammarID aGrammarID, TSIRuleID& aRuleID) = 0;

		/**

        *   Starts recognition

        *

        * @since 2.8

        * @param 	aResultSet          Recognition result is placed here, when ready.

        */

		virtual void MSrRecognizeL( CSIClientResultSet& aResultSet ) = 0;

        /**

		*	Stops recognition. Unlike Cancel(), this function gives

        *   the recognition result, if it can be guessed.

        *

        * @since	2.8

        */

		virtual void MSrEndRecordL() = 0;

		/**

		*   Deactivates a grammar.

		*

        * @since	2.8

        * @param	aGrammarID          Grammar identifier

        */

        virtual void MSrUnloadGrammarL( TSIGrammarID aGrammarID ) = 0;

        /**

		* Trains one SINDE voice tag. Adds the text to the lexicon, and 

        * creates the required rules and rule variants.

        * 

        * @since 3.1

        * @param aTrainArray The phrase to be trained, split into subwords

        * @param aLanguageArray The pronunciation languages for each of the 

        * @param aLexiconID Lexicon identifier

        * @param aGrammarID Grammar identifier

        * @param aRuleID Reference, where the new rule identifier is assigned to.

        */

        virtual void MSrAddSindeVoiceTagL( MDesCArray& aTrainArray,

                                           RArray<RLanguageArray>& aLanguageArray,

                                           TSILexiconID aLexiconID,

                                           TSIGrammarID aGrammarID,

                                           TSIRuleID& aRuleID ) = 0;

        /**

		* Trains SINDE voice tags. If the training fails for some of the names

        * (but not all), it is signaled by setting the Rule ID to KInvalidRuleID.

        * 

        * @since 3.1

        * @param aTrainArray The phrase to be trained, split into subwords

        * @param aLanguageArray The pronunciation languages

        * @param aLexiconID Lexicon identifier

        * @param aGrammarID Grammar identifier

        * @param aRuleID Referenceto an array, where the new

        *                rule identifiers are assigned to.

        */

        virtual void MSrAddSindeVoiceTagsL( RPointerArray<MDesCArray>* aTrainArray,

                                            RArray<RLanguageArray>& aLanguageArray,

                                            TSILexiconID aLexiconID,

                                            TSIGrammarID aGrammarID,

                                            RArray<TSIRuleID>& aRuleID ) = 0;

/***************************** SD Legacy functions ***********************/

		/**

		*	Adds a new rule for the given pronunciation into the specified 

		*	grammar.

        * @since	2.0

        * @param	aGrammarID			grammar Id, where the new rule is 

		*								added to

		* @param	aLexiconID			lexicon Id

		* @param	aPronunciationID	pronunciation Id

		* @param	aRuleID				reference where a new rule Id is 

		*								assigned to

		*/

		virtual void MSrAddRuleL( TSIGrammarID aGrammarID, TSILexiconID aLexiconID,

						TSIPronunciationID aPronunciationID, 

						TSIRuleID& aRuleID ) = 0;

		/**

        * 

        *	Cancels the current operation

        * @since 2.0

		*/

		virtual void MSrCancel() = 0;

        /**

		*	Saves the current changes into a permanent storage.

        * @since 2.0

        */

		virtual void MSrCommitChangesL() = 0;

		/**

        * 

        *	Creates a new grammar.

        * @since 2.0

        * @param 	aGrammarID			reference where grammar ID is stored

        */

		virtual void MSrCreateGrammarL( TSIGrammarID& aGrammarID ) = 0;

		/**

        * 

        *	Creates a new lexicon.

        * @since 2.0

        * @param 	aLexiconID			reference where lexicon ID is stored

        */

		virtual void MSrCreateLexiconL( TSILexiconID& aLexiconID ) = 0;

        /**

		*	Creates a new model bank.

        * @since	2.0

        * @param	aModelBankID		reference where a new model bank Id 

		*								is assigned to

        */

		virtual void MSrCreateModelBankL( TSIModelBankID& aModelBankID ) = 0;

		/**

		*	Ends the current recognition session. Resources allocated 

		*	for recognition are freed.

        * @since	2.0

        * @param	aModelBankID		reference where a new model bank

		*								Id is assigned to

        */

		virtual void MSrEndRecSessionL() = 0;

		/**

        *	Returns all grammar Ids that belong to the current client, 

		*	whose UID was set with MSrSetClientUid().

        * @since 2.0

		* @param	aGrammarIDs			reference where grammar Ids are stored

        */

		virtual void MSrGetAllClientGrammarIDsL( 

						RArray<TSIGrammarID>& aGrammarIDs ) = 0;

		/**

 		*	Returns all lexicon Ids that belong to the current client,

		*	whose UID was set with MSrSetClientUid().

        * @since 2.0

		* @param	aLexiconIDs			reference where lexicon Ids are stored

        */

		virtual void MSrGetAllClientLexiconIDsL( 

						RArray<TSILexiconID>& aLexiconIDs ) = 0;

		/**

        *	Returns all model bank Ids that belong to the current client, 

		*	whose UID was set with MSrSetClientUid().

        * @since 2.0

		* @param	aModelBankIDs		reference where model bank Ids are stored

        */

		virtual void MSrGetAllClientModelBankIDsL( 

						RArray<TSIModelBankID>& aModelBankIDs ) = 0;

		/**

		*	Returns all grammar Ids that exist (for all clients).

        * @since 2.0

		* @param	aGrammarIDs			reference where grammar Ids are stored

        */

		virtual void MSrGetAllGrammarIDsL( 

						RArray<TSIGrammarID>& aGrammarIDs ) = 0;

		/**

		*	Returns all lexicon Ids that exist (for all clients).

        * @since 2.0

		* @param	aLexiconIDs			reference where lexicon Ids are stored

        */

		virtual void MSrGetAllLexiconIDsL( 

						RArray<TSILexiconID>& aLexiconIDs ) = 0;

		/**

 		*	Returns all model bank Ids that exist (for all clients).

        * @since 2.0

		* @param	aModelBankIDs		reference where model bank Ids are stored

        */

		virtual void MSrGetAllModelBankIDsL( 

						RArray<TSIModelBankID>& aModelBankIDs ) = 0;

		/**

		*	Returns all pronunciation Ids that exist in the specified lexicon.

        * @since	2.0

        * @param	aLexiconID			lexicon Id

		*			aPronunciationIDs	reference where pronunciation Ids 

		*			are stored

        */

		virtual void MSrGetAllPronunciationIDsL( TSILexiconID aLexiconID, 

						RArray<TSIPronunciationID>& aPronunciationIDs ) = 0;

		/**

		*	Returns all rule Ids that exist in the specified grammar.

        * @since	2.0

        * @param	aGrammarID			grammar Id

		*			aRuleIDs			reference where rule Ids are stored

        */

		virtual void MSrGetAllRuleIDsL( TSIGrammarID aGrammarID, 

						RArray<TSIRuleID>& aRuleIDs ) = 0;

		/**

        * 

        *	Returns the engine properties specified by the engine property 

		*	ID array. On return aPropertyValue contains an array of engine 

		*	properties.

        * @since 2.0

        * @param 	aPropertyId		constant reference to array of engine 

		*							property Ids

		* @param	aPropertyValue	reference to array of engine property 

		*							values

        */

		virtual void MSrGetEnginePropertiesL( const RArray<TInt>& aPropertyId, 

						RArray<TInt>& aPropertyValue ) = 0;

		/**

		*	Checks if the rule is valid or not.

        * @since	2.0

        * @param	aGrammarID			grammar Id

		*			aRuleID				rule Id

		*			aValid				reference where the validity of the 

		*								rule is set

        */

		virtual void MSrGetRuleValidityL( TSIGrammarID aGrammarID, 

						TSIRuleID aRuleID, TBool& aValid ) = 0;

		/**

		*	Loads the specified grammar into the reocgnizer;

        *   done prior to recognition.

        * @since	2.0

        * @param	aGrammarID			grammar Id

        */

		virtual void MSrLoadGrammarL( TSIGrammarID aGrammarID ) = 0;

		/**

		*	Activates the specified grammar,

        *   which has been previously deactivated.

        *

        * @since	2.8

        * @param	aGrammarID			grammar Id

        */

		virtual void MSrActivateGrammarL( TSIGrammarID aGrammarID ) = 0;

		/**

		*	Deactivates a loaded grammar so that it is not recognized.

        *

        * @since	2.8

        * @param	aGrammarID			grammar Id

        */

		virtual void MSrDeactivateGrammarL( TSIGrammarID aGrammarID ) = 0;

        /**

        * 

        *	Loads the specified lexicon into the recognizer; 

		*	done prior to recognition.

        * @since 2.0

        * @param 	aLexiconID			lexicon ID

        */

		virtual void MSrLoadLexiconL( TSILexiconID aLexiconID ) = 0;

		/**

        * 

        *	Loads the specified model bank into the recognizer; 

		*	done prior to recognition..

        * @since 2.0

        * @param 	ModelBankID			model bank Id

        */

		virtual void MSrLoadModelsL( TSIModelBankID aModelBankID ) = 0;

		/**

		*	Records an utterance for training and recognition.

        * @since	2.0

        * @param	aRecordTime			recording time in microseconds

        */

		virtual void MSrRecordL( TTimeIntervalMicroSeconds32 aRecordTime ) = 0;

        /**

        * Pre-starts sampling before MSrRecordL call.

        *

        * @since 3.2

        */

        virtual void MSrPreStartSamplingL() = 0;

		/**

		*	Removes the specified grammar from the permanent storage.

		*	Removing a grammar will remove all rules and rule variants

        *   within the grammar.

        * @since	2.0

        * @param	aGrammarID			grammar Id

        */

		virtual void MSrRemoveGrammarL( TSIGrammarID aGrammarID ) = 0;

		/**

		*	Removes the specified lexicon from the permanent storage.

		*	Removing a lexicon will remove all pronunciations within the 

		*	lexicon.

        * @since	2.0

        * @param	aLexiconID			lexicon Id

        */

		virtual void MSrRemoveLexiconL( TSILexiconID aLexiconID ) = 0;

		/**

		*	Removes the specified model bank from the permanent storage.

		*	Removing a model bank will remove all models within the model bank.

        * @since	2.0

        * @param	aModelBankID		model bank Id

        */

		virtual void MSrRemoveModelBankL( TSIModelBankID aModelBankID ) = 0;

		/**

		*	Removes the specified model from the specified model bank 

		*	permanently.

        * @since	2.0

        * @param	aModelBankID		model bank Id

		* @param	aModelID			model Id

        */

		virtual void MSrRemoveModelL( TSIModelBankID aModelBankID, 

						TSIModelID aModelID ) = 0;

		/**

		*	Removes the specified pronunciation from the specified lexicon 

		*	permanently.

        * @since	2.0

        * @param	aLexiconID			lexicon Id

		* @param	aPronunciationID	pronunciation Id

        */

		virtual void MSrRemovePronunciationL( TSILexiconID aLexiconID, 

						TSIPronunciationID aPronunciationID ) = 0;

		/**

		*	Removes the specified rule from the specified grammar permanently.

        *   If the rule contains rule variants, they are also destoryed.

        * @since	2.0

        * @param	aGrammarID			grammar Id

		* @param	aRuleID				rule Id

        */

		virtual void MSrRemoveRuleL( TSIGrammarID aGrammarID, 

						TSIRuleID aRuleID ) = 0;

		/**

		*	Removes the specified rules from the specified grammar permanently.

        *   If the rule contains rule variants, they are also destoryed.

        * @since	2.0

        * @param	aGrammarID			grammar Id

		* @param	aRuleIDs			array of rule ids

        */

		virtual void MSrRemoveRulesL( TSIGrammarID aGrammarID, 

						RArray<TSIRuleID>& aRuleIDs ) = 0;

		/**

        *	Sets the client's UID for data ownership identification.

        * @since 2.0

        * @param	aClientUid			client's UID

        */

		virtual void MSrSetClientUid( TUid aClientUid ) = 0;

		/**

		*	Starts a new recognition session.

        * @since	2.0

        * @param	aMode				recognition mode

        */

		virtual void MSrStartRecSessionL( TNSSRecognitionMode aMode ) = 0;

		/**

		*	Unloads the specified rule from the specified grammar in temporary 

		*	memory, previously loaded with LoadGrammarL.  The rule in the 

		*	permanent storage remains intact.

        * @since	2.0

        * @param	aGrammarID			grammar Id

		* @param	aRuleID				rule Id

        */

		virtual void MSrUnloadRuleL( TSIGrammarID aGrammarID, 

						TSIRuleID aRuleID ) = 0;

		/**

		*	Unloads the specified parameters to the engine.

        * @since	2.0

        * @param	aParameterId		array of parameter IDs

		* @param	aParameterValue		array of parameter values

        */

		virtual void MSrLoadEngineParametersL( 

						const RArray<TInt>& aParameterId, 

						const RArray<TInt>& aParameterValue ) = 0;

private:

		TAny* iReservedPtr_1;	// reserved for future expansion

		TAny* iReservedPtr_2;	// reserved for future expansion

};

#endif  // NSSSISPEECHRECOGNITIONCUSTOMCOMMANDIMPLEMENTOR_H