diff -r 000000000000 -r b8ed18f6c07b mmdevicefw/speechrecogsupport/ASR/src/SpeechRecognitionCustomCommandParser.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmdevicefw/speechrecogsupport/ASR/src/SpeechRecognitionCustomCommandParser.cpp Thu Oct 07 22:34:12 2010 +0100 @@ -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 +#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 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 parameters; + RArray 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 propertyIDs; + RArray 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;iPtr(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;iPtr(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;iPtr(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;iPtr(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;iPtr(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;iPtr(0)); + + iGrammarIDs.Close(); + CleanupStack::PopAndDestroy(2, dataBuffer); //dataBuffer, stream + } + + +//-------------------------------------------------------------------------------------------------------------------- + + +void CSpeechRecognitionCustomCommandParser::DoCopyIntArrayL(TMMFMessage& aMessage, const RArray& aArray) + { + CBufFlat* dataBuffer = CBufFlat::NewL(KExpandSize); + CleanupStack::PushL(dataBuffer); + RBufWriteStream stream; + stream.Open(*dataBuffer); + CleanupClosePushL(stream); + for (TInt i=0;iPtr(0)); + CleanupStack::PopAndDestroy(2, dataBuffer); //dataBuffer, stream + } + +void CSpeechRecognitionCustomCommandParser::DoExtractIntArrayFromData1L(TMMFMessage& aMessage, RArray& 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& 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& aArray) + { + RDesReadStream stream(aDescriptor); + CleanupClosePushL(stream); + + TInt numberElements; + numberElements = stream.ReadInt32L(); + + for (TInt i=0; iExternalizeL(stream); + delete iResultSet; + iResultSet = NULL; + CleanupStack::PopAndDestroy(&stream); //stream + } +void CSpeechRecognitionCustomCommandParser::DoCopyResultSetL(TMMFMessage& aMessage) + { + aMessage.WriteDataToClientL(iResultCopyBuffer->Ptr(0)); + delete iResultCopyBuffer; + iResultCopyBuffer = NULL; + }