/*

 * 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 <SbcEncoderIntfc.h>

 #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<TUint> supSamplingFrequencies;

     CleanupClosePushL(supSamplingFrequencies);

 	TInt status = iSbcEncoderIntfcCI->GetSupportedSamplingFrequencies(

 	                                  supSamplingFrequencies);

     // store array in iDataCopyBuffer

 	CreateBufFromUintArrayL(supSamplingFrequencies);

 	if (status == KErrNone)

     	{

 	    TPckgBuf<TUint> 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<CSbcEncoderIntfc::TSbcChannelMode> supChannelModes;

     CleanupClosePushL(supChannelModes);

 	TInt status =

 	     iSbcEncoderIntfcCI->GetSupportedChannelModes(supChannelModes);

     // store array in iDataCopyBuffer

 	CreateBufFromUintArrayL(reinterpret_cast<RArray<TUint>&>(supChannelModes));

 	if (status == KErrNone)

     	{

 	    TPckgBuf<TUint> 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<TUint> supNumBlocks;

     CleanupClosePushL(supNumBlocks);

 	TInt status = iSbcEncoderIntfcCI->GetSupportedNumOfBlocks(supNumBlocks);

 	CreateBufFromUintArrayL(supNumBlocks);

 	if (status == KErrNone)

     	{

 	    TPckgBuf<TUint> 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<TUint> supNumSubbands;

 	CleanupClosePushL(supNumSubbands);

 	TInt status = iSbcEncoderIntfcCI->GetSupportedNumOfSubbands(supNumSubbands);

 	CreateBufFromUintArrayL(supNumSubbands);

 	if (status == KErrNone)

     	{

 	    TPckgBuf<TUint> 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<CSbcEncoderIntfc::TSbcAllocationMethod> supAllocMethods;

 	CleanupClosePushL(supAllocMethods);

 	TInt status =

 	     iSbcEncoderIntfcCI->GetSupportedAllocationMethods(supAllocMethods);

     // store array in iDataCopyBuffer

 	CreateBufFromUintArrayL(reinterpret_cast<RArray<TUint>&>(supAllocMethods));

 	if (status == KErrNone)

     	{

 	    TPckgBuf<TUint> 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<TSbcEncoderBitpoolRange> 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<TSbcEncoderConfig> 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<TUint>& 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