diff -r 000000000000 -r bde4ae8d615e os/mm/devsoundextensions/mmfcustominterfaces/SbcEncoderIntfc/SbcEncoderIntfcMsgHdlr/src/SbcEncoderIntfcMsgHdlr.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/devsoundextensions/mmfcustominterfaces/SbcEncoderIntfc/SbcEncoderIntfcMsgHdlr/src/SbcEncoderIntfcMsgHdlr.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,493 @@ +/* +* Copyright (c) 2006 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: Message handler for SBC encoder interface. +* +*/ + + + +// INCLUDE FILES +#include +#include "SbcEncoderIntfcMsgHdlr.h" +#include "SbcEncoderIntfcMsgs.h" + +// EXTERNAL DATA STRUCTURES + +// EXTERNAL FUNCTION PROTOTYPES + +// CONSTANTS + +// MACROS + +// LOCAL CONSTANTS AND MACROS + +// MODULE DATA STRUCTURES + +// LOCAL FUNCTION PROTOTYPES + +// FORWARD DECLARATIONS + +// ============================= LOCAL FUNCTIONS =============================== + +// ============================ MEMBER FUNCTIONS =============================== + +/** + * CSbcEncoderIntfcMsgHdlr::CSbcEncoderIntfcMsgHdlr + * C++ default constructor can NOT contain any code, that might leave. + */ +CSbcEncoderIntfcMsgHdlr::CSbcEncoderIntfcMsgHdlr( + CSbcEncoderIntfc* aSbcEncoderIntfcCI) : + CMMFObject(KUidSbcEncoderIntfc) + { + iSbcEncoderIntfcCI = aSbcEncoderIntfcCI; + } + +/** + * CSbcEncoderIntfcMsgHdlr::ConstructL + * Symbian 2nd phase constructor can leave. + */ +void CSbcEncoderIntfcMsgHdlr::ConstructL() + { + } + +/** + * CSbcEncoderIntfcMsgHdlr::NewL + * Two-phased constructor. + */ +EXPORT_C CSbcEncoderIntfcMsgHdlr* CSbcEncoderIntfcMsgHdlr::NewL( + TAny* aSbcEncoderIntfcCI) + { + CSbcEncoderIntfc* SbcEncoderIntfcCI = + (CSbcEncoderIntfc*)aSbcEncoderIntfcCI; + CSbcEncoderIntfcMsgHdlr* self = + new (ELeave) CSbcEncoderIntfcMsgHdlr(SbcEncoderIntfcCI); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +/** + * Destructor + */ +EXPORT_C CSbcEncoderIntfcMsgHdlr::~CSbcEncoderIntfcMsgHdlr() + { + delete iDataCopyBuffer; + delete iSbcEncoderIntfcCI; + } + +/** + * CSbcEncoderIntfcMsgHdlr::HandleRequest + * Handles the messages from the proxy. + * Calls a subfunction which determines which custom interface to call. + * A subfunction is used to contain multiple leaving functions for a + * single trap. + * (other items were commented in a header). + */ +EXPORT_C void CSbcEncoderIntfcMsgHdlr::HandleRequest(TMMFMessage& aMessage) + { + // debug panic + ASSERT(aMessage.Destination().InterfaceId() == KUidSbcEncoderIntfc); + TRAPD(error, DoHandleRequestL(aMessage)); + if(error) + { + aMessage.Complete(error); + } + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoHandleRequestL + * Determines which custom interface to call. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoHandleRequestL(TMMFMessage& aMessage) + { + switch(aMessage.Function()) + { + case ESbceimGetNumOfSupportedSamplingFrequencies: + { + DoGetNumOfSupportedSamplingFrequenciesL(aMessage); + break; + } + case ESbceimGetSupportedSamplingFrequencies: + { + DoGetSupportedSamplingFrequenciesL(aMessage); + break; + } + case ESbceimGetNumOfSupportedChannelModes: + { + DoGetNumOfSupportedChannelModesL(aMessage); + break; + } + case ESbceimGetSupportedChannelModes: + { + DoGetSupportedChannelModesL(aMessage); + break; + } + case ESbceimGetNumOfSupportedNumOfSubbands: + { + DoGetNumOfSupportedNumOfSubbandsL(aMessage); + break; + } + case ESbceimGetSupportedNumOfSubbands: + { + DoGetSupportedNumOfSubbandsL(aMessage); + break; + } + case ESbceimGetNumOfSupportedBlocks: + { + DoGetNumOfSupportedBlocksL(aMessage); + break; + } + case ESbceimGetSupportedBlocks: + { + DoGetSupportedBlocksL(aMessage); + break; + } + case ESbceimGetNumOfSupportedAllocationMethods: + { + DoGetNumOfSupportedAllocationMethodsL(aMessage); + break; + } + case ESbceimGetSupportedAllocationMethods: + { + DoGetSupportedAllocationMethodsL(aMessage); + break; + } + case ESbceimGetSupportedBitpoolRange: + { + DoGetSupportedBitpoolRangeL(aMessage); + break; + } + case ESbceimApplyConfig: + { + DoApplyConfigL(aMessage); + break; + } + default: + { + aMessage.Complete(KErrNotSupported); + } + } + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetNumOfSupportedSamplingFrequenciesL + * Handles the message from the proxy and calls the custom interface. + * The custom interface returns the data requested and this function writes + * it back to the proxy. It also creates a buffer and fills the sampling + * frequencies data to be returned in the subsequent call to + * DoGetSupportedSamplingFrequenciesL(). + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetNumOfSupportedSamplingFrequenciesL( + TMMFMessage& aMessage) + { + RArray supSamplingFrequencies; + CleanupClosePushL(supSamplingFrequencies); + + TInt status = iSbcEncoderIntfcCI->GetSupportedSamplingFrequencies( + supSamplingFrequencies); + + // store array in iDataCopyBuffer + CreateBufFromUintArrayL(supSamplingFrequencies); + + if (status == KErrNone) + { + TPckgBuf pckg; + pckg() = supSamplingFrequencies.Count(); + aMessage.WriteDataToClientL(pckg); + } + + CleanupStack::PopAndDestroy(&supSamplingFrequencies); + aMessage.Complete(status); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetSupportedSamplingFrequenciesL + * Sends the sampling frequency data returned from the custom interface + * implementation to the client. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetSupportedSamplingFrequenciesL( + TMMFMessage& aMessage) + { + SendDataBufferToClientL(aMessage); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetNumOfSupportedChannelModesL + * Handles the message from the proxy and calls the custom interface. + * The custom interface returns the data requested and this function writes + * it back to the proxy. It also creates a buffer and fills the sampling + * frequencies data to be returned in the subsequent call to + * DoGetSupportedChannelModesL(). + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetNumOfSupportedChannelModesL( + TMMFMessage& aMessage) + { + RArray supChannelModes; + CleanupClosePushL(supChannelModes); + TInt status = + iSbcEncoderIntfcCI->GetSupportedChannelModes(supChannelModes); + + // store array in iDataCopyBuffer + CreateBufFromUintArrayL(reinterpret_cast&>(supChannelModes)); + + if (status == KErrNone) + { + TPckgBuf pckg; + pckg() = supChannelModes.Count(); + aMessage.WriteDataToClientL(pckg); + } + + CleanupStack::PopAndDestroy(&supChannelModes); + aMessage.Complete(status); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetSupportedChannelModesL + * Sends the channel modes data returned from the custom interface + * implementation to the client. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetSupportedChannelModesL( + TMMFMessage& aMessage) + { + SendDataBufferToClientL(aMessage); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetNumOfSupportedBlocksL + * Handles the message from the proxy and calls the custom interface. + * The custom interface returns the data requested and this function writes + * it back to the proxy. It also creates a buffer and fills the supported + * blocks data to be returned in the subsequent call to + * DoGetSupportedBlocksL(). + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetNumOfSupportedBlocksL( + TMMFMessage& aMessage) + { + RArray supNumBlocks; + CleanupClosePushL(supNumBlocks); + + TInt status = iSbcEncoderIntfcCI->GetSupportedNumOfBlocks(supNumBlocks); + + CreateBufFromUintArrayL(supNumBlocks); + + if (status == KErrNone) + { + TPckgBuf pckg; + pckg() = supNumBlocks.Count(); + aMessage.WriteDataToClientL(pckg); + } + + CleanupStack::PopAndDestroy(&supNumBlocks); + aMessage.Complete(status); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetSupportedBlocksL + * Sends the supported blocks data returned from the custom interface + * implementation to the client. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetSupportedBlocksL(TMMFMessage& aMessage) + { + SendDataBufferToClientL(aMessage); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetNumOfSupportedNumOfSubbandsL + * Handles the message from the proxy and calls the custom interface. + * The custom interface returns the data requested and this function writes + * it back to the proxy. It also creates a buffer and fills the supported + * subbands data to be returned in the subsequent call to + * DoGetSupportedNumOfSubbandsL(). + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetNumOfSupportedNumOfSubbandsL( + TMMFMessage& aMessage) + { + RArray supNumSubbands; + CleanupClosePushL(supNumSubbands); + + TInt status = iSbcEncoderIntfcCI->GetSupportedNumOfSubbands(supNumSubbands); + + CreateBufFromUintArrayL(supNumSubbands); + + if (status == KErrNone) + { + TPckgBuf pckg; + pckg() = supNumSubbands.Count(); + aMessage.WriteDataToClientL(pckg); + } + + CleanupStack::PopAndDestroy(&supNumSubbands); + aMessage.Complete(status); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetSupportedNumOfSubbandsL + * Sends the supported subbands data returned from the custom interface + * implementation to the client. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetSupportedNumOfSubbandsL( + TMMFMessage& aMessage) + { + SendDataBufferToClientL(aMessage); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetNumOfSupportedAllocationMethodsL + * Handles the message from the proxy and calls the custom interface. + * The custom interface returns the data requested and this function writes + * it back to the proxy. It also creates a buffer and fills the supported + * allocation methods data to be returned in the subsequent call to + * DoGetSupportedAllocationMethodsL(). + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetNumOfSupportedAllocationMethodsL( + TMMFMessage& aMessage) + { + RArray supAllocMethods; + CleanupClosePushL(supAllocMethods); + + TInt status = + iSbcEncoderIntfcCI->GetSupportedAllocationMethods(supAllocMethods); + + // store array in iDataCopyBuffer + CreateBufFromUintArrayL(reinterpret_cast&>(supAllocMethods)); + + if (status == KErrNone) + { + TPckgBuf pckg; + pckg() = supAllocMethods.Count(); + aMessage.WriteDataToClientL(pckg); + } + + CleanupStack::PopAndDestroy(&supAllocMethods); + aMessage.Complete(status); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetSupportedAllocationMethodsL + * Sends the supported allocation methods data returned from the custom + * interface implementation to the client. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetSupportedAllocationMethodsL( + TMMFMessage& aMessage) + { + SendDataBufferToClientL(aMessage); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoGetSupportedBitpoolRangeL + * Handles the message from the proxy and calls the custom interface. + * The custom interface returns the requested bitpool range and this function + * writes it back to the proxy. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoGetSupportedBitpoolRangeL( + TMMFMessage& aMessage) + { + TSbcEncoderBitpoolRange bitPoolRange; + bitPoolRange.iMinSupportedBitpoolSize = 0; + bitPoolRange.iMaxSupportedBitpoolSize = 0; + + TInt status = iSbcEncoderIntfcCI->GetSupportedBitpoolRange( + bitPoolRange.iMinSupportedBitpoolSize, + bitPoolRange.iMaxSupportedBitpoolSize); + + if (status == KErrNone) + { + TPckgBuf pckg; + pckg() = bitPoolRange; + aMessage.WriteDataToClientL(pckg); + } + + aMessage.Complete(status); + } + +/** + * CSbcEncoderIntfcMsgHdlr::DoApplyConfigL + * Handles the message from the proxy to commit configuration settings and + * calls the custom interface method. The data passed from the proxy is read + * from the message and passed to the custom interface. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::DoApplyConfigL(TMMFMessage& aMessage) + { + TPckgBuf pckgBuf; + aMessage.ReadData1FromClientL(pckgBuf); + + iSbcEncoderIntfcCI->SetSamplingFrequency(pckgBuf().iSamplingFrequency); + iSbcEncoderIntfcCI->SetChannelMode(pckgBuf().iChannelMode); + iSbcEncoderIntfcCI->SetNumOfSubbands(pckgBuf().iNumOfSubbands); + iSbcEncoderIntfcCI->SetNumOfBlocks(pckgBuf().iNumOfBlocks); + iSbcEncoderIntfcCI->SetAllocationMethod(pckgBuf().iAllocationMethod); + iSbcEncoderIntfcCI->SetBitpoolSize(pckgBuf().iBitpoolSize); + + TInt status = iSbcEncoderIntfcCI->ApplyConfig(); + aMessage.Complete(status); + } + +/** + * CSbcEncoderIntfcMsgHdlr::CreateBufFromUintArrayL + * Utility function used to create a buffer and fill it with data from the + * array passed in. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::CreateBufFromUintArrayL(RArray& aArray) + { + delete iDataCopyBuffer; + iDataCopyBuffer = NULL; + iDataCopyBuffer = CBufFlat::NewL(8); + + RBufWriteStream stream; + stream.Open(*iDataCopyBuffer); + CleanupClosePushL(stream); + + for (TInt i = 0; i < aArray.Count(); i++) + { + stream.WriteUint32L(aArray[i]); + } + + CleanupStack::PopAndDestroy(&stream); + } + +/** + * CSbcEncoderIntfcMsgHdlr::SendDataBufferToClientL + * Sends message with requested configuration data back to the client. + * (other items were commented in a header). + */ +void CSbcEncoderIntfcMsgHdlr::SendDataBufferToClientL(TMMFMessage& aMessage) + { + if (!iDataCopyBuffer) + { + User::Leave(KErrNotReady); + } + + aMessage.WriteDataToClientL(iDataCopyBuffer->Ptr(0)); + aMessage.Complete(KErrNone); + } + + +// ========================== OTHER EXPORTED FUNCTIONS ========================= + +// End of File