/*

* 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 server side for the

*               speaker independent controller.

*

*/

// INCLUDE FILES

#include "srsfbldvariant.hrh"

#include <e32std.h>

#include <nsssispeechrecognitioncustomcommandparser.h>

#include <nsssispeechrecognitioncustomcommands.h>

#include "nsssispeechrecognitioncustomcommandcommon.h"

#include "nsssicustomcommanddata.h"

#include "rubydebug.h"

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

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

// CSISpeechRecognitionCustomCommandParser::CSISpeechRecognitionCustomCommandParser

// C++ constructor.

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

//

CSISpeechRecognitionCustomCommandParser::CSISpeechRecognitionCustomCommandParser(

	MSISpeechRecognitionCustomCommandImplementor& aImplementor) :

	CMMFCustomCommandParserBase(KUidInterfaceSpeakerIndependent),

	iImplementor(aImplementor),

    iAdaptationSet( 0 )

	{

	}

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

// CSISpeechRecognitionCustomCommandParser::NewL

// Two-phased constructor.

// (other items were commented in a header).

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

//

EXPORT_C CSISpeechRecognitionCustomCommandParser* 

			CSISpeechRecognitionCustomCommandParser::NewL(

	MSISpeechRecognitionCustomCommandImplementor& aImplementor)

	{

	return new(ELeave) CSISpeechRecognitionCustomCommandParser(aImplementor);

	}

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

// CSISpeechRecognitionCustomCommandParser::~CSISpeechRecognitionCustomCommandParser

// Destructor for CSISpeechRecognitionCustomCommandParser class

// (other items were commented in a header).

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

//

EXPORT_C CSISpeechRecognitionCustomCommandParser::

			~CSISpeechRecognitionCustomCommandParser()

	{

	iPronunciationIDs.Close();

	iRuleIDs.Close();

	iModelIDs.Close();

	iGrammarIDs.Close();

	iLexiconIDs.Close();

	iModelBankIDs.Close();

    iLanguageArray.Close();

    for ( TInt i = 0; i < iLanguageArrayArray.Count(); i++ )

        {

        iLanguageArrayArray[i].Close();

        }

    iLanguageArrayArray.Close();

	delete iResultCopyBuffer;	

	//delete iResultSet;

    delete iSIResultSet;

    delete iWordArray;

    delete iAdaptationSet;

	}

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

// CSISpeechRecognitionCustomCommandParser::HandleRequest

// Handles the client side request.

// (other items were commented in a header).

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

//

void CSISpeechRecognitionCustomCommandParser::HandleRequest(

	TMMFMessage& aMessage)

	{

	ASSERT(aMessage.Destination().InterfaceId() == 

						KUidInterfaceSpeakerIndependent);

	TRAPD(error, DoHandleRequestL(aMessage));

	if(error)

		aMessage.Complete(error);

	}

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

// CSISpeechRecognitionCustomCommandParser::DoHandleRequestL

// Decodes aMessage and calls the correct function. This function is trapped by

// HandleRequest() and the leave code, if any, sent to the client.

// (other items were commented in a header).

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

//

void CSISpeechRecognitionCustomCommandParser::DoHandleRequestL(

	TMMFMessage& aMessage)

    {

    TPckgBuf<TInt> pckgSize;

    // call required function to do the requested operation

    switch( aMessage.Function() )

        {

        case ESrAddPronunciation:

            DoAddPronunciationL(aMessage);

            break;

        case ESrAddRule:

            DoAddRuleL(aMessage);

            break;

        case ESrCancel:

            DoCancel();

            break;

        case ESrCommitChanges:

            DoCommitChangesL();

            break;

        case ESrCreateGrammar:

            DoCreateGrammarL(aMessage);

            break;

        case ESrCreateLexicon:

            DoCreateLexiconL(aMessage);

            break;

        case ESrCreateModelBank:

            DoCreateModelBankL(aMessage);

            break;

        case ESrEndRecSession:

            DoEndRecSessionL();

            break;

        case ESrGetAllClientGrammarIDs:

            DoGetAllClientGrammarIDsL();

            break;

        case ESrGetAllClientLexiconIDs:

            DoGetAllClientLexiconIDsL();

            break;

        case ESrGetAllClientModelBankIDs:

            DoGetAllClientModelBankIDsL();

            break;

        case ESrGetAllGrammarIDs:

            DoGetAllGrammarIDsL();

            break;

        case ESrGetAllLexiconIDs:

            DoGetAllLexiconIDsL();

            break;

        case ESrGetAllModelBankIDs:

            DoGetAllModelBankIDsL();

            break;

        case ESrGetAllModelIDs:

            DoGetAllModelIDsL(aMessage);

            break;

        case ESrGetAllPronunciationIDs:

            DoGetAllPronunciationIDsL(aMessage);

            break;

        case ESrGetAllRuleIDs:

            DoGetAllRuleIDsL(aMessage);

            break;

        case ESrGetAvailableStorage:

            DoGetAvailableStorageL(aMessage);

            break;

        case ESrGetEngineProperties:

            DoGetEnginePropertiesL(aMessage);

            break;

        case ESrGetModelCount:

            DoGetModelCountL(aMessage);

            break;

        case ESrGetRuleValidity:

            DoGetRuleValidityL(aMessage);

            break;

        case ESrUtteranceDuration:

            DoGetUtteranceDurationL(aMessage);

            break;

        case ESrLoadGrammar:

            DoLoadGrammarL(aMessage);

            break;

        case ESrActivateGrammar:

            DoActivateGrammarL(aMessage);

            break;

        case ESrDeactivateGrammar:

            DoDeactivateGrammarL(aMessage);

            break;

        case ESrLoadLexicon:

            DoLoadLexiconL(aMessage);

            break;

        case ESrLoadModels:

            DoLoadModelsL(aMessage);

            break;

        case ESrPlayUtterance:

            DoPlayUtteranceL(aMessage);

            break;

        case ESrRecognize:

            DoRecognizeL(aMessage);

            break;

        case ESrRecord:

            DoRecordL(aMessage);

            break;

        case ESrRemoveGrammar:

            DoRemoveGrammarL(aMessage);

            break;

        case ESrRemoveLexicon:

            DoRemoveLexiconL(aMessage);

            break;

        case ESrRemoveModelBank:

            DoRemoveModelBankL(aMessage);

            break;

        case ESrRemoveModel:

            DoRemoveModelL(aMessage);

            break;

        case ESrRemovePronunciation:

            DoRemovePronunciationL(aMessage);

            break;

        case ESrRemoveRule:

            DoRemoveRuleL(aMessage);

            break;

        case ESrRemoveRules:

            RUBY_DEBUG0( "CSISpeechRecognitionCustomCommandParser::DoHandleRequestL. case ESrRemoveRules" );

            DoRemoveRulesL( aMessage );

            break;

        case ESrSetClientUid:

            DoSetClientUidL(aMessage);

            break;

        case ESrStartRecSession:

            DoStartRecSessionL(aMessage);

            break;

        case ESrTrain:

            DoTrainL(aMessage);

            break;

        case ESrUnloadRule:

            DoUnloadRuleL(aMessage);

            break;

        case ESrLoadEngineParameters:

            DoLoadEngineParametersL(aMessage);

            break;

        case ESrGetPronunciationIDArraySize:

            pckgSize() = iPronunciationIDs.Count();

            aMessage.WriteDataToClientL(pckgSize);

            break;

        case ESrGetPronunciationIDArrayContents:

            DoCopyPronunciationIDArrayL(aMessage);

            break;

        case ESrGetRuleIDArraySize:

            pckgSize() = iRuleIDs.Count();

            aMessage.WriteDataToClientL(pckgSize);

            break;

        case ESrGetRuleIDArrayContents:

            DoCopyRuleIDArrayL(aMessage);			

            break;

        case ESrGetModelIDArraySize:

            pckgSize() = iModelIDs.Count();

            aMessage.WriteDataToClientL(pckgSize);

            break;

        case ESrGetModelIDArrayContents:

            DoCopyModelIDArrayL(aMessage);

            break;

        case ESrGetGrammarIDArraySize:

            pckgSize() = iGrammarIDs.Count();

            aMessage.WriteDataToClientL(pckgSize);

            break;

        case ESrGetGrammarIDArrayContents:

            DoCopyGrammarIDArrayL(aMessage);

            break;

        case ESrGetLexiconIDArraySize:

            pckgSize() = iLexiconIDs.Count();

            aMessage.WriteDataToClientL(pckgSize);

            break;

        case ESrGetLexiconIDArrayContents:

            DoCopyLexiconIDArrayL(aMessage);

            break;

        case ESrGetModelBankIDArraySize:

            pckgSize() = iModelBankIDs.Count();

            aMessage.WriteDataToClientL(pckgSize);

            break;

        case ESrGetModelBankIDArrayContents:

            DoCopyModelBankIDArrayL(aMessage);

            break;

        case ESrGetClientResultSetSize:

            DoExternalizeResultSetL();

            pckgSize() = iResultCopyBuffer->Size();

            aMessage.WriteDataToClientL(pckgSize);

            break;

        case ESrGetClientResultSetSizeSI:

            DoExternalizeSIResultSetL();

            pckgSize() = iResultCopyBuffer->Size();

            aMessage.WriteDataToClientL(pckgSize);

            break;

        case ESrGetClientResultSet:

            DoCopyResultSetL(aMessage);

            break;

            // SI main requests

        case ESrAdapt:

            DoAdaptL( aMessage );

            break;

        case ESrAddPronunciationSI:

            DoAddPronunciationSIL( aMessage );

            break;

        case ESrAddRuleVariant:

            DoAddRuleVariantL( aMessage );

            break;

        case ESrAddVoiceTag:

            DoAddVoiceTagL( aMessage );

            break;

        case ESrAddVoiceTags:

            DoAddVoiceTagsL( aMessage );

            break;

        case ESrCreateRule:

            DoCreateRuleL( aMessage );

            break;

        case ESrEndRecord:

            DoEndRecordL( aMessage );

            break;

        case ESrRecognizeSI:

            DoRecognizeSIL( aMessage );

            break;

        case ESrUnloadGrammar:

            DoUnloadGrammarL( aMessage );

            break;

        case ESrAddSindeVoiceTag:

            DoAddSindeVoiceTagL( aMessage );

            break;

        case ESrAddSindeVoiceTags:

            DoAddSindeVoiceTagsL( aMessage );

            break;

        case ESrPreStartSampling:

            DoPreStartSamplingL( aMessage );

            break;

        default:

            RUBY_DEBUG1( "CSISpeechRecognitionCustomCommandParser::DoHandleRequestL. Unknown function [%d]. Leaving", aMessage.Function() );

            User::Leave(KErrNotSupported);

        }	// end of switch

    aMessage.Complete(KErrNone);

    }

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

// CSISpeechRecognitionCustomCommandParser::DoAddPronunciationL

// Calls the controller plugin to add a pronunciation.

// (other items were commented in a header).

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

void CSISpeechRecognitionCustomCommandParser::DoAddPronunciationL(

	TMMFMessage& /*aMessage*/)

	{

    RUBY_DEBUG0( "CSISpeechRecognitionCustomCommandParser::DoAddPronunciationL is NOT supported" );

    User::Leave( KErrNotSupported );

	}

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

// CSISpeechRecognitionCustomCommandParser::DoAddRuleL

// Calls the controller plugin to add a rule.

// (other items were commented in a header).

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

//

void CSISpeechRecognitionCustomCommandParser::DoAddRuleL(

	TMMFMessage& aMessage)

	{

	// Async

	TSrsAddRulePckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	TSrsAddRule srsAddRule = pckg();

	iImplementor.MSrAddRuleL( srsAddRule.iGrammarID, srsAddRule.iLexiconID,

							 srsAddRule.iPronunciationID, *srsAddRule.iRuleID );

	}

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

// CSISpeechRecognitionCustomCommandParser::DoCancel

// Calls the controller plugin to cancel the currect asynchronous operation.

// (other items were commented in a header).

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

//

void CSISpeechRecognitionCustomCommandParser::DoCancel()

	{

	iImplementor.MSrCancel();

	}

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

// CSISpeechRecognitionCustomCommandParser::DoCommitChanges

// Saves the current trained model into a permanent storage.

// (other items were commented in a header).

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

//

void CSISpeechRecognitionCustomCommandParser::DoCommitChangesL()

	{

	iImplementor.MSrCommitChangesL();

	}

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

// CSISpeechRecognitionCustomCommandParser::DoCreateGrammarL

// Calls the controller plugin to create a grammar.

// (other items were commented in a header).

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

//

void CSISpeechRecognitionCustomCommandParser::DoCreateGrammarL(

	TMMFMessage& aMessage)

	{

	TSrsGrammarIDPtrPckg srsGrammarIDPtrPckg;

	aMessage.ReadData1FromClientL(srsGrammarIDPtrPckg);

	TSIGrammarID* grammarID = srsGrammarIDPtrPckg();

	iImplementor.MSrCreateGrammarL(*grammarID) ;

	}

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

// CSISpeechRecognitionCustomCommandParser::DoCreateLexiconL

// Calls the controller plugin to create a lexicon.

// (other items were commented in a header).

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

//

void CSISpeechRecognitionCustomCommandParser::DoCreateLexiconL(

	TMMFMessage& aMessage)

	{

	TSrsLexiconIDPtrPckg srsLexiconIDPtrPckg;

	aMessage.ReadData1FromClientL(srsLexiconIDPtrPckg);

	TSILexiconID* lexiconID = srsLexiconIDPtrPckg();

	iImplementor.MSrCreateLexiconL(*lexiconID) ;

	}

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

// CSISpeechRecognitionCustomCommandParser::DoCreateModelBankL

// Calls the controller plugin to create a model bank.

// (other items were commented in a header).

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

//

void CSISpeechRecognitionCustomCommandParser::DoCreateModelBankL(

	TMMFMessage& aMessage)

	{

	TSrsModelBankIDPtrPckg modelBankIDPtrPckg;

	aMessage.ReadData1FromClientL(modelBankIDPtrPckg);

	TSIModelBankID* modelBankID = modelBankIDPtrPckg();

	iImplementor.MSrCreateModelBankL(*modelBankID);

	}