--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmdevicefw/speechrecogsupport/ASR/src/SpeechRecognitionCustomCommandParser.cpp Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,724 @@
+// 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)
+ {
+ RArray<TInt> parameters;
+ RArray<TInt> values;
+ CleanupClosePushL(parameters);
+ CleanupClosePushL(values);
+ DoExtractIntArrayFromData1L(aMessage, parameters);
+ DoExtractIntArrayFromData2L(aMessage, values);
+ iImplementor.MSrLoadEngineParametersL(parameters,values);
+ CleanupStack::PopAndDestroy(2, ¶meters); // parameters, values
+ }
+
+void CSpeechRecognitionCustomCommandParser::DoGetEnginePropertiesL(TMMFMessage& aMessage)
+ {
+ RArray<TInt> propertyIDs;
+ RArray<TInt> propertyValues;
+ CleanupClosePushL(propertyIDs);
+ CleanupClosePushL(propertyValues);
+ DoExtractIntArrayFromData1L(aMessage, propertyIDs);
+
+ iImplementor.MSrGetEnginePropertiesL(propertyIDs,propertyValues);
+ // the custom command is aware of the size of the result, so it can copy the data back directly
+ DoCopyIntArrayL(aMessage, propertyValues);
+ CleanupStack::PopAndDestroy(2, &propertyIDs); // property IDs, property values
+ }
+
+
+void CSpeechRecognitionCustomCommandParser::DoCopyPronunciationIDArrayL(TMMFMessage& aMessage)
+ {
+ CBufFlat* dataBuffer = CBufFlat::NewL(KExpandSize);
+ CleanupStack::PushL(dataBuffer);
+ RBufWriteStream stream;
+ stream.Open(*dataBuffer);
+ CleanupClosePushL(stream);
+ for (TInt i=0;i<iPronunciationIDs.Count();i++)
+ stream.WriteUint32L(iPronunciationIDs[i]);
+
+ aMessage.WriteDataToClientL(dataBuffer->Ptr(0));
+
+ iPronunciationIDs.Close();
+ CleanupStack::PopAndDestroy(2, dataBuffer); //dataBuffer, stream
+ }
+void CSpeechRecognitionCustomCommandParser::DoCopyModelIDArrayL(TMMFMessage& aMessage)
+ {
+ CBufFlat* dataBuffer = CBufFlat::NewL(KExpandSize);
+ CleanupStack::PushL(dataBuffer);
+ RBufWriteStream stream;
+ stream.Open(*dataBuffer);
+ CleanupClosePushL(stream);
+ for (TInt i=0;i<iModelIDs.Count();i++)
+ stream.WriteUint32L(iModelIDs[i]);
+
+ aMessage.WriteDataToClientL(dataBuffer->Ptr(0));
+
+ iModelIDs.Close();
+ CleanupStack::PopAndDestroy(2, dataBuffer); //dataBuffer, stream
+ }
+
+void CSpeechRecognitionCustomCommandParser::DoCopyRuleIDArrayL(TMMFMessage& aMessage)
+ {
+ CBufFlat* dataBuffer = CBufFlat::NewL(KExpandSize);
+ CleanupStack::PushL(dataBuffer);
+ RBufWriteStream stream;
+ stream.Open(*dataBuffer);
+ CleanupClosePushL(stream);
+ for (TInt i=0;i<iRuleIDs.Count();i++)
+ stream.WriteUint32L(iRuleIDs[i]);
+
+ aMessage.WriteDataToClientL(dataBuffer->Ptr(0));
+
+ iRuleIDs.Close();
+ CleanupStack::PopAndDestroy(2, dataBuffer); //dataBuffer, stream
+ }
+
+//------------------------------------------------------------------------------------------------------------------
+
+void CSpeechRecognitionCustomCommandParser::DoCopyLexiconIDArrayL(TMMFMessage& aMessage)
+ {
+ CBufFlat* dataBuffer = CBufFlat::NewL(KExpandSize);
+ CleanupStack::PushL(dataBuffer);
+ RBufWriteStream stream;
+ stream.Open(*dataBuffer);
+ CleanupClosePushL(stream);
+ for (TInt i=0;i<iLexiconIDs.Count();i++)
+ stream.WriteUint32L(iLexiconIDs[i]);
+
+ aMessage.WriteDataToClientL(dataBuffer->Ptr(0));
+
+ iLexiconIDs.Close();
+ CleanupStack::PopAndDestroy(2, dataBuffer); //dataBuffer, stream
+ }
+void CSpeechRecognitionCustomCommandParser::DoCopyModelBankIDArrayL(TMMFMessage& aMessage)
+ {
+ CBufFlat* dataBuffer = CBufFlat::NewL(KExpandSize);
+ CleanupStack::PushL(dataBuffer);
+ RBufWriteStream stream;
+ stream.Open(*dataBuffer);
+ CleanupClosePushL(stream);
+ for (TInt i=0;i<iModelBankIDs.Count();i++)
+ stream.WriteUint32L(iModelBankIDs[i]);
+
+ aMessage.WriteDataToClientL(dataBuffer->Ptr(0));
+
+ iModelBankIDs.Close();
+ CleanupStack::PopAndDestroy(2, dataBuffer); //dataBuffer, stream
+ }
+
+void CSpeechRecognitionCustomCommandParser::DoCopyGrammarIDArrayL(TMMFMessage& aMessage)
+ {
+ CBufFlat* dataBuffer = CBufFlat::NewL(KExpandSize);
+ CleanupStack::PushL(dataBuffer);
+ RBufWriteStream stream;
+ stream.Open(*dataBuffer);
+ CleanupClosePushL(stream);
+ for (TInt i=0;i<iGrammarIDs.Count();i++)
+ stream.WriteUint32L(iGrammarIDs[i]);
+
+ aMessage.WriteDataToClientL(dataBuffer->Ptr(0));
+
+ iGrammarIDs.Close();
+ CleanupStack::PopAndDestroy(2, dataBuffer); //dataBuffer, stream
+ }
+
+
+//--------------------------------------------------------------------------------------------------------------------
+
+
+void CSpeechRecognitionCustomCommandParser::DoCopyIntArrayL(TMMFMessage& aMessage, const RArray<TInt>& aArray)
+ {
+ CBufFlat* dataBuffer = CBufFlat::NewL(KExpandSize);
+ CleanupStack::PushL(dataBuffer);
+ RBufWriteStream stream;
+ stream.Open(*dataBuffer);
+ CleanupClosePushL(stream);
+ for (TInt i=0;i<aArray.Count();i++)
+ stream.WriteUint32L(aArray[i]);
+
+ aMessage.WriteDataToClientL(dataBuffer->Ptr(0));
+ CleanupStack::PopAndDestroy(2, dataBuffer); //dataBuffer, stream
+ }
+
+void CSpeechRecognitionCustomCommandParser::DoExtractIntArrayFromData1L(TMMFMessage& aMessage, RArray<TInt>& aArray)
+ {
+ TInt size = User::LeaveIfError(aMessage.SizeOfData1FromClient());
+ HBufC8* buf = HBufC8::NewL(size);
+ CleanupStack::PushL(buf);
+ TPtr8 ptr = buf->Des();
+ aMessage.ReadData1FromClientL(ptr);
+ DoExtractIntArrayL(ptr,aArray);
+ CleanupStack::PopAndDestroy(buf);
+ }
+
+void CSpeechRecognitionCustomCommandParser::DoExtractIntArrayFromData2L(TMMFMessage& aMessage, RArray<TInt>& aArray)
+ {
+ TInt size = User::LeaveIfError(aMessage.SizeOfData2FromClient());
+ HBufC8* buf = HBufC8::NewL(size);
+ CleanupStack::PushL(buf);
+ TPtr8 ptr = buf->Des();
+ aMessage.ReadData2FromClientL(ptr);
+ DoExtractIntArrayL(ptr,aArray);
+ CleanupStack::PopAndDestroy(buf);
+ }
+
+
+void CSpeechRecognitionCustomCommandParser::DoExtractIntArrayL(TDes8& aDescriptor, RArray<TInt>& aArray)
+ {
+ RDesReadStream stream(aDescriptor);
+ CleanupClosePushL(stream);
+
+ TInt numberElements;
+ numberElements = stream.ReadInt32L();
+
+ for (TInt i=0; i<numberElements; i++)
+ {
+ User::LeaveIfError(aArray.Append(stream.ReadInt32L()));
+ }
+ CleanupStack::PopAndDestroy(&stream); //stream
+ }
+
+
+void CSpeechRecognitionCustomCommandParser::DoExternalizeResultSetL()
+ {
+ ASSERT(iResultSet);
+ iResultCopyBuffer = CBufFlat::NewL(KExpandSize);
+ RBufWriteStream stream;
+ stream.Open(*iResultCopyBuffer);
+ CleanupClosePushL(stream);
+ iResultSet->ExternalizeL(stream);
+ delete iResultSet;
+ iResultSet = NULL;
+ CleanupStack::PopAndDestroy(&stream); //stream
+ }
+void CSpeechRecognitionCustomCommandParser::DoCopyResultSetL(TMMFMessage& aMessage)
+ {
+ aMessage.WriteDataToClientL(iResultCopyBuffer->Ptr(0));
+ delete iResultCopyBuffer;
+ iResultCopyBuffer = NULL;
+ }