/*
* 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++)
      	{
   		aSupportedChannelModes.AppendL(
   		    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++)
      	{
   		aSupportedAllocationMethods.AppendL(
   		            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;
    }

/**
 * CSbcEncoderIntfcProxy::GetChannelMode
 * Returns current channel mode commited by call to ApplyConfig().
 * (other items were commented in a header).
 */
EXPORT_C TInt CSbcEncoderIntfcProxy::GetChannelMode(
                                     TSbcChannelMode& aChannelMode)
    {
    TInt status = KErrNone;

    if (iHasBeenApplied)
        {
        aChannelMode = iSbcEncConfCurrent.iChannelMode;
        }
    else
        {
        status = KErrArgument;
        }

    return status;
    }

/**
 * CSbcEncoderIntfcProxy::SetNumOfSubbands
 * Saves locally requested number of subbands.
 * Change does not apply to the encoder until ApplyConfig() is called.
 * (other items were commented in a header).
 */
EXPORT_C void CSbcEncoderIntfcProxy::SetNumOfSubbands(TUint aNumOfSubbands)
    {
    iSbcEncConf.iNumOfSubbands = aNumOfSubbands;
    iSbcEncConf.iNumOfSubbandsSet = ETrue;
    }

/**
 * CSbcEncoderIntfcProxy::GetNumOfSubbands
 * Returns current number of subbands commited by call to ApplyConfig().
 * (other items were commented in a header).
 */
EXPORT_C TInt CSbcEncoderIntfcProxy::GetNumOfSubbands(TUint& aNumOfSubbands)
    {
    TInt status = KErrNone;

    if (iHasBeenApplied)
        {
        aNumOfSubbands = iSbcEncConfCurrent.iNumOfSubbands;
        }
    else
        {
        status = KErrArgument;
        }

    return status;
    }

/**
 * CSbcEncoderIntfcProxy::SetNumOfBlocks
 * Saves locally requested number of blocks.
 * Change does not apply to the encoder until ApplyConfig() is called.
 * (other items were commented in a header).
 */
EXPORT_C void CSbcEncoderIntfcProxy::SetNumOfBlocks(TUint aNumOfBlocks)
    {
    iSbcEncConf.iNumOfBlocks = aNumOfBlocks;
    iSbcEncConf.iNumOfBlocksSet = ETrue;
    }

/**
 * CSbcEncoderIntfcProxy::GetNumOfBlocks
 * Returns current number of blocks commited by call to ApplyConfig().
 * (other items were commented in a header).
 */
EXPORT_C TInt CSbcEncoderIntfcProxy::GetNumOfBlocks(TUint& aNumOfBlocks)
    {
    TInt status = KErrNone;

    if (iHasBeenApplied)
        {
        aNumOfBlocks = iSbcEncConfCurrent.iNumOfBlocks;
        }
    else
        {
        status = KErrArgument;
        }

    return status;
    }

/**
 * CSbcEncoderIntfcProxy::SetAllocationMethod
 * Saves locally requested allocation method.
 * Change does not apply to the encoder until ApplyConfig() is called.
 * (other items were commented in a header).
 */
EXPORT_C void CSbcEncoderIntfcProxy::SetAllocationMethod(
                                     TSbcAllocationMethod aAllocationMethod)
    {
    iSbcEncConf.iAllocationMethod = aAllocationMethod;
    iSbcEncConf.iAllocationMethodSet = ETrue;
    }

/**
 * CSbcEncoderIntfcProxy::GetAllocationMethod
 * Returns current allocation method commited by call to ApplyConfig().
 * (other items were commented in a header).
 */
EXPORT_C TInt CSbcEncoderIntfcProxy::GetAllocationMethod(
                                     TSbcAllocationMethod& aAllocationMethod)
    {
    TInt status = KErrNone;

    if (iHasBeenApplied)
        {
        aAllocationMethod = iSbcEncConfCurrent.iAllocationMethod;
        }
    else
        {
        status = KErrArgument;
        }

    return status;
    }

/**
 * CSbcEncoderIntfcProxy::SetBitpoolSize
 * Saves locally requested bitpool range.
 * Change does not apply to the encoder until ApplyConfig() is called.
 * (other items were commented in a header).
 */
EXPORT_C void CSbcEncoderIntfcProxy::SetBitpoolSize(TUint aBitpoolSize)
    {
    iSbcEncConf.iBitpoolSize = aBitpoolSize;
    iSbcEncConf.iBitpoolSizeSet = ETrue;
    }

/**
 * CSbcEncoderIntfcProxy::GetBitpoolSize
 * Returns current bitpool range commited by call to ApplyConfig().
 * (other items were commented in a header).
 */
EXPORT_C TInt CSbcEncoderIntfcProxy::GetBitpoolSize(TUint& aBitpoolSize)
    {
    TInt status = KErrNone;

    if (iHasBeenApplied)
        {
        aBitpoolSize = iSbcEncConfCurrent.iBitpoolSize;
        }
    else
        {
        status = KErrArgument;
        }

    return status;
    }

/**
 * CSbcEncoderIntfcProxy::PopulateArrayL
 * Utility method that reads stream from 8-bit descriptor, converts it
 * to TUint data items and then copies them to the aArray.
 * (other items were commented in a header).
 */
void CSbcEncoderIntfcProxy::PopulateArrayL(RArray<TUint>& aArray,
                                           TPtr8 aPtr,
                                           TUint aCount)
    {
   	RDesReadStream stream(aPtr);
    CleanupClosePushL(stream);

   	for (TInt i = 0; i < aCount; i++)
      	{
   		aArray.AppendL(stream.ReadUint32L());
   		}

   	CleanupStack::PopAndDestroy(&stream);
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

// End of File