/*

* Copyright (c) 2004-2007 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 class implements the recognition algorithm manager.

*

*/

#ifndef DEVASRRECOGNITIONALGMGR_H

#define DEVASRRECOGNITIONALGMGR_H

//  INCLUDES

#include <nsssispeechrecognitiondatadevasr.h>

#include <asrsrecognitionhwdevice.h>

#include <nssdevasrcommon.h>

#include <nssdevasr.h>

#include <asrsadaptationhwdevice.h>

// CLASS DECLARATION

/**

*  Interface class to be implemented by observer of the recognition algorithm manager.

*

*  @since 2.0

*/

class MRecAlgMgrObserver

    {

    public:

        /**

        * Invoked by the adaptation hw device when model adaptation has

        * finished its processing.

        *

        * @since 2.8

        * @param "TInt aResultCode" Error code of operation.

        */

        virtual void AdaptComplete( TInt aResultCode ) = 0;

        /**

        * Feature vector received event from the front-end algorithm.

        *

        * @since 2.0

        * @param "TDesC8& aFV" Buffer containing a feature vector.

        * @param "TInt32 aSNR" Signal-to-noise ratio.

        * @param "TInt32 aPosition" Indicates whether this is the first, 

        *        subsequent or last feature vector.

        */

        virtual void FeatureVectorDataRcvd( const TDesC8& aFV, 

                                            TInt32 aSNR, 

                                            TInt32 aPosition ) = 0;

        /**

        * Invoked by the front-end when EOU has been detected

        *

        * @since 2.8

        * @param "TInt aResultCode" Result of front-end processing.

        */

        virtual void EouDetected( TInt aResultCode ) = 0;

        /**

        * Invoked by the front-end when initialization has completed.

        *

        * @since 2.0

        * @param "TInt aResultCode" Result of front-end initialization.

        */

        virtual void InitFEComplete( TInt aResultCode ) = 0;

        /**

        * Invoked by the recognizer back-end when initialization has completed.

        *

        * @since 2.0

        * @param "TInt aResultCode" Result of recognizer back-end initialization.

        */

        virtual void InitRecognizerBEComplete( TInt aResultCode ) = 0;

        /**

        * Invoked by the recognizer back-end when grammar loading has completed.

        *

        * @since 2.0

        * @param "TInt aResultCode" Result of grammar loading

        */

        virtual void LoadGrammarComplete( TInt aResultCode ) = 0;

        /**

        * Invoked when grammar has been unloaded.

        *

        * @since 2.8

        * @param "TInt aResultCode" Result of grammar loading

        */

        virtual void UnloadGrammarComplete( TInt aResultCode ) = 0;

        /**

        * Invoked when grammar has been activated.

        *

        * @since 2.0

        * @param "TInt aResultCode" Result of grammar activation

        */

        virtual void ActivateGrammarComplete( TInt aResultCode ) = 0;

        /**

        * Invoked when grammar has been deactivated.

        *

        * @since 2.0

        * @param "TInt aResultCode" Result of grammar deactivation

        */

        virtual void DeActivateGrammarComplete( TInt aResultCode ) = 0;

        /**

        * Invoked by the recognizer back-end when lexicon loading has completed.

        *

        * @since 2.0

        * @param "TInt aResultCode" Result of lexicon loading.

        */

        virtual void LoadLexiconComplete( TInt aResultCode ) = 0;

        /**

        * Invoked by the recognizer back-end when model loading has completed.

        *

        * @since 2.0

        * @param "TInt aResultCode" Result of model loading.

        */

        virtual void LoadModelsComplete( TInt aResultCode ) = 0;

        /**

        * Invoked by the recognizer when recognition process has completed.

        *

        * @since 2.0

        * @param "TInt aResultCode" Result of the recognition process.

        */

        virtual void RecognitionComplete( TInt aResultCode ) = 0;

        /**

        * Invoked by the training module when the training process has completed.

        *

        * @since 2.0

        * @param "TInt aResultCode" Result of training process.

        */

        virtual void TrainComplete( TInt aResultCode ) = 0;

        /**

        * Invoked when rule unloading has been done.

        *

        * @since 2.8

        * @param "TInt aResultCode" Result of training process.

        */

        virtual void UnloadRuleComplete( TInt aResultCode ) = 0;

        /**

        * Invoked when speech data is needed.

        *

        * @since 2.8

        */

        virtual void RequestSpeechData() = 0;

        /**

        * Invoked when result resolving is needed.

        *

        * @since 2.8

        * @param "RArray<TUint>& aNBestIDs"

        * @param "CSIResultSet& aSIResultSet"

        * @param "RPointerArray<CSICompiledGrammar>& aSICompiledGrammar"

        * @param "TDesC8& aCombinedData"

        */

        virtual void ResolveResult( const RArray<TUint>& aNBestIDs,

                                    CSIResultSet& aSIResultSet,

                                    const RPointerArray<CSICompiledGrammar>& aSICompiledGrammar,

                                    const TDesC8& aCombinedData/*,

                                    CSIModelBank& iSIModelBank*/ ) = 0;

        /**

        * Invoked when grammar combining is needed

        *

        * @since 2.8

        * @param "RPointerArray<CSICompiledGrammar>& aCompiledGrammars" 

        *        Array of previously compiled grammar

        * @param "const RPointerArray<TSIRuleVariantInfo>& aExcludedRules" 

        *        Rules to be blacklisted.

        */

        virtual void CombineGrammarL( const RPointerArray<CSICompiledGrammar>& aCompiledGrammars,

                                      const RPointerArray<TSIRuleVariantInfo>& aExcludedRules ) = 0;

    };

/**

*  This class is an aggregation of all related algorithms. It manages the algorithms

*  and coordinate transfer of data.

*

*  @lib NssDevASR.lib

*  @since 2.0

*/

class CRecognitionAlgMgr : public CActive,

                           public MASRSRecognitionHwDeviceObserver,

                           public MASRAdaptationHwDeviceObserver

    {

    public: // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CRecognitionAlgMgr* NewL( MRecAlgMgrObserver& aObserver );

        /**

        * Destructor.

        */

        virtual ~CRecognitionAlgMgr();

    public: // New functions

        /**

        * Adapts models

        *

        * @sinxe 2.8

        * @param "CSIResultSet& aResultSet" Result set reference.

        * @param "TInt aResultIndex" Index of correct result.

        * @param "TLanguage aLanguage" Language of correct result.

        */

        void AdaptModelsL( const CSIResultSet& aResultSet, TInt aResultIndex,

                           TLanguage aLanguage );

        /**

        * Cancels the current or started tasks.

        *

        * @since 2.0

        */

        void Cancel();

        /**

        * This method is used to indicate the end of a recognition session.

        * The EndRecSession() method should be used to end the session.

        *

        * @since 2.0

        */

        void EndRecSession();

        /**

        * Grammar combination has been completed.

        */

        void CombineComplete( HBufC8* aResult, TInt aError );

		/**

        * Retreive the properties of the underlying speech recognition engine.

        *

        * @since 2.0

        * @param "RArray<TInt>& aPropertyId" An array of identifiers being querried.

        * @param "RArray<TInt>& aPropertyValue" An array of values corresponding

        *        to the querried identifiers.

        */

        void GetEnginePropertiesL( const RArray<TInt>& aPropertyId, 

                                   RArray<TInt>& aPropertyValue );

        /**

        * Load the specified parameter(s) to the engines. 

        *

        * @param "RArray<TInt>& aParameterId" An array of parameter identifiers.

        * @param "RArray<TInt>& aParameterValue" An array of parameter values.

        */

        void LoadEnginePropertiesL( const RArray<TInt>& aParameterId,

                                    const RArray<TInt>& aParameterValue );

        /**

        * Retreive the duration of the utterance detected by the algorithm.

        *

        * @since 2.0

        * @param "TUint32& aStartFrame" Indicates the start frame of feature vector.

        * @param "TUint32& aEndFrame" Indicates the end frame of the feature vector.

        * @param "TReal& aFrameLength" The length of each frame

        * @return ETrue if successful

        */

        TBool GetUtteranceDuration( TUint32& aStartFrame, TUint32& aEndFrame, 

                                    TReal& aFrameLength );

        /**

        * Initializes the front-end module in the speech recognition engine.

        * The frontend module used during training/recognition functions is started

        * as a result. This method is intended to be used in conjunction with InitTrainBE().

        *

        * @since 2.0

        * @param "TRecognizerMode aFeMode" Mode of the recognizer.

        */

        void InitFrontEnd( TRecognizerMode aFeMode );

        /**

        * Initialize the recognition engine back-end. The module responsible for recognition

        * function is started as a result. This method must be used before any recognition

        * operations and intended to be used in conjunction with InitFrontEnd().

        *

        * @since 2.0

        * @param "aResult" A reference to an object where the recognition

        *        result will be written.

        */

		void InitRecognizerBE( CSIResultSet& aResult );

        /**

        * Load the specified grammar into the recognizer.

        *

        * @since 2.8

        * @param "aGrammar" A reference to a grammar in an internal format.

        */

		void LoadGrammarL( const CSIGrammar& aGrammar );

		void LoadGrammarL( const CSICompiledGrammar& aGrammar );

        /**

        * Unloads the specified grammar from the recognizer.

        *

        * @since 2.8

        * @param "aGrammar" A reference to a grammar.

        */

		void UnloadGrammarL( const CSIGrammar& aGrammar );

		void UnloadGrammarL( const CSICompiledGrammar& aGrammar );

        /**

        * Get the specified grammar.

        *

        * @since 2.8

        * @param "TSIGrammarID aGrammarID" Identifier of grammar to be found.

		* @param "CSDGrammar** aSDGrammar" Pointer to found SD grammar, 

        *         NULL if not found.

		* @param "CSICompiledGrammar** aSIActiveGrammar" Pointer to found SI 

        *        active grammar, NULL if not found.

		* @param "CSICompiledGrammar** aSIDeActivatedGrammar" Pointer to found SI 

        *        non-active grammar, NULL if not found

        */

		void GetGrammarL( const TSIGrammarID aGrammarID, 

                          CSICompiledGrammar** aSIActiveGrammar,

                          CSICompiledGrammar** aSIDeActivatedGrammar );

		/**

		* Activates a grammar.

        *

		* @since 2.8

		* @param "TSIGrammarID aGrammarID" A grammar identifier.

		*/

		void ActivateGrammarL( const TSIGrammarID aGrammarID );

		/**

		* Deactivates a grammar

        *

		* @since 2.8

		* @param "TSIGrammarID aGrammarID" A grammar identifier

		*/

		void DeactivateGrammarL( const TSIGrammarID aGrammarID );

        /**

        * Load the specified lexicon into the recognizer.

        *

        * @since 2.0

        * @param "aLexicon" A reference to a lexicon in an internal format.

        */

		void LoadLexiconL( const CSILexicon& aLexicon );

        /**

        * Load the specified model bank into the recognizer.

        *

        * @since 2.0

        * @param "aModels" A reference to a model bank.

        */

        void LoadModelsL( const CSDModelBank& aModels );

		void LoadModelsL( const CSIModelBank& aModels );

        /**

        * Use to send the utterance data as a response to the RequestSpeechData().

        *

        * @since 2.8

        * @param "TDesC8& aBuffer" Buffer containing utterance data.

        * @param "TBool aEnd" Flag to tell if given buffer is the last one.

        */

        void SendSpeechData( TPtrC8& aBuffer, TBool aEnd );

        /**

        * Request to start a recognition session.

        *

        * @since 2.0

        * @param "TRecognizerMode aMode" Mode of recognizer.

        * @return result code of request.

        */

        TInt StartRecSession( TRecognizerMode aMode );

        /**

        * Starts recognition.

        */

        void StartRecognitionL();

        /**

        * Request to unload the specified rule in the grammar from recognizer.

        *

        * @param "TSIGrammarID aGrammarID" Identifer of the grammar to operate on.

        * @param "TSIRuleID aRuleID" Identifier of the rule to remove.

        */

        void UnloadRule( TSIGrammarID aGrammarID, TSIRuleID aRuleID );

        /**

        * Used during unit testing to print the state of the algorithm

        */

        void AlgorithmState();

        /**

        * Sets rejection value

        *

        * @param "TUint32 aRejection" Rejection threshold value.

        */

        void SetRejection( TUint32 aRejection );

    public: // MASRAdaptationHwDeviceObserver

        /**

        * Called when adaptation has been done

        */

        void MaahdAdaptationComplete( TInt aError );

    public: // From MASRSRecognitionHwDeviceObserver

        /**

        * Called by the hardware device when the InitializeL() method has completed.

        * @since Series60 2.8

        * @param aError Initialization result code. 

        *               KErrNone if successful otherwise a system-wide error code.

        * @return none

        */

        void MarhdoInitializationComplete( TInt aError );

        /**

        * Called by the hardware device when the  InitializeL() method has completed.

        * @since Series60 2.8

        * @param aError Initialization result code. 

        *               KErrNone if successful otherwise a system-wide error code.

        * @return none

        */

        void MarhdoInitRecognizerFEComplete( TInt aError );

        /**

        * Called by the hardware device when backend initialization is completed.

        * @since Series60 2.8

        * @param aError Initialization result code. 

        *               KErrNone if successful otherwise a system-wide error code.

        * @return none

        */

        void MarhdoInitRecognizerBEComplete( TInt aError );

        /**

        * Called by the hardware device when recognition result is available.

        * @since Series60 2.8

        * @param aError Recognition result code. KErrNone if successful.  

        *               KErrRejected if the recognition result is rejected, 

        *               otherwise a system-wide error code

        * @return none

        */ 

        void MarhdoRecognitionComplete( TInt aError );

        /**

        * Called by the hardware device when end-of-utterance is detected by the 

        * acoustic frontend. This method must be called before MarhdoRecognitionComplete().

        * @since Series60 2.8

        * @param aError Recognition result code. KErrNone if successful, otherwise KErrTooLong, 

        *               KErrTooShort, KErrAsrSpeechTooEarly, KErrNoSpeech

        * @return none

        */

        void MarhdoEouDetected( TInt aError );

        /**

        * Called by the hardware device when a feature vector is extracted by acoustic frontend.

        * @since Series60 2.8

        * @param aFV A buffer containing a feature vector.

        * @param aSNR Signal-to-noise ratio.

        * @param aPosition Indicates whether this is the first, subsequent or last feature vector in a series.

        * @return none

        */

        void MarhdoFeatureVector( const TDesC8& aFV, TInt32 aSNR, TInt32 aPosition );

        /**

        * Called by the hardware device to request for utterance data. 

        * The response to the request is sent in SendSpeechData().

        * @since Series60 2.8

        * @param none

        * @return none

        */

        void MarhdoRequestSpeechData();

    private:

        /**

        * C++ default constructor.

        */

        CRecognitionAlgMgr(MRecAlgMgrObserver& aObserver);

        /**

        * Symbian 2nd phase constructor

        */

        void ConstructL();

        void RunL();

        void DoCancel();

        /**

        * The following methods are asynchronous handlers for the corresponding

        * synchronous calls.

        */

        void HandleInitFrontEnd();

        void HandleInitTrainBE();

        void HandleInitRecognizerBE();

        void HandleLoadGrammar();

        void HandleLoadLexicon();

        void HandleLoadModels();

        void HandleUtteranceDataRcvd();

        void HandleActivateGrammar();

        void HandleDeActivateGrammar();

        void HandleUnloadRule();

        void HandleUnloadGrammar();

        /**

        * Used to complete a request

        */

        void Ready(const TInt aStatus);

    private: // Data