// Copyright (c) 2003-2009 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:

//

#include <mmf/common/speechrecognitioncustomcommandparser.h>

#include "SpeechRecognitionCustomCommandCommon.h"

const TInt KExpandSize = 10;

EXPORT_C CSpeechRecognitionCustomCommandParser* CSpeechRecognitionCustomCommandParser::NewL(

							MSpeechRecognitionCustomCommandImplementor& aImplementor)

	{

	CSpeechRecognitionCustomCommandParser* self = new (ELeave) CSpeechRecognitionCustomCommandParser(aImplementor);

	return self;

	}

EXPORT_C CSpeechRecognitionCustomCommandParser::~CSpeechRecognitionCustomCommandParser()

	{

	iPronunciationIDs.Close();

	iRuleIDs.Close();

	iModelIDs.Close();

	iModelBankIDs.Close();

	iGrammarIDs.Close();

	iLexiconIDs.Close();

	delete iResultSet;

	delete iResultCopyBuffer;	

	}

void CSpeechRecognitionCustomCommandParser::HandleRequest(TMMFMessage& aMessage)

	{

	TInt err;

	if (aMessage.Destination().InterfaceId() == KUidInterfaceSpeechRecognition)

		{

		TRAP(err, DoHandleRequestL(aMessage));

		aMessage.Complete(err);

		}

	else

		aMessage.Complete(KErrNotSupported);

	}

CSpeechRecognitionCustomCommandParser::CSpeechRecognitionCustomCommandParser(MSpeechRecognitionCustomCommandImplementor& aImplementor)

	: CMMFCustomCommandParserBase(KUidInterfaceSpeechRecognition), iImplementor(aImplementor)

	{

	}

void CSpeechRecognitionCustomCommandParser::DoHandleRequestL(TMMFMessage& aMessage)

	{	

	TPckgBuf<TInt> pckgSize;

	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 ESrGetAllModelIDs:

			DoGetAllModelIDsL(aMessage);

			break;

		case ESrGetAllPronunciationIDs:

			DoGetAllPronunciationIDsL(aMessage);

			break;

		case ESrGetAllRuleIDs:

			DoGetAllRuleIDsL(aMessage);

			break;

		case ESrGetAllModelBankIDs:

			DoGetAllModelBankIDsL();

			break;

		case ESrGetAllLexiconIDs:

			DoGetAllLexiconIDsL();

			break;

		case ESrGetAllGrammarIDs:

			DoGetAllGrammarIDsL();

			break;

		case ESrGetAllClientModelBankIDs:

			DoGetAllClientModelBankIDsL();

			break;

		case ESrGetAllClientLexiconIDs:

			DoGetAllClientLexiconIDsL();

			break;

		case ESrGetAllClientGrammarIDs:

			DoGetAllClientGrammarIDsL();

			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 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 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 ESrGetLexiconIDArraySize:

			pckgSize() = iLexiconIDs.Count();

			aMessage.WriteDataToClientL(pckgSize);

			break;

		case ESrGetLexiconIDArrayContents:

			DoCopyLexiconIDArrayL(aMessage);

			break;

		case ESrGetGrammarIDArraySize:

			pckgSize() = iGrammarIDs.Count();

			aMessage.WriteDataToClientL(pckgSize);

			break;

		case ESrGetGrammarIDArrayContents:

			DoCopyGrammarIDArrayL(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 ESrGetClientResultSet:

			DoCopyResultSetL(aMessage);

			break;

		case ESrSetClientUid:

			DoSetClientUidL(aMessage);

			break;

		default:

			User::Leave(KErrNotSupported);

			break;

		}

	}

void CSpeechRecognitionCustomCommandParser::DoAddPronunciationL(TMMFMessage& aMessage)

	{

	TSrsAddPronunciationPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrAddPronunciationL(pckg().iLexiconID, pckg().iModelBankID, pckg().iModelID, *pckg().iPronunciationID);

	}

void CSpeechRecognitionCustomCommandParser::DoAddRuleL(TMMFMessage& aMessage)

	{

	TSrsAddRulePckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrAddRuleL(pckg().iGrammarID, pckg().iLexiconID, pckg().iPronunciationID, *pckg().iRuleID);

	}

void CSpeechRecognitionCustomCommandParser::DoCancel()

	{

	iImplementor.MSrCancel();

	}

void CSpeechRecognitionCustomCommandParser::DoCommitChangesL()

	{

	iImplementor.MSrCommitChangesL();

	}

void CSpeechRecognitionCustomCommandParser::DoCreateGrammarL(TMMFMessage& aMessage)

	{

	TSrsGrammarIDPtrPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrCreateGrammarL(*pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoCreateLexiconL(TMMFMessage& aMessage)

	{

	TSrsLexiconIDPtrPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrCreateLexiconL(*pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoCreateModelBankL(TMMFMessage& aMessage)

	{

	TSrsModelBankIDPtrPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrCreateModelBankL(*pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoEndRecSessionL()

	{

	iImplementor.MSrEndRecSessionL();

	}

void CSpeechRecognitionCustomCommandParser::DoGetAllModelIDsL(TMMFMessage& aMessage)

	{

	TSrsModelBankIDPckg pckgModelBank;

	iModelIDs.Reset();

	aMessage.ReadData1FromClientL(pckgModelBank);

	iImplementor.MSrGetAllModelIDsL(pckgModelBank(), iModelIDs);

	}

void CSpeechRecognitionCustomCommandParser::DoGetAllPronunciationIDsL(TMMFMessage& aMessage)

	{

	TSrsLexiconIDPckg pckgLexicon;

	iPronunciationIDs.Reset();

	aMessage.ReadData1FromClientL(pckgLexicon);

	iImplementor.MSrGetAllPronunciationIDsL(pckgLexicon(), iPronunciationIDs);

	}

void CSpeechRecognitionCustomCommandParser::DoGetAllRuleIDsL(TMMFMessage& aMessage)

	{

	TSrsGrammarIDPckg pckgGrammar;

	iRuleIDs.Reset();

	aMessage.ReadData1FromClientL(pckgGrammar);

	iImplementor.MSrGetAllRuleIDsL(pckgGrammar(), iRuleIDs);

	}

void CSpeechRecognitionCustomCommandParser::DoGetAllModelBankIDsL()

	{

	iModelBankIDs.Reset();

	iImplementor.MSrGetAllModelBankIDsL(iModelBankIDs);

	}

void CSpeechRecognitionCustomCommandParser::DoGetAllLexiconIDsL()

	{

	iLexiconIDs.Reset();

	iImplementor.MSrGetAllLexiconIDsL(iLexiconIDs);

	}

void CSpeechRecognitionCustomCommandParser::DoGetAllGrammarIDsL()

	{

	iGrammarIDs.Reset();

	iImplementor.MSrGetAllGrammarIDsL(iGrammarIDs);

	}

void CSpeechRecognitionCustomCommandParser::DoGetAllClientModelBankIDsL()

	{

	iModelBankIDs.Reset();

	iImplementor.MSrGetAllClientModelBankIDsL(iModelBankIDs);

	}

void CSpeechRecognitionCustomCommandParser::DoGetAllClientLexiconIDsL()

	{

	iLexiconIDs.Reset();

	iImplementor.MSrGetAllClientLexiconIDsL(iLexiconIDs);

	}

void CSpeechRecognitionCustomCommandParser::DoGetAllClientGrammarIDsL()

	{

	iGrammarIDs.Reset();

	iImplementor.MSrGetAllClientGrammarIDsL(iGrammarIDs);

	}

void CSpeechRecognitionCustomCommandParser::DoGetAvailableStorageL(TMMFMessage& aMessage)

	{

	TSrsIntPtrPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrGetAvailableStorageL(*pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoGetModelCountL(TMMFMessage& aMessage)

	{

	TSrsModelBankIDPckg pckgModelBank;

	TSrsIntPtrPckg pckgResult;

	aMessage.ReadData1FromClientL(pckgModelBank);

	aMessage.ReadData2FromClientL(pckgResult);

	iImplementor.MSrGetModelCountL(pckgModelBank(),*pckgResult());

	}

void CSpeechRecognitionCustomCommandParser::DoGetRuleValidityL(TMMFMessage& aMessage)

	{

	TSrsRuleValidityPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrGetRuleValidityL(pckg().iGrammarID, pckg().iRuleID, *pckg().iRuleValid);

	}

void CSpeechRecognitionCustomCommandParser::DoGetUtteranceDurationL(TMMFMessage& aMessage)

	{

	TSrsGetUtteranceDurationPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrGetUtteranceDurationL(pckg().iModelBankID, pckg().iModelID, *pckg().iDuration);

	}

void CSpeechRecognitionCustomCommandParser::DoLoadGrammarL(TMMFMessage& aMessage)

	{

	TSrsGrammarIDPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrLoadGrammarL(pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoLoadLexiconL(TMMFMessage& aMessage)

	{

	TSrsLexiconIDPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrLoadLexiconL(pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoLoadModelsL(TMMFMessage& aMessage)

	{

	TSrsModelBankIDPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrLoadModelsL(pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoPlayUtteranceL(TMMFMessage& aMessage)

	{

	TSrsPlayUtterancePckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrPlayUtteranceL(pckg().iModelBankID, pckg().iModelID);

	}

void CSpeechRecognitionCustomCommandParser::DoSetClientUidL(TMMFMessage& aMessage)

	{

	TSrsUidPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrSetClientUid(pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoRecognizeL(TMMFMessage& aMessage)

	{

	if (iResultSet)

		User::Leave(KErrInUse);

	TInt size;

	size = User::LeaveIfError(aMessage.SizeOfData1FromClient());

	HBufC8* dataBuffer = HBufC8::NewLC(size);

	TPtr8 buf = dataBuffer->Des();

	aMessage.ReadData1FromClientL(buf);

	RDesReadStream stream(buf);

	CleanupClosePushL(stream);

	iResultSet = CSDClientResultSet::NewL();

	TInt err = KErrNone;

	TRAP(err, iResultSet->InternalizeL(stream));

	if (err == KErrNone)

		{

		TRAP(err, iImplementor.MSrRecognizeL(*iResultSet));

		}

	if (err!=KErrNone)

		{

		delete iResultSet;

		iResultSet = NULL;

		User::Leave(err);

		}

	CleanupStack::PopAndDestroy(2, dataBuffer);//dataBuffer, stream

	}

void CSpeechRecognitionCustomCommandParser::DoRecordL(TMMFMessage& aMessage)

	{

	TSrsTimeIntervalMicroSeconds32Pckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrRecordL(pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoRemoveGrammarL(TMMFMessage& aMessage)

	{

	TSrsGrammarIDPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrRemoveGrammarL(pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoRemoveLexiconL(TMMFMessage& aMessage)

	{

	TSrsLexiconIDPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrRemoveLexiconL(pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoRemoveModelBankL(TMMFMessage& aMessage)

	{

	TSrsModelBankIDPckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrRemoveModelBankL(pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoRemoveModelL(TMMFMessage& aMessage)

	{

	TSrsModelBankIDPckg pckgModelBankID;

	TSrsModelIDPckg pckgModelID;

	aMessage.ReadData1FromClientL(pckgModelBankID);

	aMessage.ReadData2FromClientL(pckgModelID);

	iImplementor.MSrRemoveModelL(pckgModelBankID(), pckgModelID());

	}

void CSpeechRecognitionCustomCommandParser::DoRemovePronunciationL(TMMFMessage& aMessage)

	{

	TSrsLexiconIDPckg pckgLexicon;

	TSrsPronunciationIDPckg pckgPronunciation;

	aMessage.ReadData1FromClientL(pckgLexicon);

	aMessage.ReadData2FromClientL(pckgPronunciation);

	iImplementor.MSrRemovePronunciationL(pckgLexicon(), pckgPronunciation());

	}

void CSpeechRecognitionCustomCommandParser::DoRemoveRuleL(TMMFMessage& aMessage)

	{

	TSrsGrammarIDPckg pckgGrammar;

	TSrsRuleIDPckg pckgRule;

	aMessage.ReadData1FromClientL(pckgGrammar);

	aMessage.ReadData2FromClientL(pckgRule);

	iImplementor.MSrRemoveRuleL(pckgGrammar(), pckgRule());

	}

void CSpeechRecognitionCustomCommandParser::DoStartRecSessionL(TMMFMessage& aMessage)

	{

	TSrsRecognitionModePckg pckg;

	aMessage.ReadData1FromClientL(pckg);

	iImplementor.MSrStartRecSessionL(pckg());

	}

void CSpeechRecognitionCustomCommandParser::DoTrainL(TMMFMessage& aMessage)

	{

	TSrsModelBankIDPckg pckgModelBankID;

	TSrsModelIDPtrPckg pckgModelIDPtr;

	aMessage.ReadData1FromClientL(pckgModelBankID);

	aMessage.ReadData2FromClientL(pckgModelIDPtr);

	iImplementor.MSrTrainL(pckgModelBankID(),*pckgModelIDPtr());

	}

void CSpeechRecognitionCustomCommandParser::DoUnloadRuleL(TMMFMessage& aMessage)

	{

	TSrsGrammarIDPckg pckgGrammar;

	TSrsRuleIDPckg pckgRule;

	aMessage.ReadData1FromClientL(pckgGrammar);

	aMessage.ReadData2FromClientL(pckgRule);

	iImplementor.MSrUnloadRuleL(pckgGrammar(), pckgRule());

	}

void CSpeechRecognitionCustomCommandParser::DoLoadEngineParametersL(TMMFMessage& aMessage)

	{