/*

* Copyright (c) 2004 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:  Algorithm manager for grammar handling algorihtms.

*

*/

#ifndef DEVASRVMALGORITHMMANAGER_H

#define DEVASRVMALGORITHMMANAGER_H

//  INCLUDES

#include <e32base.h>

#include <nsssispeechrecognitiondatadevasr.h>

#include <asrsgrcompilerhwdevice.h>

#include <asrsvocmanhwdevice.h>

#include <asrsttphwdevice.h>

//#include "DevASRSrsAlgorithmManager.h"

// DATA TYPES

enum TTtpHwState

    {

    ETtpStateUninitialized = 0,

    ETtpStateIdle,

    ETtpStateBusy

    };

enum TGrCompilerState

    {

    EGrStateUninitialized = 0,

    EGrStateIdle,

    EGrStateBusyCompiling,

    EGrStateBusyCombining

    };

// FORWARD DECLARATIONS

class MDevASRObserver;

class MSDGrammarCompiler;

//class CASRGrCompilerHwDevice;

//class CASRSVocManHwDevice;

//class CASRSTtpHwDevice;

// CLASS DECLARATIONS

/**

* Observer mixin.

*

* @lib NssDevAsr.lib

* @since 2.8

*/

class MVmAlgMgrObserver

    {

    public:

        /**

        * Called when grammars have been combined.

        */

        virtual void CombineComplete( HBufC8* aResult, TInt aError ) = 0;

        /**

        * Called by CVMAlgorithmManager when it needs a grammar object.

        * 

        * @param "TSIGrammarID aGrammarID" Grammar identifier which is needed.

        * @param "CSICompiledGrammar** aSIActiveGrammar" Output parameter which will

        *        contain the grammar object pointer if grammar is currently active.

        * @param "CSICompiledGrammar** aSIDeActivatedGrammar" Output parameter which will

        *        contain the grammar object pointer if grammar is currently not active.

        */

        virtual void GetGrammarL( const TSIGrammarID aGrammarID, 

                                  CSICompiledGrammar** aSIActiveGrammar,

                                  CSICompiledGrammar** aSIDeActivatedGrammar ) = 0;

    };

/**

* Algorithm manager to handle VocMan, Ttp and Grammar Compiler

*

* @lib NssDevAsr.lib

* @since 2.8

*/

class CVMAlgorithmManager : public CBase, public MASRSTtpHwDeviceObserver, public MASRSGrCompilerHwDeviceObserver

    {

    public: // Constructors and destructor

        /**

        * Two-phased constructor.

        */

        static CVMAlgorithmManager* NewL( MDevASRObserver& aObserver, MVmAlgMgrObserver& aVmObserver );

        /**

        * Destructor.

        */

        virtual ~CVMAlgorithmManager();

    public: // New functions

        /**

        * Use to adapt rule after recognition.

        *

        * @since 2.8

        * @param "CSIResultSet& aResultSet" Result set.

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

        */

        void AdaptVocabL( const CSIResultSet& aResultSet, 

                          TInt aResultIndex );

        /**

        * Cancels training.

        *

        * @since 2.8

        */

        void Cancel();

        /**

        * Computes number of rule variants for grammar.

        *

        * @since 2.8

        * @param "CSIGrammar& aGrammar" A grammar where to add new rules.

        * @param "TUint32 aTargetNRuleVariants" Preferable target number of 

        *        all rule variants after adding new rule variants

        * @param "TUint32 aMaxNRuleVariants" Maximum number of all rule variants.

        * @param "RArray<TUint>& aNewRuleScores" Scores for each new rule. The 

        *         size of array tells also how many	new rules will be added. 

        *         Based on the scores some rules can get more rule variants 

        *         than others. If there is no scores available, the array 

        *         should initialize with constant values.

        * @param "RArray<TUint>& aNNeNRuleVariants" Array where to add number 

        *         of new rule variants for new rules. The order is equivalent 

        *         to aNewRuleScores.

        * @param "TUint32& aNPrune" Number of rule variants which should be 

        *         pruned before adding new rule variants.

        */

        void ComputeNewGrammarSizeL( const CSIGrammar& aGrammar, 

                                     const TUint32 aTargetNRuleVariants, 

                                     const TUint32 aMaxNRuleVariants, 

                                     const RArray<TUint>& aNewRuleScores, 

                                     RArray<TUint>& aNNeNRuleVariants, 

                                     TUint32& aNPrune );

        /**

        * Compiles SI or SD grammar to internal format.

        *

        * @since 2.8

        * @param "aGrammar" Reference to grammar object.

        * @param "aModelBank" Reference to model bank.

        */

        void CompileGrammarL( CSICompiledGrammar& aGrammar );

        /**

        * 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.

        */

        void CombineGrammarL( const RPointerArray<CSICompiledGrammar>& aCompiledGrammars,

                              const RPointerArray<TSIRuleVariantInfo>& aExcludedRules );

        /**

        * Determines which rule variants can be removed.

        *

        * @since 2.8

        * @param "CSIGrammar& aGrammar" A grammar to be pruned.

        * @param "TUint32 aMinNumber" Minimum number of pruned items

        * @param "RArray<TSIRuleVariantInfo> aPrunedRuleVariants" A array where 

        *         to put information which variants can be pruned.

        */

        TBool PruneGrammar( const CSIGrammar& aGrammar, 

                            const TUint32 aMinNumber, 

                            RArray<TSIRuleVariantInfo>& aPrunedRuleVariants );

        /**

        * Resolves result using Grammar Compiler.

        *

        * @since 2.8

        * @param "RArray<TUint>& aNBestIDs" List of N-best results

        * @param "

        */

        void ResolveResult( const RArray<TUint>& aNBestIDs,

                            CSIResultSet& aSIResultSet,

                            const RPointerArray<CSICompiledGrammar>& aSICompiledGrammar,

                            const TDesC8& aCombinedData );

        /**

        * Starts training from text.

        *

        * @since 2.8

        * @param "CSITtpWordList& aWordList" Text for training.

        * @param "RArray<TLanguage>& aDefaultLanguage" Default language for 

        *        pronunciations.

        * @param "RArray<TUint32>& aMaxNPronunsForWord" Maximum number of 

        *        pronunciation per word.

        */

        void TrainFromTextL( CSITtpWordList& aWordList, 

                             const RArray<TLanguage>& aDefaultLanguage, 

                             const RArray<TUint32>& aMaxNPronunsForWord );

		/**

        * Retreive the properties of the engines.

        *

        * @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 );

    public: // From MASRTtpHwDeviceObserver

        /**

        * Callback function to load configuration data.

        *

        * @param "TUint32 aPackageType" Type identifier.

        * @param "TUint32 aPackageID" Package identifier.

        * @param "TUint32 aStartPosition" First byte.

        * @param "TUint32 aEndPosition" Last byte. If greater than the size of 

        *                               the data, rest of the data is given.

        * @return Pointer to the data buffer, TTP HW Device takes ownership.

        */	

        HBufC8* MathdoConfigurationData( TUint32 aPackageType, TUint32 aPackageID,

                                         TUint32 aStartPosition = 0,

                                         TUint32 aEndPosition = KMaxTUint32 );

		/**

        * Callback function to notify that word list is converted.

        *

        * @param "TInt aError" Error code, KErrNone if successful.

        */	

		void MathdoWordListReady( const TInt aError );

    public: // From MASRSGrCompilerObserver

        /**

        * Grammar has been compiled.

        *

        * @param "TInt aError" An error code.

        */

        void MghdoGrammarCompilerComplete( TInt aError );

        /**

        * Grammars have been combined.

        *

        * @param "HBufC8* aResult" Contains the compiled grammar, NULL if error

        *         happened.

        * @param "TInt aError" KErrNone if successful.

        */

        void MghdoGrammarCombinerComplete( HBufC8* aResult, TInt aError );

        /**

        * Called when GrCompilerHwDevice needs an SI lexicon.

        *

        * @param "TSILexiconID anID" Requested lexicon id.

        * @return Pointer to created lexicon.

        */

        CSILexicon* MghdoSILexiconL( TSILexiconID anID );

        /**

        * Called when GrCompiler needs configuration data package

        */

        HBufC8* MghdoConfigurationData( TUint32 aPackageType,

                                        TUint32 aPackageID,

                                        TUint32 aStartPosition = 0,

                                        TUint32 aEndPosition = KMaxTUint32 );

    private:

/*        void DeleteData( TPtrC8& aData );*/

        /**

        * C++ default constructor.

        */

        CVMAlgorithmManager( MDevASRObserver& aObserver, MVmAlgMgrObserver& aVmObserver );

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();

        // Prohibit copy constructor

        CVMAlgorithmManager( const CVMAlgorithmManager& );

        // Prohibit assigment operator

        CVMAlgorithmManager& operator=( const CVMAlgorithmManager& );

    private: // Data

        // Grammar compiler HW device

        CASRSGrCompilerHwDevice* iGrCompiler;

        // Vocabulary management HW device

        CASRSVocManHwDevice* iVocMan;

        // TTP HW device

        CASRSTtpHwDevice* iTtp;

        // Observer

        MDevASRObserver& iObserver;

        // Array for data pointers

//        RPointerArray<HBufC8> iDataArray;

        // TtpHwDevice state

        TTtpHwState iTtpState;

        // GrCompilerHwDeviceState

        TGrCompilerState iGrState;

        // Our own observer

        MVmAlgMgrObserver& iVmAlgObserver;

    };

#endif // DEVASRVMALGORITHMMANAGER_H

// End of File