/*

* 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 is the implementation of the speech recognition utility.

*

*/

// INCLUDE FILES

#include "rubydebug.h"

#include "srsfbldvariant.hrh"

#include "nsssispeechrecognitionutility.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::CSISpeechRecognitionUtility

// C++ default constructor.

// -----------------------------------------------------------------------------

//

CSISpeechRecognitionUtility::CSISpeechRecognitionUtility(

	MSISpeechRecognitionUtilityObserver& aSpeechRecognitionUtilityObserver ) : 

	iSrCustomCommands(iMMFController)

	{	

	iSpeechRecognitionUtilityObserver = &aSpeechRecognitionUtilityObserver;

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::CreateInstanceL

// Creates instance of CSISpeechRecognitionUtility

// Needed when dynamically loading nsssispeechrecognitionutility.dll

// -----------------------------------------------------------------------------

//

EXPORT_C TAny* CSISpeechRecognitionUtility::CreateInstanceL()

    {

    CSISpeechRecognitionUtility* utility = new (ELeave) CSISpeechRecognitionUtility();

    return static_cast<MSISpeechRecognitionUtilityBase*>( utility );

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::CreateInstanceSecondPhaseL

// Does second phase construction after CreateInstanceL

// Needed when dynamically loading nsssispeechrecognitionutility.dll

// -----------------------------------------------------------------------------

//

EXPORT_C void CSISpeechRecognitionUtility::CreateInstanceSecondPhaseL( TUid aClientUid, 

                                                                       TUid aPluginUid, 

                                                                       MSISpeechRecognitionUtilityObserver& aObserver )

    {

    ConstructL( aClientUid, aPluginUid, aObserver );

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::CSISpeechRecognitionUtility

// C++ default constructor.

// -----------------------------------------------------------------------------

//

CSISpeechRecognitionUtility::CSISpeechRecognitionUtility(): iSrCustomCommands( iMMFController )

    {	

    // Nothing

    }

// -----------------------------------------------------------------------------

// FindSpeechPluginL

// Searches for SI Controller Plugin.

// -----------------------------------------------------------------------------

//

TUid FindSpeechPluginL()

    {

    RUBY_DEBUG_BLOCK( "CSISpeechRecognitionUtility::FindSpeechPluginL" );

	RMMFControllerImplInfoArray controllers;

	CleanupResetAndDestroyPushL(controllers);

	CMMFControllerPluginSelectionParameters* selectionParams = 

					CMMFControllerPluginSelectionParameters::NewLC();

	// Select the media IDs to allow

	RArray<TUid> mediaIds;

	CleanupClosePushL(mediaIds);

	User::LeaveIfError(mediaIds.Append(KUidMediaTypeSI));

	selectionParams->SetMediaIdsL(mediaIds,

			CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);

	CleanupStack::PopAndDestroy(&mediaIds);

	selectionParams->ListImplementationsL(controllers);	

	// make sure at least on controller has been found

	if( ! controllers.Count() )

	    {

        RUBY_DEBUG1( "No controllers found using media type %x", KUidMediaTypeSI );

		User::Leave( KErrNotFound );

    	}

    TUid result = controllers[0]->Uid();

    CleanupStack::PopAndDestroy( 2 );

    return( result );

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CSISpeechRecognitionUtility::ConstructL( TUid aClientUid, 

                                              TUid aPluginUid, 

                                              MSISpeechRecognitionUtilityObserver& aObserver )

    {

    RUBY_DEBUG_BLOCK( "CSISpeechRecognitionUtility::ConstructL" );

    iSpeechRecognitionUtilityObserver = &aObserver;

    // dummy priority settings, they are set for real when record, recognize 

    // and playback are called

    TMMFPrioritySettings prioritySettings;

    prioritySettings.iPriority = 0;

    prioritySettings.iPref = (TMdaPriorityPreference) 0;

    prioritySettings.iState = EMMFStateIdle; // idle

    if ( aPluginUid.iUid == 0 )

        {

        aPluginUid = FindSpeechPluginL();

        }

    // load the controller

    // coded this way for debugging

    TInt err;

    if ((err = iMMFController.Open(aPluginUid, prioritySettings))

        == KErrNone) 

        {

        // start the event monitor

        iControllerEventMonitor = 

            CMMFControllerEventMonitor::NewL(*this, iMMFController);

        iControllerEventMonitor->Start();

        }

    else

        {

        RUBY_DEBUG2( "Unable to load controller plugin, error = %d, UID = %x", err, aPluginUid.iUid );

        User::Leave(err);

        }

    User::LeaveIfError(iSrCustomCommands.SetClientUid(aClientUid));

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSISpeechRecognitionUtility* CSISpeechRecognitionUtility::NewL(

	MSISpeechRecognitionUtilityObserver& aSpeechRecognitionUtilityObserver, TUid aClientUid)

	{

	CSISpeechRecognitionUtility* self = NewLC(aSpeechRecognitionUtilityObserver, aClientUid);

	// remove the pointer from the cleanup stack

	CleanupStack::Pop( self );	

    return self;

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::NewLC

// Two-phased constructor, leaves a pointer to the object on the stack.

// -----------------------------------------------------------------------------

//

EXPORT_C CSISpeechRecognitionUtility* CSISpeechRecognitionUtility::NewLC(

	MSISpeechRecognitionUtilityObserver& aSpeechRecognitionUtilityObserver, TUid aClientUid)

	{

	CSISpeechRecognitionUtility* self = new (ELeave)  

		CSISpeechRecognitionUtility(aSpeechRecognitionUtilityObserver);

    // push onto cleanup stack 

    // (in case self->ConstructL leaves)

    CleanupStack::PushL(self);

	// use two-stage construct

    // Plugin UID == 0 -> List all plugins and pick any suitable

    self->ConstructL( aClientUid, KNullUid, aSpeechRecognitionUtilityObserver );

    return self;

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSISpeechRecognitionUtility* CSISpeechRecognitionUtility::NewL(

	MSISpeechRecognitionUtilityObserver& aSpeechRecognitionUtilityObserver,

    TUid aClientUid,

    TUid aMmfPluginUid )

    {

	CSISpeechRecognitionUtility* self = new (ELeave)  

		CSISpeechRecognitionUtility(aSpeechRecognitionUtilityObserver);

    // push onto cleanup stack 

    // (in case self->ConstructL leaves)

    CleanupStack::PushL( self );

	// use two-stage construct

    self->ConstructL(aClientUid, aMmfPluginUid, aSpeechRecognitionUtilityObserver);      

    CleanupStack::Pop( self );

    return( NULL );

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::~CSISpeechRecognitionUtility

// The destructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CSISpeechRecognitionUtility::~CSISpeechRecognitionUtility()

	{

	// indicate we don't want any callbacks

	SetEventHandler(NULL);

	// cancel any pending requests

	if ( iControllerEventMonitor )	// make sure we have a valid pointer

	{

		iControllerEventMonitor->Cancel();

	}

	delete iControllerEventMonitor;

	iMMFController.Close();

    REComSession::FinalClose();

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::GetEngineProperties

// Retreive the properties of the underlying speech recognition engine. Returns

// an object containing the engine properties in the aProperties variable.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::GetEngineProperties(

	const RArray<TInt>& aPropertyId, 

	RArray<TInt>& aPropertyValue)

	{

	return iSrCustomCommands.GetEngineProperties(aPropertyId, 

									aPropertyValue);

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::Adapt

// Performs adaptation for acoustic models based on correct result.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::Adapt(

    const CSIClientResultSet& aResultSet,

    TInt aCorrect )

    {

    return iSrCustomCommands.Adapt( aResultSet, aCorrect );

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::AddPronunciation

// Adds a new pronunciation into the Lexicon. Returns an the ID of the 

// pronunciation in the aPronunciationID variable.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::AddPronunciation(

    TSILexiconID aLexiconID,

    const TDesC& aTextForTraining,

    TLanguage aLanguage,

    TSIPronunciationID& aPronunciationID)

    {

    return iSrCustomCommands.AddPronunciation( aLexiconID, aTextForTraining,

                                               aLanguage, aPronunciationID );

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::AddRule

// Adds a new rule into the Grammar. Returns an the ID of the pronunciation 

// in the aPronunciationID variable.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::AddRule(

	TSIGrammarID aGrammarID, 

	TSILexiconID aLexiconID, 

	TSIPronunciationID aPronunciationID, 

	TSIRuleID& aRuleID)

	{

	// async

	return iSrCustomCommands.AddRule(aGrammarID, aLexiconID, 

				aPronunciationID, aRuleID);

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::AddRuleVariant

// Adds a new rule variant for the given pronunciation into the 

// specified grammar.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::AddRuleVariant(

    TSIGrammarID aGrammarID,

    TSILexiconID aLexiconID,

    RArray<TSIPronunciationID>& aPronunciationIDs,

    TSIRuleID aRuleID,

    TSIRuleVariantID& aRuleVariantID )

    {

    return iSrCustomCommands.AddRuleVariant( aGrammarID, aLexiconID, aPronunciationIDs, aRuleID, aRuleVariantID );

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::AddVoiceTag

// Adds a new rule for the given phrase into the 

// specified grammar.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::AddVoiceTag( MDesCArray& aTextArray,

                                                        const RArray<TLanguage>& aLanguageArray,

                                                        TSILexiconID aLexiconID,

                                                        TSIGrammarID aGrammarID,

                                                        TSIRuleID& aRuleID )

    {

    return iSrCustomCommands.AddVoiceTag( aTextArray, aLanguageArray,

                                          aLexiconID, aGrammarID, aRuleID );

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::AddVoiceTag

// Adds a new rule for the given phrase into the 

// specified grammar.

// -----------------------------------------------------------------------------

//

#ifdef __SINDE_TRAINING

EXPORT_C TInt CSISpeechRecognitionUtility::AddVoiceTag( MDesCArray& aTextArray,

                                                        const RArray<RLanguageArray>& aLanguageArray,

                                                        TSILexiconID aLexiconID,

                                                        TSIGrammarID aGrammarID,

                                                        TSIRuleID& aRuleID )

    {

    return iSrCustomCommands.AddVoiceTag( aTextArray, aLanguageArray,

                                          aLexiconID, aGrammarID, aRuleID );

    }

#else

EXPORT_C TInt CSISpeechRecognitionUtility::AddVoiceTag( MDesCArray& /*aTextArray*/,

                                                        const RArray<RLanguageArray>& /*aLanguageArray*/,

                                                        TSILexiconID /*aLexiconID*/,

                                                        TSIGrammarID /*aGrammarID*/,

                                                        TSIRuleID& /*aRuleID*/ )

    {

    return KErrNotSupported;

    }

#endif // __SINDE_TRAINING

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::AddVoiceTags

// Adds a new rules for the given phrases into the 

// specified grammar.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::AddVoiceTags( const RPointerArray<MDesCArray>& aTextArrayArray,

                                                         const RArray<TLanguage>& aLanguageArray,

                                                         TSILexiconID aLexiconID,

                                                         TSIGrammarID aGrammarID, 

                                                         RArray<TSIRuleID>& aRuleIDArray )

    {

    if ( iRuleIDs != 0 )

        {

        return( KErrInUse );

        }

    iRuleIDs = &aRuleIDArray;

    return iSrCustomCommands.AddVoiceTags( aTextArrayArray, aLanguageArray,

                                           aLexiconID, aGrammarID, aRuleIDArray);

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::AddVoiceTags

// Adds a new rules for the given phrases into the 

// specified grammar.

// -----------------------------------------------------------------------------

//

#ifdef __SINDE_TRAINING

EXPORT_C TInt CSISpeechRecognitionUtility::AddVoiceTags( const RPointerArray<MDesCArray>& aTextArrayArray,

                                                         const RArray<RLanguageArray>& aLanguageArray,

                                                         TSILexiconID aLexiconID,

                                                         TSIGrammarID aGrammarID, 

                                                         RArray<TSIRuleID>& aRuleIDArray )

    {

    if ( iRuleIDs != 0 )

        {

        return( KErrInUse );

        }

    iRuleIDs = &aRuleIDArray;

    return iSrCustomCommands.AddVoiceTags( aTextArrayArray, aLanguageArray,

                                           aLexiconID, aGrammarID, aRuleIDArray );

    }

#else

EXPORT_C TInt CSISpeechRecognitionUtility::AddVoiceTags( const RPointerArray<MDesCArray>& /*aTextArrayArray*/,

                                                         const RArray<RLanguageArray>& /*aLanguageArray*/,

                                                         TSILexiconID /*aLexiconID*/,

                                                         TSIGrammarID /*aGrammarID*/, 

                                                         RArray<TSIRuleID>& /*aRuleIDArray*/ )

    {

    return KErrNotSupported;

    }

#endif // __SINDE_TRAINING

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::Cancel

// Cancel the current asynchronous operation.

// -----------------------------------------------------------------------------

//

EXPORT_C void CSISpeechRecognitionUtility::Cancel()

	{

	iSrCustomCommands.Cancel();

	// Now cancel has been called, so we can get rid of pointers

	iPronunciationIDs = NULL;

	iRuleIDs = NULL;

	iModelIDs = NULL;

	iResultSet = NULL;

	iGrammarIDs = NULL;

	iLexiconIDs = NULL;

	iModelBankIDs = NULL;

    iSIResultSet = NULL;

    iResultSet = NULL;

	}

// -----------------------------------------------------------------------------

// CSpeechRecognitionCustomCommandParser::CommitChanges

// Commit the current changes to permanent storage.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::CommitChanges()

	{

	// async

	return iSrCustomCommands.CommitChanges();

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::CreateGrammar

// Create a new grammar.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::CreateGrammar(

	TSIGrammarID& aGrammarID)

	{

	// async

	return iSrCustomCommands.CreateGrammar(aGrammarID);

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::CreateLexicon

// Create a new lexicon.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::CreateLexicon(

	TSILexiconID& aLexiconID)

	{

	// async

	return iSrCustomCommands.CreateLexicon(aLexiconID);

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::CreateRule

// Creates a new rule.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::CreateRule(

    TSIGrammarID aGrammarID,

    TSIRuleID& aRuleID )

    {

    return iSrCustomCommands.CreateRule( aGrammarID, aRuleID );

    }

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::LoadModels

// Loads the model specified by aModelBankID into the recognizer.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::LoadModels(

	TSIModelBankID aModelBankID)

	{

	// async

	return iSrCustomCommands.LoadModels(aModelBankID);

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::LoadGrammar

// Loads the grammar specified by aGrammarID into the recognizer.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::LoadGrammar(

	TSIGrammarID aGrammarID)

	{

	// async

	return iSrCustomCommands.LoadGrammar(aGrammarID);

	}

// -----------------------------------------------------------------------------

// CSISpeechRecognitionUtility::ActivateGrammar

// Activates the grammar.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CSISpeechRecognitionUtility::ActivateGrammar(

	TSIGrammarID aGrammarID)

	{

	// async

	return iSrCustomCommands.ActivateGrammar(aGrammarID);

	}