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