/*

* 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:   Interface proxy for BT SBC Encoder configuration CI.

*

*/

// INCLUDE FILES

#include <CustomCommandUtility.h>

#include <CustomInterfaceUtility.h>

#include "SbcEncoderIntfcMsgs.h"

#include "SbcEncoderIntfcProxy.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 ==============================

/**

 * CSbcEncoderIntfcProxy::CSbcEncoderIntfcProxy

 * C++ default constructor can NOT contain any code, that might leave.

 */

CSbcEncoderIntfcProxy::CSbcEncoderIntfcProxy(

                       TMMFMessageDestinationPckg aMessageHandler,

                       MCustomCommand& aCustomCommand,

                       CCustomInterfaceUtility* aCustomInterfaceUtility) :

	iCustomCommand(aCustomCommand),

	iMessageHandler(aMessageHandler),

	iCustomInterfaceUtility(aCustomInterfaceUtility)

    {

    }

/**

 * CSbcEncoderIntfcProxy::ConstructL

 * Symbian 2nd phase constructor can leave.

 */

void CSbcEncoderIntfcProxy::ConstructL()

    {

    iHasBeenApplied = EFalse;

    }

/**

 * CSbcEncoderIntfcProxy::NewL

 * Two-phased constructor.

 */

EXPORT_C CSbcEncoderIntfcProxy* CSbcEncoderIntfcProxy::NewL(

                               TMMFMessageDestinationPckg aMessageHandler,

                               MCustomCommand& aCustomCommand,

                               CCustomInterfaceUtility* aCustomInterfaceUtility)

    {

    CSbcEncoderIntfcProxy* self = new(ELeave) CSbcEncoderIntfcProxy(

                                              aMessageHandler,

                                              aCustomCommand,

                                              aCustomInterfaceUtility);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

/**

 * Destructor

 */

EXPORT_C CSbcEncoderIntfcProxy::~CSbcEncoderIntfcProxy()

    {

    iCustomInterfaceUtility->RemoveCustomInterface(iMessageHandler);

    delete iCustomInterfaceUtility;

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedSamplingFrequencies

 * Returns an array of supported sampling frequencies.

 * Calls a subfunction, which sends the appropriate custom command

 * to its message handler. A subfunction is used to contain multiple

 * leaving functions in a single trap.

 * (other items were commented in a header).

 */

EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedSamplingFrequencies(

                                     RArray<TUint>&

                                     aSupportedSamplingFrequencies)

    {

    TRAPD(status,

          GetSupportedSamplingFrequenciesL(aSupportedSamplingFrequencies));

    return status;

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedSamplingFrequenciesL

 * Returns an array of supported sampling frequencies.

 * Sends the custom command for this function to its message handler. This

 * requires two commands. The first is a request for the number of supported

 * sampling frequencies. A buffer is allocated locally to hold this number of

 * frequencies that will be returned. A pointer to this buffer is sent with the

 * next command, which is a request for the frequencies. This buffer will be

 * filled with the frequency values. These values are then copied into the

 * array provided to this function and the local buffer is deleted.

 * (other items were commented in a header).

 */

void CSbcEncoderIntfcProxy::GetSupportedSamplingFrequenciesL(

                            RArray<TUint>& aSupportedSamplingFrequencies)

    {

	aSupportedSamplingFrequencies.Reset();

	TPckgBuf<TUint> pckgBuf;

	User::LeaveIfError(iCustomCommand.CustomCommandSync(

                       iMessageHandler,

                       ESbceimGetNumOfSupportedSamplingFrequencies,

                       KNullDesC8,

                       KNullDesC8,

                       pckgBuf));

    HBufC8* buf = HBufC8::NewLC(pckgBuf() * sizeof(TUint));

    TPtr8 ptr = buf->Des();

    User::LeaveIfError(iCustomCommand.CustomCommandSync(

                       iMessageHandler,

                       ESbceimGetSupportedSamplingFrequencies,

                       KNullDesC8,

                       KNullDesC8,

                       ptr));

    PopulateArrayL(aSupportedSamplingFrequencies, ptr, pckgBuf());

   	CleanupStack::PopAndDestroy(buf);

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedChannelModes

 * Returns an array of supported channel modes.

 * Calls a  subfunction which sends the appropriate custom command to its

 * message handler. A subfunction is used to contain multiple leaving

 * functions for a single trap.

 * (other items were commented in a header).

 */

EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedChannelModes(

                                     RArray<TSbcChannelMode>&

                                     aSupportedChannelModes)

    {

    TRAPD(status, GetSupportedChannelModesL(aSupportedChannelModes));

    return status;

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedChannelModesL

 * Returns an array of supported channel modes.

 * Sends the custom command for this function to its message handler. This

 * requires two commands. The first is a request for the number of supported

 * channel modes. A buffer is allocated locally to hold this number of channel

 * modes that will be returned. A pointer to this buffer is sent with the next

 * command, which is a request for the channel modes. This buffer will be

 * filled with the frequency values. These values are then copied into the array

 * provided to this function and the local buffer is deleted.

 * (other items were commented in a header).

 */

void CSbcEncoderIntfcProxy::GetSupportedChannelModesL(

                            RArray<TSbcChannelMode>& aSupportedChannelModes)

    {

	aSupportedChannelModes.Reset();

	TPckgBuf<TSbcChannelMode> pckgBuf;

	User::LeaveIfError(iCustomCommand.CustomCommandSync(

                                      iMessageHandler,

                                      ESbceimGetNumOfSupportedChannelModes,

                                      KNullDesC8,

                                      KNullDesC8,

                                      pckgBuf));

    HBufC8* buf = HBufC8::NewLC(pckgBuf() * sizeof(TUint));

    TPtr8 ptr = buf->Des();

    User::LeaveIfError(iCustomCommand.CustomCommandSync(

                                      iMessageHandler,

                                      ESbceimGetSupportedChannelModes,

                                      KNullDesC8,

                                      KNullDesC8,

                                      ptr));

   	RDesReadStream stream(ptr);

    CleanupClosePushL(stream);

   	for (TInt i = 0; i < pckgBuf(); i++)

      	{

   		    static_cast<TSbcChannelMode>(stream.ReadUint32L()));

   		}

   	CleanupStack::PopAndDestroy(&stream);

   	CleanupStack::PopAndDestroy(buf);

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedNumOfBlocks

 * Returns an array of supported blocks.

 * Calls a subfunction, which sends the appropriate custom command to its

 * message handler. A subfunction is used to contain multiple leaving functions

 * for a single trap.

 * (other items were commented in a header).

 */

EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedNumOfBlocks(

		                             RArray<TUint>& aSupportedNumOfBlocks)

    {

    TRAPD(status, GetSupportedNumOfBlocksL(aSupportedNumOfBlocks));

    return status;

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedNumOfBlocks

 * Returns an array of supported blocks.

 * Sends the custom command for this function to its message handler. This

 * requires two commands. The first is a request for the number of supported

 * blocks. A buffer is allocated locally to hold this number of blocks that

 * will be returned. A pointer to this buffer is then sent with the next

 * command, which is a request for the blocks. This buffer will be filled

 * with the block values. These values are then copied into the array provided

 * to this function and the local buffer is deleted.

 * (other items were commented in a header).

 */

void CSbcEncoderIntfcProxy::GetSupportedNumOfBlocksL(

		                    RArray<TUint>& aSupportedNumOfBlocks)

    {

	aSupportedNumOfBlocks.Reset();

	TPckgBuf<TUint> pckgBuf;

	User::LeaveIfError(iCustomCommand.CustomCommandSync(

                                      iMessageHandler,

                                      ESbceimGetNumOfSupportedBlocks,

                                      KNullDesC8,

                                      KNullDesC8,

                                      pckgBuf));

    HBufC8* buf = HBufC8::NewLC(pckgBuf() * sizeof(TUint));

    TPtr8 ptr = buf->Des();

    User::LeaveIfError(iCustomCommand.CustomCommandSync(

                                      iMessageHandler,

                                      ESbceimGetSupportedBlocks,

                                      KNullDesC8,

                                      KNullDesC8,

                                      ptr));

    PopulateArrayL(aSupportedNumOfBlocks, ptr, pckgBuf());

   	CleanupStack::PopAndDestroy(buf);

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedNumOfSubbands

 * Returns an array of supported subbands.

 * Calls a  subfunction which sends the appropriate custom command to its

 * message handler. A subfunction is used to contain multiple leaving functions

 * for a single trap.

 * (other items were commented in a header).

 */

EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedNumOfSubbands(

                                     RArray<TUint>& aSupportedNumOfSubbands)

    {

    TRAPD(status, GetSupportedNumOfSubbandsL(aSupportedNumOfSubbands));

    return status;

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedNumOfSubbandsL

 * Returns an array of supported subbands.

 * Sends the custom command for this function to its message handler. This

 * requires two commands. The first is a request for the number of supported

 * subbands. A buffer is allocated locally to hold this number of subbands that

 * will be returned. A pointer to this buffer is sent with the next command,

 * which is a request for the subbands. This buffer will be filled with the

 * subband values. These values are then copied into the array provided to this

 * function and the local buffer is deleted.

 * (other items were commented in a header).

 */

void CSbcEncoderIntfcProxy::GetSupportedNumOfSubbandsL(

                            RArray<TUint>& aSupportedNumOfSubbands)

    {

	aSupportedNumOfSubbands.Reset();

	TPckgBuf<TUint> pckgBuf;

	User::LeaveIfError(iCustomCommand.CustomCommandSync(

                                      iMessageHandler,

                                      ESbceimGetNumOfSupportedNumOfSubbands,

                                      KNullDesC8,

                                      KNullDesC8,

                                      pckgBuf));

    HBufC8* buf = HBufC8::NewLC(pckgBuf() * sizeof(TUint));

    TPtr8 ptr = buf->Des();

    User::LeaveIfError(iCustomCommand.CustomCommandSync(

                                      iMessageHandler,

                                      ESbceimGetSupportedNumOfSubbands,

                                      KNullDesC8,

                                      KNullDesC8,

                                      ptr));

    PopulateArrayL(aSupportedNumOfSubbands, ptr, pckgBuf());

   	CleanupStack::PopAndDestroy(buf);

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedAllocationMethods

 * Returns an array of supported allocation methods.

 * Calls a  subfunction which sends the appropriate custom command to its

 * message handler. A subfunction is used to contain multiple leaving

 * functions for a single trap.

 * (other items were commented in a header).

 */

EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedAllocationMethods(

                                     RArray<TSbcAllocationMethod>&

                                     aSupportedAllocationMethods)

    {

    TRAPD(status, GetSupportedAllocationMethodsL(aSupportedAllocationMethods));

    return status;

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedAllocationMethodsL

 * Returns an array of supported allocation methods.

 * Sends the custom command for this function to its message handler. This

 * requires two commands. The first is a request for the number of supported

 * allocation methods. A buffer is allocated locally to hold this number of

 * allocation methods that will be returned. A pointer to this buffer is sent

 * with the next command which is a request for the allocation methods. This

 * buffer will be filled with the allocation method values. These values are

 * then copied into the array provided to this function and the local buffer

 * is deleted.

 * (other items were commented in a header).

 */

void CSbcEncoderIntfcProxy::GetSupportedAllocationMethodsL(

                            RArray<TSbcAllocationMethod>&

                            aSupportedAllocationMethods)

    {

	aSupportedAllocationMethods.Reset();

	TPckgBuf<TSbcAllocationMethod> pckgBuf;

	User::LeaveIfError(iCustomCommand.CustomCommandSync(

                                      iMessageHandler,

                                      ESbceimGetNumOfSupportedAllocationMethods,

                                      KNullDesC8,

                                      KNullDesC8,

                                      pckgBuf));

    HBufC8* buf = HBufC8::NewLC(pckgBuf() * sizeof(TUint));

    TPtr8 ptr = buf->Des();

    User::LeaveIfError(iCustomCommand.CustomCommandSync(

                                      iMessageHandler,

                                      ESbceimGetSupportedAllocationMethods,

                                      KNullDesC8,

                                      KNullDesC8,

                                      ptr));

   	RDesReadStream stream(ptr);

    CleanupClosePushL(stream);

   	for (TInt i = 0; i < pckgBuf(); i++)

      	{

   		            static_cast<TSbcAllocationMethod>(stream.ReadUint32L()));

   		}

   	CleanupStack::PopAndDestroy(&stream);

   	CleanupStack::PopAndDestroy(buf);

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedBitpoolRange

 * Returns supported bitpool range.

 * Calls a subfunction which sends the appropriate custom command to its

 * message handler. A subfunction is used to contain multiple leaving

 * functions for a single trap.

 * (other items were commented in a header).

 */

EXPORT_C TInt CSbcEncoderIntfcProxy::GetSupportedBitpoolRange(

        		                     TUint& aMinSupportedBitpoolSize,

        		                     TUint& aMaxSupportedBitpoolSize)

    {

    TRAPD(status, GetSupportedBitpoolRangeL(aMinSupportedBitpoolSize,

                                            aMaxSupportedBitpoolSize));

    return status;

    }

/**

 * CSbcEncoderIntfcProxy::GetSupportedBitpoolRangeL

 * Returns an array of supported bitpool range.

 * Sends the custom command for this function to its message handler with TUint

 * type arguments that will be filled with the bitpool min and max values.

 * (other items were commented in a header).

 */

void CSbcEncoderIntfcProxy::GetSupportedBitpoolRangeL(

                            TUint& aMinSupportedBitpoolSize,

		                    TUint& aMaxSupportedBitpoolSize)

    {

    TSbcEncoderBitpoolRange bitPoolRange;

    bitPoolRange.iMinSupportedBitpoolSize = 0;

    bitPoolRange.iMaxSupportedBitpoolSize = 0;

	TPckgBuf<TSbcEncoderBitpoolRange> pckgBuf(bitPoolRange);

    User::LeaveIfError(iCustomCommand.CustomCommandSync(

                                      iMessageHandler,

                                      ESbceimGetSupportedBitpoolRange,

                                      KNullDesC8,

                                      KNullDesC8,

                                      pckgBuf));

    aMinSupportedBitpoolSize = pckgBuf().iMinSupportedBitpoolSize;

    aMaxSupportedBitpoolSize = pckgBuf().iMaxSupportedBitpoolSize;

    }

/*

 * CSbcEncoderIntfcProxy::ApplyConfig

 * Commits encoder configuration settings configured by callas to Set() APIs.

 * Sends the custom command for this function to its message handler.

 * New settings will not take effect until ApplyConfig() is called.

 * (other items were commented in a header).

 */

EXPORT_C TInt CSbcEncoderIntfcProxy::ApplyConfig()

    {

    TInt status = KErrNone;

    if (!iHasBeenApplied)

        {

        if (!iSbcEncConf.iSamplingFrequencySet ||

        	!iSbcEncConf.iChannelModeSet ||

        	!iSbcEncConf.iNumOfSubbandsSet ||

        	!iSbcEncConf.iNumOfBlocksSet ||

        	!iSbcEncConf.iAllocationMethodSet ||

        	!iSbcEncConf.iBitpoolSizeSet)

            {

            status = KErrArgument;

            }

        }

    if (status == KErrNone)

        {

        TSbcEncoderConfig sbcEncoderConfig;

    	sbcEncoderConfig.iSamplingFrequency = iSbcEncConf.iSamplingFrequency;

    	sbcEncoderConfig.iChannelMode       = iSbcEncConf.iChannelMode;

    	sbcEncoderConfig.iNumOfSubbands     = iSbcEncConf.iNumOfSubbands;

    	sbcEncoderConfig.iNumOfBlocks       = iSbcEncConf.iNumOfBlocks;

    	sbcEncoderConfig.iAllocationMethod  = iSbcEncConf.iAllocationMethod;

    	sbcEncoderConfig.iBitpoolSize       = iSbcEncConf.iBitpoolSize;

    	TPckgBuf<TSbcEncoderConfig> pckgBuf(sbcEncoderConfig);

    	status = iCustomCommand.CustomCommandSync(iMessageHandler,

    	                                          ESbceimApplyConfig,

    	                                          pckgBuf,

    	                                          KNullDesC8);

    	if (status == KErrNone)

    		{

    		iSbcEncConfCurrent = iSbcEncConf;

    		iHasBeenApplied = ETrue;

    		}

        }

	return status;

    }

/**

 * CSbcEncoderIntfcProxy::SetSamplingFrequency

 * Saves locally requested sampling frequency.

 * Change does not apply to the encoder until ApplyConfig() is called.

 * (other items were commented in a header).

 */

EXPORT_C void CSbcEncoderIntfcProxy::SetSamplingFrequency(

                                     TUint aSamplingFrequency)

    {

    iSbcEncConf.iSamplingFrequency = aSamplingFrequency;

    iSbcEncConf.iSamplingFrequencySet = ETrue;

    }

/**

 * CSbcEncoderIntfcProxy::GetSamplingFrequency

 * Returns current sampling frequency commited by call to ApplyConfig().

 * (other items were commented in a header).

 */

EXPORT_C TInt CSbcEncoderIntfcProxy::GetSamplingFrequency(

                                     TUint& aSamplingFrequency)

    {

    TInt status = KErrNone;

    if (iHasBeenApplied)

        {

        aSamplingFrequency = iSbcEncConfCurrent.iSamplingFrequency;

        }

    else

        {

        status = KErrArgument;

        }

    return status;

    }

/**

 * CSbcEncoderIntfcProxy::SetChannelMode

 * Saves locally requested channel mode.

 * Change does not apply to the encoder until ApplyConfig() is called.

 * (other items were commented in a header).

 */

EXPORT_C void CSbcEncoderIntfcProxy::SetChannelMode(

                                     TSbcChannelMode aChannelMode)

    {

    iSbcEncConf.iChannelMode = aChannelMode;

    iSbcEncConf.iChannelModeSet = ETrue;

    }