// Copyright (c) 2005-2009 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:

//

#include <mmf/server/mmfcodec.h>

#include "mmfSBCCodecImplementationUIDs.hrh"

#include <mmffourcc.h>

#include "A2dpCodecUtilities.h"

#include "A2dpBTheadsetAudioIf.h"

#include "MMFBtRoutingSoundDevice.h"	// for TRange

/**

Panics

**/

enum TA2dpBTHeadsetPanic

	{

	EA2dpBTHeadsetUnExpectedState,//0

	EA2dpBTHeadsetNoRTPStreamer,//1

	EA2dpBTHeadsetNoData,//2

	EA2dpBTHeadsetUnexpectedDataType,//3

	EA2dpBTHeadsetBTAddrNotSet, //4

	EA2dpBTHeadsetNoCodec //5

	};

static void Panic(TA2dpBTHeadsetPanic aPanic)

// Panic client

	{

	_LIT(KA2dpBTHeadsetPanicName, "A2DP BT If Panic");

	User::Panic(KA2dpBTHeadsetPanicName, aPanic);

	}

CA2dpBTHeadsetAudioInterface::CA2dpBTHeadsetAudioInterface()

	{

	}

void CA2dpBTHeadsetAudioInterface::ConstructL()

	{

	iA2dpCodecConfiguration = CA2dpAudioCodecConfiguration::NewL();

	User::LeaveIfError(iSocketServer.Connect());

	iGAVDPStateMachine = CGAVDPStateMachine::NewL(*this, *iA2dpCodecConfiguration, iSocketServer);	

	}

/**

Creates CA2dpBTHeadsetAudioInterface

Note there should only ever be one CA2dpBTHeadsetAudioInterface*

However this being a singleton is not enforced in this class however

The client of this class ie the CA2dpBTHeadsetAudioServer should enforce this.

@return CA2dpBTHeadsetAudioInterface*

*/	

EXPORT_C CA2dpBTHeadsetAudioInterface* CA2dpBTHeadsetAudioInterface::NewL()

	{

	CA2dpBTHeadsetAudioInterface* self = new(ELeave) CA2dpBTHeadsetAudioInterface();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

destructor

*/	

EXPORT_C CA2dpBTHeadsetAudioInterface::~CA2dpBTHeadsetAudioInterface()

	{

	SetSniffMode(ETrue);

	delete iGAVDPStateMachine;

	delete iCodec;

	delete iA2dpCodecConfiguration;

	delete iRTPStreamer;

	iSocketServer.Close();

	}

/**

Procedure to perform a GAVDP initialization sequence on an A2DP headset

If the headset is already initialized then this procedure does not perform

any further initialization.

if link has gone down since a previous call to Initialize then

calling this function will perform a full reinitialize.

if link goes down during initialization will generate error

The GAVDPStateChangeComplete callback is called when the headset device

is in the open state.

The headset is in the GAVDP_Open state on completion

It is not possible to perform an Initialize if the headset is already in the

streaming state or is already being initialized.

@param aRemoteAddress Address of the bluetooth headset we are trying to initialize

@param aStatus

*/	

EXPORT_C void CA2dpBTHeadsetAudioInterface::Initialize(const TBTDevAddr& aRemoteAddress, TRequestStatus& aStatus)

	{

	__ASSERT_ALWAYS(((iGAVDPStateMachine->State() == TGAVDPState::EGAVDPIdle)||

					(iGAVDPStateMachine->State() == TGAVDPState::EGAVDPOpen)), Panic(EA2dpBTHeadsetUnExpectedState));

	__ASSERT_ALWAYS(!iReconfiguring, Panic(EA2dpBTHeadsetUnExpectedState)); //can't initialize while we're reconfiguring

	iInitializeRequestStatus = &aStatus;

	*iInitializeRequestStatus = KRequestPending;

	//this will cause a full initialization if the address has changed

	iGAVDPStateMachine->SetBTAddress(aRemoteAddress);

	TGAVDPState state(TGAVDPState::EGAVDPOpen);

	TInt err = iGAVDPStateMachine->ChangeState(state);

	if (err)

		{

		User::RequestComplete(iInitializeRequestStatus, err);

		}	

	}

/**

Procedure to cancel a GAVDP initialization sequence on an A2DP headset

*/		

EXPORT_C void CA2dpBTHeadsetAudioInterface::CancelInitialize()

	{

	if (iInitializeRequestStatus)

		{

		if (*iInitializeRequestStatus == KRequestPending)//make sure there is a pending request to cancel

			{

			iGAVDPStateMachine->CancelChangeState();

			}

		}

	}

/**

Handles the state change GAVDPIdle->GAVDPOpen

This state change usually occurs as a result to an Initialize call

Can also occur due to an error condition resulting in a GAVDP state machine reset 

*/

void CA2dpBTHeadsetAudioInterface::ProcessGAVDPStateChangeIdleToOpen(TInt aError)

	{

	__ASSERT_DEBUG((aError||iGAVDPStateMachine->State()==TGAVDPState::EGAVDPOpen||

	iGAVDPStateMachine->State()==TGAVDPState::EGAVDPIdle),Panic(EA2dpBTHeadsetUnExpectedState)); //if there is no error then current state should be open

	if (!aError)

		{

		SetSniffMode(ETrue);

		iPaused = EFalse;

		iReconfiguring = EFalse;

		if (iRTPStreamer) //if this is true then an error has occured somewhere

			{//and we need to reset the streamer and close the socket

			delete iRTPStreamer;

			iRTPStreamer = NULL;

			iGAVDPStateMachine->BearerSocket().Close();

			}

		}

	if (iInitializeRequestStatus)

		{

		if (*iInitializeRequestStatus == KRequestPending)

			{

			User::RequestComplete(iInitializeRequestStatus, aError);

			}

		}

	}

/**

Handles the state change GAVDPOpen->GAVDPStreaming

This state change occurs as a result to an OpenDevice call 

This can get called twice, once if a reconfiguration is needed prior 

to going in the streaming state where the state machine should still be in the open state

and a second time when the state machine is in the streaming state

*/	

void CA2dpBTHeadsetAudioInterface::ProcessGAVDPStateChangeOpenToStreaming(TInt aError)

	{

	if (iOpenDeviceRequestStatus)

		{

		iOpenDeviceError = aError;

		if (*iOpenDeviceRequestStatus == KRequestPending)

			{

			if (iReconfiguring)

				{//should be in the OPEN state if we are reconfiguring

				__ASSERT_DEBUG((iGAVDPStateMachine->State() == TGAVDPState::EGAVDPOpen),Panic(EA2dpBTHeadsetUnExpectedState));

				iReconfiguring = EFalse;

				if (!iOpenDeviceError)

					{

					//move GAVDP state to streaming

					TGAVDPState state(TGAVDPState::EGAVDPStreaming);

					iOpenDeviceError = iGAVDPStateMachine->ChangeState(state);

					}

				if (iOpenDeviceError)

					{

					SetSniffMode(ETrue); //go back to sniff mode

					User::RequestComplete(iOpenDeviceRequestStatus, iOpenDeviceError);

					}

				}//if (iReconfiguring)

			else

				{//callback must be in response to a streaming change state

				__ASSERT_DEBUG((aError||iGAVDPStateMachine->State()==TGAVDPState::EGAVDPStreaming),Panic(EA2dpBTHeadsetUnExpectedState)); //if there is no error then current state should be open

				if (!iOpenDeviceError)

					{

					__ASSERT_DEBUG((iGAVDPStateMachine->State()==TGAVDPState::EGAVDPStreaming),Panic(EA2dpBTHeadsetUnExpectedState));

					delete iRTPStreamer;

					iRTPStreamer = NULL;

					TRAP(iOpenDeviceError,iRTPStreamer = CActiveRTPStreamer::NewL(iGAVDPStateMachine->BearerSocket(),*this));

					if (!iOpenDeviceError)

						{//create codec

						iAudioSettingsHaveChanged = EFalse;

						iRTPStreamer->SetAudioConfiguration(*iA2dpCodecConfiguration);

						//if we have not set the data type ourselves then get iDataType

						//from the code configuration

						if (iDataType == KMMFFourCCCodeNULL)

							{

							iDataType = iA2dpCodecConfiguration->HeadsetCodecDataType();

							if (iDataType == KMMFFourCCCodeSBC)

								{//then the audio interfacef code will be pcm16

								iDataType = KMMFFourCCCodePCM16;

								}

							}

						if (iDataType == KMMFFourCCCodePCM16)

							{//then an SBC codec is required

							const TUid KSbcCodecUid = { KMmfUidCodecPCM16ToSBC };

							TRAP(iOpenDeviceError,iCodec = CMMFCodec::NewL(KSbcCodecUid));

							if (!iOpenDeviceError)

								{

								TUid configType;

								configType.iUid = KMmfUidSBCConfigure;

								TSBCFrameParameters& SBCFrameParameters = iA2dpCodecConfiguration->UpdateLocalSBCCodecConfiguration();

								//use a package buffer for codec config to keep flexability should

								//it be possible to use other codecs rather than SBC in future.

								TPckgBuf<TSBCFrameParameters> SBCFrameParametersBuf(SBCFrameParameters);

								TRAP(iOpenDeviceError,iCodec->ConfigureL(configType, SBCFrameParametersBuf));

								iRTPStreamer->SetCodec(*iCodec);

								}

							}

						}//if (!iOpenDeviceError)

					}//if (!iOpenDeviceError)

				if ((iOpenDeviceError) && (iGAVDPStateMachine->State()==TGAVDPState::EGAVDPStreaming))

					{

					//there was an error so wind back state to EGAVDPOpen

					//don't complete the OpenDevice request status till we've wound back

					TGAVDPState state(TGAVDPState::EGAVDPOpen);

					TInt iOpenDeviceError = iGAVDPStateMachine->ChangeState(state);

					//if the above fails there's not much we can do

					}

				else

					{

					//if we get to here then we should either be in the streaming state with no errors

					//or in the open state with an error - either way we complete the OpenDevice request status

					User::RequestComplete(iOpenDeviceRequestStatus, iOpenDeviceError);

					if (iOpenDeviceError)

						{

						SetSniffMode(ETrue);

						}

					}

				}//else  if not (iReconfiguring)

			}//	if (*iOpenRequestStatus == KRequestPending)

		}//if (iOpenRequestStatus)

	}

/*

Handles the state change GAVDPStreaming->GAVDPOpen

The transition from streaming to open can be caused by one of two ways

1 - A call to CloseDevice

2 - A call to Open device where there was an error after the transition to streaming

*/	

void CA2dpBTHeadsetAudioInterface::ProcessGAVDPStateChangeStreamingToOpen(TInt aError)

	{

	__ASSERT_DEBUG((aError||iGAVDPStateMachine->State()==TGAVDPState::EGAVDPOpen),Panic(EA2dpBTHeadsetUnExpectedState)); //if there is no error then current state should be open

	//only have streamer and codec in streaming state

	delete iRTPStreamer;

	iRTPStreamer = NULL;

	delete iCodec;

	iCodec = NULL;

	if (iCloseDeviceRequestStatus)

		{//state change is in response to a close device

		if (*iCloseDeviceRequestStatus == KRequestPending)

			{

			User::RequestComplete(iCloseDeviceRequestStatus, aError);

			}

		}

	else if (iOpenDeviceRequestStatus)

		{

		//it must be a failed OpenDevice where the state has been wound back to EGAVDPOpen

		__ASSERT_DEBUG((iGAVDPStateMachine->State() == TGAVDPState::EGAVDPOpen),Panic(EA2dpBTHeadsetUnExpectedState));

		//the following ASSERT_DEBUG should be present but is commented out as the RVCT 

		//compiler generates a warning

		//__ASSERT_DEBUG((iOpenDeviceError), EA2dpBTHeadsetUnExpectedState);

		if (*iOpenDeviceRequestStatus == KRequestPending)

			{

			User::RequestComplete(iOpenDeviceRequestStatus, iOpenDeviceError);

			}

		}

	SetSniffMode(ETrue);

	}

/**

Callback by the GAVDP state machine when a GAVDP state change has been completed

@param aInitialState The TGAVDPState prior to the start of the state change

@param aCurrentState The current TGAVDPState of the GAVDP state machine

@param aError standard Symbian error code.  

*/

void CA2dpBTHeadsetAudioInterface::GAVDPStateChangeComplete(const TGAVDPState& aInitialState, TInt aError)

	{	

	switch(aInitialState.State())

		{

		case TGAVDPState::EGAVDPIdle:

			ProcessGAVDPStateChangeIdleToOpen(aError);

			break;

		case TGAVDPState::EGAVDPOpen:

			ProcessGAVDPStateChangeOpenToStreaming(aError);

			break;

		case TGAVDPState::EGAVDPStreaming:

			ProcessGAVDPStateChangeStreamingToOpen(aError);	

			break;

		default:

			Panic(EA2dpBTHeadsetUnExpectedState);

			break;

		}

	}

/**

Returns a list of the supported datatypes for audio that can be sent to the headset.

The list is obtained from the headset, so the headset need to have been Initialized first

@param  aSupportedDataTypes

The array of supported data types that will be filled in by this function.

The supported data types are in the form of an array

of TFourCC codes. Any existing entries in the array will be overwritten on 

calling this function. 

@return standard Symbian error code.   

KErrNotReady if headset has not been initialized.

*/

EXPORT_C TInt CA2dpBTHeadsetAudioInterface::GetSupportedDataTypes(RArray<TFourCC>& aSupportedDataTypes) const

	{

	aSupportedDataTypes.Reset(); //clear any existing data in aSupportedDataTypes array

	TInt err = KErrNone;

	RArray<TUsableSEP>& usableSEPs = iGAVDPStateMachine->UsableSEPs();

	TUint numberOfUsableSEPS = usableSEPs.Count();

	if (numberOfUsableSEPS)

		{

		TUint i;

		TUsableSEP SEP;

		//iterate through the list of usable SEPs looking for one that supports

		//the requested data type

		for (i=0;  i<usableSEPs.Count(); i++)

			{

			SEP = usableSEPs[i];

			//both the headset and the A2dpBTHeadsetAudioInterface need to

			//support the datatype so check we also support the datatype

			//currently only SBC & MP3 data types are supported

			if ((SEP.iDataType == KMMFFourCCCodeSBC)||(SEP.iDataType == KMMFFourCCCodeMP3))

				{

				err = aSupportedDataTypes.Append(SEP.iDataType);

				}

			if (err)

				{

				break;

				}

			if (SEP.iDataType == KMMFFourCCCodeSBC)

				{//then we also support pcm16

				err = aSupportedDataTypes.Append(KMMFFourCCCodePCM16);

				if (err)

					{

					break;

					}

				}

			}

		}

	else if (iGAVDPStateMachine->State() == TGAVDPState::EGAVDPIdle)

		{//no usable SEPs available so can't yet get supported data types

		err = KErrNotReady;

		}

	if (err)

		{

		aSupportedDataTypes.Reset();

		}

	return err;

	}

/**

Returns the sample rates supported by the headset.

In the case of SBC the supported values are obtained from the headset.

In the case of mp3,AAC & ATRAC 3 the values are not obtained from

the headset as the underlying bluetoothav code does not have a defined structure

for containing these values, therefore the mandatory values are returned

@param  aSupportedDiscreteRates

The array of supported sample rates that will be filled in by this function.

The supported data types are in the form of an array

of TFourCC codes. Any existing entries in the array will be overwritten on 

calling this function. 

@param aSupportedRateRanges

To cover the case where headsets support a range of sample rates

@return standard Symbian error code.   

KErrNotReady if headset has not been initialized.

*/	

EXPORT_C TInt CA2dpBTHeadsetAudioInterface::GetSupportedSampleRates(RArray<TUint>& aSupportedDiscreteRates, RArray<TRange>& aSupportedRateRanges) const

	{

	TInt error = KErrNone;

	aSupportedDiscreteRates.Reset();

	aSupportedRateRanges.Reset();

	//get the codec capabilites from the GAVDP state machine

	TAvdtpMediaCodecCapabilities* codecCaps = NULL;

	error = iGAVDPStateMachine->CodecCaps(codecCaps);

	if (!error)

		{

		error = TA2dpCodecCapabilityParser::GetSupportedSampleRates(*codecCaps,aSupportedDiscreteRates);

		}

	if (error)

		{

		aSupportedDiscreteRates.Reset();

		}

	return error;

	}

/**

Returns the number of channels supported by the headset.

In the case of SBC the supported values are obtained from the headset.

In the case of mp3,AAC & ATRAC 3 the values are not obtained from

the headset as the underlying bluetoothav code does not have a defined structure

for containing these values, therefore the mandatory values are returned

@param  aSupportedChannels

The array of supported number of channels that will be filled in by this function.

Any existing entries in the array will be overwritten on 

calling this function. 

@param aStereoSupport

Additional parameter to specifiy the stereo support

@return standard Symbian error code.

@see TMMFStereoSupport

KErrNotReady if headset has not been initialized.

*/		

EXPORT_C TInt CA2dpBTHeadsetAudioInterface::GetSupportedChannels(RArray<TUint>& aSupportedChannels, TMMFStereoSupport& aStereoSupport) const

	{

	aSupportedChannels.Reset();

	aStereoSupport = EMMFNone;

	TInt error = KErrNone;

	//get the codec capabilites from the GAVDP state machine

	TAvdtpMediaCodecCapabilities* codecCaps = NULL;

	error = iGAVDPStateMachine->CodecCaps(codecCaps);

	if (!error)

		{

		error = TA2dpCodecCapabilityParser::GetSupportedChannels(*codecCaps, aSupportedChannels, aStereoSupport);

		}

	if (error) 

		{

		aSupportedChannels.Reset();

		aStereoSupport = EMMFNone;

		}

	return error;

	}

/**

Sets the data type of the data sent to the CA2dpBTHeadsetAudioInterface

Note that data type specified here may not be identical to the data type

sent to the headset and hence the data type used in the the a2dp codec configuration.  

ie if the CA2dpBTHeadsetAudioInterface data type set by this method is pcm16

then the data type sent to the headset is SBC.

note that this method just sets the internal iDatatype member

the datatype cannot be changed on the fly, but only gets changed

when the GAVDP state machine is reconfigured in CA2dpBTHeadsetAudioInterface::OpenDevice()

@param  aSinkFourCC

        The 4CC code of the data to be supplied to this class instance.

@return System wide error code indicating if the function call was successful.

		KErrNotReady if the headset is not initialized

		KErrInUse if the headset is already streaming

		KErrNotSupported if the datatype is not supported

*/

EXPORT_C TInt CA2dpBTHeadsetAudioInterface::SetDataType(const TFourCC& aDataType)

	{

	TInt error = KErrNone;

	if (iGAVDPStateMachine->State() == TGAVDPState::EGAVDPIdle)

		{

		return KErrNotReady;

		}

	if (iGAVDPStateMachine->State() == TGAVDPState::EGAVDPStreaming)

		{

		return KErrInUse; //don't allow this while we're streaming audio

		}

	//the requested data type is a non standard data type

	//so first check if there is a SEP that supports it

	RArray<TUsableSEP>& usableSEPs = iGAVDPStateMachine->UsableSEPs();

	TUint i;

	TUsableSEP SEP;

	TBool dataTypeSupported = EFalse;

	//iterate through the list of usable SEPs looking for one that supports

	//the requested data type

	for (i=0; i<usableSEPs.Count(); i++)

		{

		SEP = usableSEPs[i];

		if (SEP.iDataType == aDataType)

			{//one of the usable SEPs supports the requested data type

			dataTypeSupported = ETrue;

			iDataType = aDataType;

			if (aDataType != iA2dpCodecConfiguration->HeadsetCodecDataType())

				{

				iA2dpCodecConfiguration->SetHeadsetCodecDataType(aDataType);

				iAudioSettingsHaveChanged = ETrue;

				}

			break;

			}

		else if ((SEP.iDataType == KMMFFourCCCodeSBC) && (aDataType == KMMFFourCCCodePCM16))

			{

			dataTypeSupported = ETrue;

			iDataType = aDataType;

			if (iA2dpCodecConfiguration->HeadsetCodecDataType()!= KMMFFourCCCodeSBC)

				{

				iA2dpCodecConfiguration->SetHeadsetCodecDataType(KMMFFourCCCodeSBC);

				iAudioSettingsHaveChanged = ETrue;

				}

			break;

			}		

		}

	if (!dataTypeSupported)

		{

		error = KErrNotSupported;

		}		

	return error;

	}

/**

Sets the sample rate 

@param aSampleRate

@return System wide error code indicating if the function call was successful.

		KErrNotReady if the headset is not initialized

		KErrInUse if the headset is already streaming

		KErrNotSupported if the sample rate is not supported

*/	

EXPORT_C TInt CA2dpBTHeadsetAudioInterface::SetSampleRate(TUint aSampleRate)

	{

	TInt error = KErrNone;

	if (iGAVDPStateMachine->State() == TGAVDPState::EGAVDPIdle)

		{

		return KErrNotReady;

		}

	if (iGAVDPStateMachine->State() == TGAVDPState::EGAVDPStreaming)

		{

		//don't allow this while we're streaming audio

		return KErrInUse; 

		}

	//check that the sample rate is supported

	RArray<TUint> supportedDiscreteRates;

	RArray<TRange> supportedRateRanges;

	GetSupportedSampleRates(supportedDiscreteRates, supportedRateRanges);

	if (supportedDiscreteRates.Find(aSampleRate) == KErrNotFound)

		{

		//in theory we should iterate through the ranges as well, however

		//SBC only suports discrete values so just return KErrNotSupported

		error = KErrNotSupported;

		}

	else

		{

		if (aSampleRate != iA2dpCodecConfiguration->SampleRate())

			{

			iA2dpCodecConfiguration->SetSampleRate(aSampleRate);

			iAudioSettingsHaveChanged = ETrue;

			}

		}

	supportedDiscreteRates.Close();

	supportedRateRanges.Close();

	return error;

	}

/**

Sets the number of channels 

@param aSampleChannels

@param aStereoSupport.  note that the aStereoSupport in the case of pcm16 refers to the output to the headset.

the data going for pcm16 is always either interleaved stereo pcm16 or mono

the aStereoSupport parameter is ignored for non stereo

@see TMMFStereoSupport

@return System wide error code indicating if the function call was successful.

		KErrNotReady if the headset is not initialized

		KErrInUse if the headset is already streaming

		KErrNotSupported if the datatype is not supported

*/	

EXPORT_C TInt CA2dpBTHeadsetAudioInterface::SetChannels(TUint aChannels, TMMFStereoSupport aStereoSupport)

	{

	TInt error = KErrNone;

	if (iGAVDPStateMachine->State() == TGAVDPState::EGAVDPIdle)

		{

		return KErrNotReady;

		}

	if (iGAVDPStateMachine->State() == TGAVDPState::EGAVDPStreaming)

		{

		return KErrInUse; //don't allow this while we're streaming audio

		}

	//check that the number of channels is supported

	RArray<TUint> supportedChannels;

	TMMFStereoSupport stereoSupport;

	GetSupportedChannels(supportedChannels, stereoSupport);

	if (supportedChannels.Find(aChannels) == KErrNotFound)

		{

		error = KErrNotSupported;

		}	

	else if (aChannels == EMMFStereo)

		{

		//now check stereo support

		if ((aStereoSupport & stereoSupport) != aStereoSupport)

			{

			error = KErrNotSupported;

			}

		else if (iA2dpCodecConfiguration->StereoSupport() != aStereoSupport)

			{

			iA2dpCodecConfiguration->SetStereoSupport(aStereoSupport);

			iAudioSettingsHaveChanged = ETrue;

			}

		}

	if (!error)

		{

		if (iA2dpCodecConfiguration->Channels() != aChannels)

			{

			iA2dpCodecConfiguration->SetChannels(aChannels);

			iAudioSettingsHaveChanged = ETrue;

			}

		}

	return error;

	}

/**

Procedure to gets the headset into the GAVDP Streaming state where 

it is ready to accept audio data.  The procedure causes a reconfiguration

of the headset incase the settings have changed - and if they haven't then the 

reconfigure does nothing.

The GAVDPStateChangeComplete callback is called after the reconfigure

where it puts the GAVDP state machine in the streaming state

The GAVDPStateChangeComplete callback is called again when the headset device

is in the streaming state.

@param aStatus

*/

EXPORT_C void CA2dpBTHeadsetAudioInterface::OpenDevice(TRequestStatus& aStatus)

	{

	iOpenDeviceRequestStatus = &aStatus;

	*iOpenDeviceRequestStatus = KRequestPending;

	if (iGAVDPStateMachine->State() == TGAVDPState::EGAVDPStreaming)

		{

		//device is already open

		User::RequestComplete(iOpenDeviceRequestStatus, KErrNone);

		return;

		}

	//this isn't a local error variable as it is used in the GAVDPStateChangeComplete callback

	iOpenDeviceError = KErrNone;

	//take out of sniff mode - no point in checking error code as there is

	//not much that can be done

	SetSniffMode(EFalse);

	//first reconfigure if the configuration has changed

	//note that there is a subtle difference between the configuration of the 

	//CA2dpBTHeadsetAudioInterface and that of the GAVDP state machine

	//the configuration of the CA2dpBTHeadsetAudioInterface is the configuration

	//seen from the DevSound whereas the CGAVDPStateMachine is the configuration

	//as seen by the headset.  In most cases they would be identical, the only

	//current case where the differ is in the data type where the DevSound sees

	//the data tpye as pcm16 but the headset is SBC

	iOpenDeviceError = iGAVDPStateMachine->Reconfigure(iAudioSettingsHaveChanged);

	if (iOpenDeviceError)

		{

		User::RequestComplete(iOpenDeviceRequestStatus, iOpenDeviceError);

		}

	else

		{

		//the Reconfigure will result in a GAVDPStateChangeComplete callback

		iReconfiguring = ETrue;

		}

	}

/**

 Procedure to cancel a GAVDP initialization sequence on an A2DP headset

*/	

EXPORT_C void CA2dpBTHeadsetAudioInterface::CancelOpenDevice()

	{

	if (iOpenDeviceRequestStatus)

		{

		if (*iOpenDeviceRequestStatus == KRequestPending)//make sure there is a pending request to cancel

			{

			iGAVDPStateMachine->CancelChangeState();

			}

		}

	}

/**

Procedure to put a headset that is in the GAVDP Streaming state back into

the GAVDP Open state

The GAVDPStateChangeComplete callback is called again when the headset device

is in the open state.

@param aStatus

*/	

EXPORT_C void CA2dpBTHeadsetAudioInterface::CloseDevice(TRequestStatus& aStatus)

	{

	iCloseDeviceRequestStatus = &aStatus;

	*iCloseDeviceRequestStatus = KRequestPending;

	if (iGAVDPStateMachine->State() != TGAVDPState::EGAVDPStreaming)

		{

		//device isn't open

		User::RequestComplete(iCloseDeviceRequestStatus, KErrNone);

		return;

		}

	else

		{

		if (iRTPStreamer)

			{

			iRTPStreamer->Pause();

			}

		//note the callback ProcessGAVDPStateChangeStreamingToOpen

		//will put the BT link back in sniff mode

		TGAVDPState state(TGAVDPState::EGAVDPOpen);

		TInt err = iGAVDPStateMachine->ChangeState(state);

		if (err)

			{

			User::RequestComplete(iCloseDeviceRequestStatus, err);

			}

		}

	}

/**

Procedure to get the headset volume

@return volume in the range 0-255

*/	

EXPORT_C TUint CA2dpBTHeadsetAudioInterface::Volume() const

	{

	return 0;

	}

/**

Procedure to set the volume in the range 0-255

Note this procedure requires the AVRCP bluettooth profile

in order to change the volume which is not implemented

@param aVolume the volume in the range 0-255

*/	

EXPORT_C TInt CA2dpBTHeadsetAudioInterface::SetVolume(TUint /*aVolume*/)

	{

	return KErrNone;

	}

/**

This function causes the CA2dpBTHeadsetAudioInterface to send the audio data contained in aData to the initialized A2DP headset.

The data is buffered internally and CA2dpBTHeadsetAudioInterface may already be playing audio

when this method is called.

The TRequestStatus is completed when the CA2dpBTHeadsetAudioInterface  has finished with the audio data contained in aData.  

By 'finished' this does not mean finished as in physically finished playing the audio,

but to inform the client that:

a)	it can repopulate the buffer with new audio data.

b)	the  CA2dpBTHeadsetAudioInterface is ready to accept another buffer of audio data via a further call to PlayData()

(ie the CA2dpBTHeadsetAudioInterface is not expected to accept multiple buffers in succession prior to completing their

TRequestStatus as this would not provide the client with any indication of whether the

sound drivers internal buffers are full).

@param aStatus  The TRequestStatus completed when the sound driver has finished with the audio data contained in aData.

The TRequestStatus is set to KErrNone unless the request has been cancelled via CancelPlayData()

in which case the status will be set to KErrCancel. 

The TRequestStatus is completed as soon as possible and before the audio has been physically played

in order for the client to send further audio buffers before the buffers already in the sound driver

are played out. 

Prior to calling PlayData() the client would be expected to Initialize Configure and Open the CA2dpBTHeadsetAudioInterface

and register with the sound driver that it requires notification of error conditions via a call to NotifyPlayError().

@param aData  Buffer containing the audio data to be played.  

aData, is not owned or created by the sound driver but is owned by the client.  

*/

EXPORT_C void CA2dpBTHeadsetAudioInterface::PlayData(const TDesC8& aData, TRequestStatus& aStatus)

	{

	__ASSERT_DEBUG((aData.Length()), Panic(EA2dpBTHeadsetNoData));

	__ASSERT_DEBUG((iRTPStreamer), Panic(EA2dpBTHeadsetNoRTPStreamer));

	iRTPStreamer->Send(aData, aStatus);

	}

/**

Cancels the current request for PlayData() if currently active.

The currently active PlayData() completes the request status immediately with KErrCancel.

*/	

EXPORT_C void CA2dpBTHeadsetAudioInterface::CancelPlayData()

	{

	__ASSERT_DEBUG((iRTPStreamer), Panic(EA2dpBTHeadsetNoRTPStreamer));

	iRTPStreamer->CancelLastSendBuffer();

	}

/**

Used to clear all internally buffered audio.  

This function does not complete any pending TRequestStatuses.  

*/	

EXPORT_C void CA2dpBTHeadsetAudioInterface::FlushBuffer()

	{

	__ASSERT_DEBUG((iRTPStreamer), Panic(EA2dpBTHeadsetNoRTPStreamer));

	iRTPStreamer->FlushPendingSendBuffers();

	}

/**

Returns the total number of bytes of data sent in PlayData that have been

sent to the headset.  ie the number of bytes sent prior to any encoding by the SBC codec.

It is updated after each buffer has been sent to the headset. 

The BytesPlayed are not reset to 0 on an error condition.

It must be explicitly reset via a call to ResetBytesPlayed().

@param The number of bytes played

*/	

EXPORT_C TUint CA2dpBTHeadsetAudioInterface::BytesPlayed() const

	{

	TUint bytesPlayed = 0;

	if (iRTPStreamer)//don't ASSERT iRTPStreamer here as this API still has meaning with no streamer

		{

		bytesPlayed = iRTPStreamer->BytesSent();

		}

	return bytesPlayed;

	}

/**

Resets bytes played to 0.

*/	

EXPORT_C void CA2dpBTHeadsetAudioInterface::ResetBytesPlayed()

	{

	if (iRTPStreamer)//don't ASSERT iRTPStreamer here as this API still has meaning with no streamer

		{

		iRTPStreamer->ResetBytesSent();

		}

	}

/**

Function to halt the sending of buffers to the headset.

Note that even if no buffers are being send via PlayData buffers

can still be sent to the headset as they are buffered internally

Calling PauseBuffer stops the internally buffered data being sent as well

as any buffers sent via PlayData

If the TRequestStatus from the previous PlayData() is outstanding then PausePlayBuffer()

does not complete the TRequestStatus.

The TRequestStatus will only be completed after ResumePlaying() is called.

*/	

EXPORT_C void CA2dpBTHeadsetAudioInterface::PauseBuffer()

	{

	__ASSERT_DEBUG((iRTPStreamer), Panic(EA2dpBTHeadsetNoRTPStreamer));

	iRTPStreamer->Pause();

	iPaused = ETrue;

	}

/**

This resumes playing from where playing was halted from the previous call to PauseBuffer().

The next TRequestStatus (if active) to be completed, is the request status from the previous PlayData()

prior to calling PausePlayBuffer().

If PausePlayBuffer() has not been called prior to ResumePlaying(),

then this method does nothing.

*/	

EXPORT_C void CA2dpBTHeadsetAudioInterface::ResumePlaying()

	{

	__ASSERT_DEBUG((iRTPStreamer), Panic(EA2dpBTHeadsetNoRTPStreamer));

	iRTPStreamer->Resume();

	iPaused = EFalse;

	}

/**

This function is used when the client is requesting notification of an error that occurs during playback.

The TRequestStatus passed in the NotifyPlayError() method is separate to the TRequestStatus passed into the PlayData() method,

and hence the client would typically have a separate active object for both the PlayData()

and NotifyPlayError() TRequestStatuses.

The NotifyPlayError() method is required because if an error occurs during playback,

the PlayData() TRequestStatus may not be active.

If a PlayData() request status is active then the error is reported back via the PlayData()

TRequestStatus and not via the NotifyPlayError() TRequestStatus.

If no PlayData() TRequestStatus is active then the error is reported back by completing the NotifyPlayError()

TRequestStatus with the appropriate error code.

Note that a call to CancelPlayData() should complete the PlayData() request status with KErrCancel

and should not complete the NotifyPlayError() TRequestStatus.

@param aStatus TRequestStatus completed when a play error occurs.

*/	

EXPORT_C void CA2dpBTHeadsetAudioInterface::NotifyError(TRequestStatus& aStatus)

	{

	iNotifyRequestStatus= &aStatus;

	*iNotifyRequestStatus = KRequestPending;

	}

/**

Cancels the NotifyPlayError() TRequestStatus if currently active.

The TRequestStatus completes immediately with KErrCancel.

*/	

EXPORT_C void CA2dpBTHeadsetAudioInterface::CancelNotifyError()

	{

	User::RequestComplete(iNotifyRequestStatus, KErrCancel);

	}

/**

Callback from the RTPStreamer when an unexpected event occurs

@param aError

*/

void CA2dpBTHeadsetAudioInterface::RTPStreamerEvent(TInt aError)

	{

	//an error has occured while streaming

	__ASSERT_DEBUG((iRTPStreamer), Panic(EA2dpBTHeadsetNoRTPStreamer));

	//could also be EGAVDPIdle as we could have just received a GAVDPStateMachineEvent

	//which would reset the state to EGAVDPIdle

	__ASSERT_DEBUG((iGAVDPStateMachine->State() == TGAVDPState::EGAVDPStreaming) ||

	(iGAVDPStateMachine->State() == TGAVDPState::EGAVDPIdle), Panic(EA2dpBTHeadsetUnExpectedState));

	TGAVDPState state(TGAVDPState::EGAVDPIdle);

	TInt err = iGAVDPStateMachine->ChangeState(state);

	//the above returns an error code but there's not much we can do if it returns an error

	if (iNotifyRequestStatus)

		{

		if (*iNotifyRequestStatus == KRequestPending)

			{

			User::RequestComplete(iNotifyRequestStatus, aError);

			}

		}

	}

/**

Callback from the GAVDPStateMachine when an error event occurs

@param aError

*/	

void  CA2dpBTHeadsetAudioInterface::GAVDPStateMachineEvent(TInt aError)

	{

	//an error has occured - if an error occurs then it could be

	//because we've lost the connection to the headset eg because it is out of range

	//has been switched off etc there we assume that the connection has been

	//lost and put the GAVDP state back to idle

	//note we're simplifying things somewhat as some errors may not be a result 

	//of a loss of connection to the headset

	TGAVDPState state(TGAVDPState::EGAVDPIdle);

	TInt err = iGAVDPStateMachine->ChangeState(state);

	if (!iRTPStreamer)

		{//if we don't have an RTP streamer

		//then close the bearer socket.  If we do have an RTP streamer

		//then delay the close till after we have deleted the RTPStreamer in the

		//the GAVDPStateChangeComplete callback.  this is because

		//closing the bearer socket before the RTP streamer is deleted

		//can panic the RTP stack.

		iGAVDPStateMachine->BearerSocket().Close();

		}	

	if (iNotifyRequestStatus)

		{

		if (*iNotifyRequestStatus == KRequestPending)

			{

			User::RequestComplete(iNotifyRequestStatus, aError);

			}

		}

	}

/**

Callback from the GAVDPStateMachine when the headset has suspended the stream

*/