/*
* 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