// 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 "A2dpCodecUtilities.h"

#include "GavdpStateMachine.h"

/**

GAVDP State Machine Panics

**/

enum TGavdpStateMachinePanic

	{

	EGavdpStateMachineBadState,//0

	EGavdpStateMachineBadConfigByRemoteHeadsetState,//1

	EGavdpStateMachineBadBTAddr,//2

	EGavdpStateMachineUnexpectedCallback,//3

	EGavdpStateMachineDataTypeMismatch//4

	};

static void Panic(TGavdpStateMachinePanic aPanic)

// Panic client

	{

	_LIT(KGavdpStateMachinePanicName, "GAVDP State Mchn");

	User::Panic(KGavdpStateMachinePanicName, aPanic);

	}

/**

Utility function to map a bluetooth code to a standard SymbianOS code

Where a standard Symbian error code exists the error is mapped

to the standard code.  Ideally all HCI, L2CAP, AVDTP, GAVDP errors

should be mapped to standard SymbianOS codes since bluetooth specific

error codes aren't meaningful in the multimedia domain

*/

static TInt ConvertToStandardSymbianOSError(TInt aError)

	{

	TInt error;

	switch (aError)

		{

		case KHCIErrorBase-EPageTimedOut://-6004

			error = KErrCouldNotConnect;

			break;

		case KHCIErrorBase-EAuthenticationFailure://-6005

			error = KErrCouldNotConnect;

			break;

		case KHCIErrorBase-EPairingNotAllowed: //-6024

			error = KErrCouldNotConnect;

			break;

		case KHCIErrorBase-ELMPResponseTimeout: //-6034

			error = KErrTimedOut;

			break;

		case KErrHCIConnectFailed: //-6304

			error = KErrCouldNotConnect;

			break;

		case KErrHCILinkDisconnection: //-6305

			error = KErrDisconnected;

			break;

		default:

			error = aError;

			break;

		}

	return error;

	}

/**

Creates CGAVDPStateMachine

@internalComponent

@return CGAVDPStateMachine*

*/

CGAVDPStateMachine* CGAVDPStateMachine::NewL(MGAVDPStateChangeObserver& aGAVDPStateChangeObserver, CA2dpAudioCodecConfiguration& aA2dpCodecSettings, RSocketServ& aSocketServer)

	{

	CGAVDPStateMachine* self = new(ELeave) CGAVDPStateMachine(aGAVDPStateChangeObserver, aA2dpCodecSettings, aSocketServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Constructor

[TODO] change default stereo mode to EMMFJoint when hardware has sufficient bandwidth

Note we make the AO priority one less than normal to give the AOs in GAVDP

preference

*/

CGAVDPStateMachine::CGAVDPStateMachine(MGAVDPStateChangeObserver& aGAVDPStateChangeObserver, CA2dpAudioCodecConfiguration& aA2dpCodecSettings, RSocketServ& aSocketServer) : CActive(EPriorityNormal-1), 

iGAVDPStateChangeObserver(aGAVDPStateChangeObserver) ,iA2dpCodecSettings(aA2dpCodecSettings), iSocketServer(aSocketServer)

	{

	CActiveScheduler::Add(this);

	}

void CGAVDPStateMachine::ConstructL()

	{

	User::LeaveIfError(iGavdp.Open(*this, iSocketServer));

	User::LeaveIfError(RegisterLocalSEP());

	iSignallingTransactionTimeout = CGavdpTimeout::NewL(*this);

	}

/**

Internal function to register local SEPs with GAVDP

The function sets the iSymbianDeviceSEID to the TSEID 

of the Symbian device

*/	

TInt CGAVDPStateMachine::RegisterLocalSEP()

	{

	//register SEPs - currently SBC & mp3 SEPs are supported

	TAvdtpSEPInfo avdtpSEPInfo;	

	avdtpSEPInfo.SetInUse(EFalse);

	avdtpSEPInfo.SetMediaType(EAvdtpMediaTypeAudio);

	avdtpSEPInfo.SetIsSink(EFalse);

	TInt err = iGavdp.RegisterSEP(avdtpSEPInfo);	

	TUsableSEP sep;

	sep.iSEID = avdtpSEPInfo.SEID();

	sep.iDataType = KMMFFourCCCodeSBC;

	err = iSymbianDeviceSEPs.Append(sep);

	if (!err)

		{

		avdtpSEPInfo.SetInUse(EFalse);

		avdtpSEPInfo.SetMediaType(EAvdtpMediaTypeAudio);

		avdtpSEPInfo.SetIsSink(EFalse);

		err = iGavdp.RegisterSEP(avdtpSEPInfo);

		if (!err)

			{

			sep.iSEID = avdtpSEPInfo.SEID();

			sep.iDataType = KMMFFourCCCodeMP3;

			err = iSymbianDeviceSEPs.Append(sep);

			}

		}			

	if (!err)

		{

		TBool SEPDataTypeFound(EFalse);

		for(TUint i = 0; i< iSymbianDeviceSEPs.Count();i++)

			{

			if (iSymbianDeviceSEPs[i].iDataType == iA2dpCodecSettings.HeadsetCodecDataType()) 

				{

				iSymbianDeviceSEID = iSymbianDeviceSEPs[i].iSEID;

				SEPDataTypeFound = ETrue;

				break;

				}

			}

		if (!SEPDataTypeFound)

			{

			err = KErrNotFound;

			}

		}

	return err;

	}

/**

Standard destructor.

*/

CGAVDPStateMachine::~CGAVDPStateMachine()

	{

	Cancel();

	iBearerSocket.Close();

	iGavdp.Close();

	iPotentialSEPs.Close();

	iUsableSEPs.Close();

	iSymbianDeviceSEPs.Close();

	iSEPCapabilities.ResetAndDestroy();

	iSEPCapabilities.Close();

	delete iSignallingTransactionTimeout;

	}

/**

Function to set the Bluetooth address of the headset.

@param aRemoteAddress Bluetooth address of the headset

*/

void CGAVDPStateMachine::SetBTAddress(const TBTDevAddr& aRemoteAddress)

	{

	if (iBTDevAddr != aRemoteAddress)

		{//must be using a new headet so reset state machine

		Reset();

		iBTDevAddr = aRemoteAddress;

		}

	}

/**

Function to returns the current state of the GAVDP state machine.

@return the current state of the GAVDP state machine

*/

TGAVDPState CGAVDPStateMachine::State() const

	{

	return iCurrentState ;

	}

/**

Internal function to resets the GAVDP state machine to the EGAVDPIdle state

Note that if the headset is already connected Reseting

will cause a subsequent call to RGavdp.Connect, however

if we are already connected this should complete straight away

Note we don't close the bearer socket here as we need to ensure

this is closed after the RTP streamer is deleted so this is handled by the CA2dpBTHeadsetAudioInterface

*/

void CGAVDPStateMachine::Reset()

	{

	iPotentialSEPs.Reset();

	iUsableSEPs.Reset();

	iSEPCapabilities.ResetAndDestroy();

	iSEPIterator = 0;

	iSEPCapabilityEntry = 0;

	iA2dpCodecSettings.Reset();

	iInitialState = TGAVDPState::EGAVDPIdle;

	iCurrentState = TGAVDPState::EGAVDPIdle;

	iNextState = TGAVDPState::EGAVDPIdle;

	iTargetState = TGAVDPState::EGAVDPIdle;

	iConfigurationByRemoteHeadsetState.Reset();

	iHeadsetSEID.Reset();

	iLocalSEPConfigured = EFalse;

	iChangeOfSelectedHeadsetSEP = EFalse;

	iGavdp.Cancel();

	iSignallingTransactionTimeout->Cancel();

	}

/**

Function to move the GAVDP state machine to the state specified in aNewState

Not all state changes are allowed, however. 

Permitted state changes are anystate to ->EGAVDPIdle,EConnectedToGavdp,ESEPsDiscovered

which causes a reset.  

Anything prior to EGAVDPOpen->EGAVDPOpen

EGAVDPOpen->EGAVDPStreaming

EGAVDPStreaming->EGAVDPOpen

When the state change is completed a GAVDPStateChangeComplete callback is 

made on the MGAVDPStateChangeObserver, which is the CA2dpBTHeadsetAudioInterface

@param aNewState The state we wish to go to

@return standard SymbianOS error code

*/

TInt CGAVDPStateMachine::ChangeState(const TGAVDPState& aNewState)

	{

	if (iStateChangeInProgress)

		{//can't change state if a state change is already in progress

		return KErrNotReady; 

		}

	if (aNewState.State()<= TGAVDPState::ESEPSelected)

		{

		//if the state is ESEPSelected or less then

		//the assumption is we need to reselect the SEP and in

		//effect redo the entire initialization prior to selecting the SEP

		//therefore roll back to EGAVDPIdle and reset.

		Reset();

		}

	else if (aNewState == TGAVDPState::EGAVDPStreaming)

		{

		//must be in the EGAVDPOpen state in order to go to EGAVDPStreaming

		if (iCurrentState != TGAVDPState::EGAVDPOpen)

			{

			return KErrNotReady;

			}

		}

	if (aNewState == iCurrentState)

		{

		//then we are already in the requested state so don't move to

		//next state- so just call the RunL and complete

		iStateChangeInProgress = EFalse;//we're not going to change the state

		TRequestStatus* stat = &iStatus;

		if (!IsActive())

			{

			User::RequestComplete(stat, KErrNone);

			SetActive();

			}

		}

	else

		{//need to move to the next state

		iInitialState = iCurrentState; //incase we need to wind back if state change fails

		iTargetState = aNewState;

		NextState();

		}

	return KErrNone;

	}

/**

Function to cause a reconfiguration of the SEP.  The function determines 

whether a reconfiguration is required ie becuase the settings have changed.

And if so the SEP is reconfigured or a new SEP is selected if the reconfiguration

results in a change of SEP ie because the datatype has changed

This function makes a GAVDPStateChangeComplete callback on the CA2dpBTHeadsetAudioInterface

If the SEP changes because of a change in data type then the 	iChangeOfSelectedHeadsetSEP

flag is set which is used by the state machine to cause the media transport

caps to be added to the SEP

@param aSettingsHaveChanged set to ETrue if the settings have changed

@return SymbianOS error code

*/	

TInt CGAVDPStateMachine::Reconfigure(TBool aSettingsHaveChanged)

	{

	//not allowed to reconfigure in the middle of a state change	

	if ((iStateChangeInProgress)||(IsActive()))

		{

		return KErrNotReady;

		}	

	//in order to perform a reconfigure the current state must

	//be either EConfigured or EGAVDPOpen

	//reconfiguration by the SymbianOs device in the streaming state is not supported

	//in this implementation even though it is allowed by the GAVDP profile

	if ((iCurrentState != TGAVDPState::EConfigured) &&

		(iCurrentState != TGAVDPState::EGAVDPOpen))

		{

		return KErrNotReady;

		}

	__ASSERT_DEBUG((iCurrentState == iTargetState), Panic(EGavdpStateMachineBadState));//this should always be true if no state change is in progress

	iChangeOfSelectedHeadsetSEP = EFalse;

	if (aSettingsHaveChanged)

		{//then see if we need to change SEP

		//data type has changed so we need to choose a different SEP

		//and configure it

		//note if no match is found then we go with the exiting

		//selected SEP

		for (TUint i=0;  i<iUsableSEPs.Count() ; i++)

			{

			TUsableSEP sep = iUsableSEPs[i];

			if (sep.iDataType == iA2dpCodecSettings.HeadsetCodecDataType())

				{//then we have a match so use this SEP

				if (sep.iSEID != iHeadsetSEID)

					{//then this is a different SEP to the one we were already using

					iHeadsetSEID = sep.iSEID;

					iLocalSEPConfigured = EFalse;

					iChangeOfSelectedHeadsetSEP = ETrue;//need to config transport capabilites again if change of SEP

					//need to change the symbian device SEP as well

					TBool symbianDeviceSupportsNewSEPDataType(EFalse);

					for(TUint i = 0; i< iSymbianDeviceSEPs.Count();i++)

						{

						if (iSymbianDeviceSEPs[i].iDataType == sep.iDataType) 

							{

							iSymbianDeviceSEID = iSymbianDeviceSEPs[i].iSEID;

							symbianDeviceSupportsNewSEPDataType = ETrue;

							break;

							}

						}

					__ASSERT_DEBUG(symbianDeviceSupportsNewSEPDataType, Panic(EGavdpStateMachineDataTypeMismatch));

					//the if condition below is totaly unnecesaary since we have already

					//ASSERTed symbianDeviceSupportsNewSEPDataType, however the ARM 5 compiler

					//does not seem to recognize code in ASSERT statements so the if statement

					//supresses an ARM v5 compiler warning

					if (symbianDeviceSupportsNewSEPDataType)

						{

						iBearerSocket.Close(); //if we change headset SEP then the old bearer is no longer valid 

						}

					}

				}

			}

		}

	//if a reconfigure is required then we need to reset the current state

	//to ESEPSelected and reconfigure 

	iInitialState = iCurrentState; //incase we need to wind back if state change fails

	if ((aSettingsHaveChanged)||(iChangeOfSelectedHeadsetSEP))

		{

		iTargetState = iCurrentState;  //need to end up in the same state we started at

		iCurrentState = TGAVDPState::ESEPSelected; //roll back the state machine to ESEPSelected

		iNextState = iCurrentState;

		NextState(); //make sure the NextState is EConfigured

		}

	else

		{//go to RunL to make GAVDPStateChangeComplete callback

		if (!IsActive())

			{

			TRequestStatus* stat = &iStatus;

			User::RequestComplete(stat, KErrNone);

			SetActive();

			}

		}

	return KErrNone;

	}

/**

Advance to Next state

*/	

void CGAVDPStateMachine::NextState()

	{

	iStateChangeInProgress = ETrue;

	TRequestStatus* stat = &iStatus;

	++iNextState;

	if (!IsActive())

		{

		User::RequestComplete(stat, KErrNone);

		SetActive();

		}

	}

/**

Internal function to complete the state change

*/	

void CGAVDPStateMachine::StateChangeComplete()

	{

	iCurrentState = iNextState;

	if (iCurrentState == iTargetState)

		{

		iStateChangeInProgress = EFalse;

		iGAVDPStateChangeObserver.GAVDPStateChangeComplete(iInitialState, KErrNone);

		}

	else

		{//we've completed the internal state change but have not reached the target state

		NextState();

		}

	}

/**

Function to cancel a state change initialited by the ChangeState function

This function is called when the change state is explicitly cancelled by the client

*/

void CGAVDPStateMachine::CancelChangeState()

	{

	//if we call this externally then the reason is KErrCancel

	//as the state change has been explicitely cancelled

	CancelChangeState(KErrCancel);

	}

/**

Internal function to cancel a state change initiated by the ChangeState function

Usually called when an error occurs that would prevent the state change

from completing

*/	

void CGAVDPStateMachine::CancelChangeState(TInt aReason)

	{

	if (iStateChangeInProgress)

		{//unwind the request as far as possible

		switch (iInitialState.State())

			{

			case TGAVDPState::EGAVDPIdle:

				Reset();

				break;

			case TGAVDPState::EGAVDPOpen:

				iGavdp.Cancel();

				iCurrentState = TGAVDPState::EGAVDPOpen;

				iNextState = TGAVDPState::EGAVDPOpen;

				iTargetState = TGAVDPState::EGAVDPOpen;

				break;

			case TGAVDPState::EGAVDPStreaming:

				iGavdp.Cancel();

				iNextState = TGAVDPState::EGAVDPStreaming;

				iTargetState = TGAVDPState::EGAVDPStreaming;

				break;

			default:

				Panic(EGavdpStateMachineBadState);

				break;		

			}	

		}

	if (IsActive())

		{

		Cancel();

		}

	iStateChangeInProgress = EFalse;

	iGAVDPStateChangeObserver.GAVDPStateChangeComplete(iInitialState, aReason);

	}

/**

Internal function to initiate the connection to the headset

*/

void CGAVDPStateMachine::ConnectToGAVDP()

	{

	iGavdp.Connect(iBTDevAddr);

	}

/**

MGavdpUser callback to indicate the headset is connected

@see MGavdpUser

*/	

void CGAVDPStateMachine::GAVDP_ConnectConfirm(const TBTDevAddr& aDevice)

	{

	if (!iStateChangeInProgress)

		{//connect initiated by remote headset so we'll accept the address

		iBTDevAddr = aDevice;

		iCurrentState == TGAVDPState::EConnectedToGavdp;

		}

	else if (iBTDevAddr == aDevice)

		{//if a state change is in progress then we have already set the bt

		//address so the above should be true

		//if its not we'll treat the connect as a spurious connect and ignore

		if (iCurrentState.State() == TGAVDPState::EGAVDPIdle)

			{//if the above isn't true then must be a spurious connect from the headset

			//now connected to the device in question

			StateChangeComplete();

			}	

		}

	}

/**

MGavdpUser callback to indicate the headset has suspended streaming

Makes a GAVDPStateMachineStreamSuspendedByRemoteHeadset MGAVDPStateChangeObserver

callback on the CA2dpBTHeadsetAudioInterface

@see MGavdpUser

*/

TInt CGAVDPStateMachine::GAVDP_SuspendIndication(TSEID aSEID)

	{

	TInt err = KErrNone;

	//first check the callback is for the symbian device SEP we are using to 

	//send data to the a2dp headset - incase the Symbian device has more than one SEP

	if (aSEID == iSymbianDeviceSEID)

		{

		__ASSERT_DEBUG((iCurrentState.State() == TGAVDPState::EGAVDPStreaming), Panic(EGavdpStateMachineUnexpectedCallback));

		//need to stop the RTP streamer from sending more packets to the headset

		iGAVDPStateChangeObserver.GAVDPStateMachineStreamSuspendedByRemoteHeadset();

		iCurrentState = TGAVDPState::EGAVDPSuspended;

		}

	else

		{

		err = ConvertToSymbianError::AvdtpError(EAvdtpBadACPSEID);

		}

	return err;

	}

/**

MGavdpUser callback to indicate the headset wished to configure the SymbianDevice

@see MGavdpUser

*/

void CGAVDPStateMachine::GAVDP_ConfigurationStartIndication(TSEID aLocalSEID, TSEID aRemoteSEID)

	{

	//first check the callback is for the symbian device SEP we are using to 

	//send data to the a2dp headset - incase the Symbian device has more than one SEP

	if (aLocalSEID == iSymbianDeviceSEID)

		{

		__ASSERT_DEBUG((iCurrentState.State() != TGAVDPState::EGAVDPStreaming), Panic(EGavdpStateMachineUnexpectedCallback));

		__ASSERT_DEBUG(iConfigurationByRemoteHeadsetState.State() == TConfigurationByRemoteHeadsetState::ENotBeingConfiguredByRemoteHeadset, Panic(EGavdpStateMachineBadConfigByRemoteHeadsetState));

		//cancel any current state changes - config is being driven by headset

		Cancel();

		iGavdp.Cancel();

		//no timeouts are required as if the headset goes down ie does not 

		//result in the expected GAVDP_ConfigurationIndication callbacks a GAVDP_Error

		//callback occurs.

		iConfigurationByRemoteHeadsetState = TConfigurationByRemoteHeadsetState::ERemoteHeadsetConfigurationStart;

		//we just store the remote SEP for now

		iConfigurationByRemoteHeadsetState.SetSEPRequestedByRemoteHeadset(aRemoteSEID);

		}

	//	else we can't return an error if the aLocalSEID is not for the SymbianOS device

	}

/**

MGavdpUser callback to request the SymbianOS device to take the configuration passed in aCapability

Only SBC reconfigurations by the remote headset are supported, sample rate changes

are not supported, changes in the number of channels are not suported

if the capability is TSBCCodecCapabilities then the function checks that the values

requested can be accepted.

@see MGavdpUser

*/

TInt CGAVDPStateMachine::GAVDP_ConfigurationIndication(TAvdtpServiceCapability* aCapability)

	{

	//the underlying GAVDP/AVDTP code should ensure that this 

	//callback from GAVDP never occurs once the headset has been configured	

	__ASSERT_DEBUG((iCurrentState.State() != TGAVDPState::EGAVDPStreaming), Panic(EGavdpStateMachineUnexpectedCallback));

	__ASSERT_DEBUG(iConfigurationByRemoteHeadsetState.State() == TConfigurationByRemoteHeadsetState::ERemoteHeadsetConfigurationStart, Panic(EGavdpStateMachineBadConfigByRemoteHeadsetState));

	TInt err = KErrNone;

	switch(aCapability->Category())

		{

		case EServiceCategoryMediaTransport:

			{

			TAvdtpMediaTransportCapabilities* mediaTransportCaps = static_cast<TAvdtpMediaTransportCapabilities*>(aCapability);

			iConfigurationByRemoteHeadsetState.SetTransportCapsRequestedByRemoteHeadset(mediaTransportCaps);

			}

			break;

		case EServiceCategoryMediaCodec:

			{

			TAvdtpMediaCodecCapabilities* codecCaps = static_cast<TAvdtpMediaCodecCapabilities*>(aCapability);

			if (codecCaps->MediaType() != EAvdtpMediaTypeAudio)

				{

				err = ConvertToSymbianError::A2dpError(EA2dpNotSupportedCodec);

				}

			//we're only going to allow a reconfiguration for SBC

			if ((codecCaps->MediaCodecType() == EAudioCodecSBC) && (iA2dpCodecSettings.HeadsetCodecDataType() == KMMFFourCCCodeSBC))

				{

				TSBCCodecCapabilities* sbcCodecCapabilities = static_cast<TSBCCodecCapabilities*>(codecCaps);

				TSBCSamplingFrequencyBitmask samplingFreqBitMask = sbcCodecCapabilities->SamplingFrequencies();

				//if the headset has already been configured then we don't allow a change 

				//of sampling frequency.  This is because once the DevSound has been configured

				//with a sampling frequency after the DevSound is initialized and hence

				//the a2dpheadsetif is initialized, it is no longer possible to change the sample frequency

				TBool headsetAlreadyConfigured(EFalse);

				if ((iCurrentState.State() == TGAVDPState::EGAVDPOpen) ||

				(iCurrentState.State() == TGAVDPState::EGAVDPSuspended))

					{

					headsetAlreadyConfigured = ETrue;

					}

				//only one bit of the sampling frequency mask should be set

				//note we're using switch statements rather than if then else

				//it makes it easier to pick up the case where we have an invalid

				//value or more than one value has been set in the bit mask

				switch (samplingFreqBitMask)

					{

					case E16kHz:

						if ((headsetAlreadyConfigured) && (iA2dpCodecSettings.SampleRate() != 16000))

							{

							err = ConvertToSymbianError::A2dpError(EA2dpNotSupportedSamplingFrequency);

							}

						break;

					case E32kHz:

						if ((headsetAlreadyConfigured) && (iA2dpCodecSettings.SampleRate() != 32000))

							{

							err = ConvertToSymbianError::A2dpError(EA2dpNotSupportedSamplingFrequency);

							}

						break;

					case E44100Hz:

						if ((headsetAlreadyConfigured) && (iA2dpCodecSettings.SampleRate() != 44100))

							{

							err = ConvertToSymbianError::A2dpError(EA2dpNotSupportedSamplingFrequency);

							}

						break;

					case E48kHz:

						if ((headsetAlreadyConfigured) && (iA2dpCodecSettings.SampleRate() != 48000))

							{

							err = ConvertToSymbianError::A2dpError(EA2dpNotSupportedSamplingFrequency);

							}

						break;

					default:

						err = ConvertToSymbianError::A2dpError(EA2dpInvalidSamplingFrequency);

						break;

					}

				TSBCChannelModeBitmask channelModeBitMask =  sbcCodecCapabilities->ChannelModes();

				//if the headset has already been configured then we don't allow a change 

				//of channels.  This is because once the DevSound has been configured

				//with a sampling frequency after the DevSound is initialized and hence

				//the a2dpheadsetif is initialized, it is no longer possible to change the number of channels

				switch (channelModeBitMask)

					{

					case EMono:

						if ((headsetAlreadyConfigured) && (iA2dpCodecSettings.Channels() != EMMFMono))

							{

							err = ConvertToSymbianError::A2dpError(EA2dpNotSupportedChannelMode);

							}

						break;

					case EDualChannel: //we don't support dual channel

						err = ConvertToSymbianError::A2dpError(EA2dpNotSupportedChannelMode);

						break;

					case EStereo:

						if ((headsetAlreadyConfigured) && (iA2dpCodecSettings.Channels() != EMMFStereo))

							{

							err = ConvertToSymbianError::A2dpError(EA2dpNotSupportedChannelMode);

							}

						break;

					case EJointStereo:

						if ((headsetAlreadyConfigured) && (iA2dpCodecSettings.Channels() != EMMFStereo))

							{

							err = ConvertToSymbianError::A2dpError(EA2dpNotSupportedChannelMode);

							}

						break;

					default:

						err = ConvertToSymbianError::A2dpError(EA2dpInvalidChannelMode);

						break;

					}

				TSBCBlockLengthBitmask blockLengthBitMask = sbcCodecCapabilities->BlockLengths();

				switch (blockLengthBitMask)

					{

					case EBlockLenFour:

						break;

					case EBlockLenEight:

						break;

					case EBlockLenTwelve:

						break;

					case EBlockLenSixteen:

						break;

					default:

						err = ConvertToSymbianError::A2dpError(EA2dpInvalidBlockLength);

						break;

					}

				TSBCSubbandsBitmask subbandsBitMask = sbcCodecCapabilities->Subbands();

				TUint subbands = 0;

				switch (subbandsBitMask) 

					{

					case EFourSubbands:

						subbands = 4;

						break;

					case EEightSubbands:

						subbands = 8;

						break;

					default:

						err = ConvertToSymbianError::A2dpError(EA2dpInvalidSubbands);

						break;

					}

				TSBCAllocationMethodBitmask allocationMethodBitMask = sbcCodecCapabilities->AllocationMethods();

				switch (allocationMethodBitMask)

					{

					case ELoudness:

						break;

					case ESNR:

						break;

					default:

						err = ConvertToSymbianError::A2dpError(EA2dpInvalidAllocationMethod);

						break;

					}

				TInt bitPoolValue = sbcCodecCapabilities->MinBitpoolValue();

				if (bitPoolValue < KMinBitPoolValue)

					{

					err = ConvertToSymbianError::A2dpError(EA2dpInvalidMinimumBitPoolValue);

					}

				bitPoolValue = sbcCodecCapabilities->MaxBitpoolValue();

				//The bitpool value must be in the range of 2-250 and must not exceed

				// 16*numberOfSubbands*channels

				if ((bitPoolValue > KMaxBitPoolValue)||(bitPoolValue > (16*subbands*iA2dpCodecSettings.Channels())))

					{		

					err = ConvertToSymbianError::A2dpError(EA2dpInvalidMaximumBitPoolValue);

					}

				if (!err)

					{//note ownership of codecCaps is transferred

					iConfigurationByRemoteHeadsetState.SetCodecConfigRequestedByRemoteHeadset(codecCaps);

					}

				}//if (codecCaps->MediaCodecType() == EAudioCodecSBC) && (iA2dpCodecSettings.HeadsetCodecDataType() == KMMFFourCCodeSBC))

			else

				{//only support SBC for now

				err = ConvertToSymbianError::A2dpError(EA2dpNotSupportedCodec);

				}

			}

			break; //case EServiceCategoryMediaCodec:

		default: //	switch(aCapability->Category())

			err = KErrNotSupported;

			break;

		}

	if (err)

		{

		iConfigurationByRemoteHeadsetState = TConfigurationByRemoteHeadsetState::ERemoteHeadsetConfigurationFailed;

		if ((iCurrentState.State() < TGAVDPState::EConfigured) && (iCurrentState.State() != TGAVDPState::EGAVDPIdle))

			{//we only abort if the remote headset has not been configured

			//need to abort using SEID of remote headset - this resets config at remote headset

			Cancel(); //probably not necessary - but just in case

			iGavdp.AbortStream(iConfigurationByRemoteHeadsetState.SEPRequestedByRemoteHeadset());

			}

		//else

		//config is a reconfig in suspend streams 

		//wait on a Start_Indication if the headset is ok with the existing config

		//or an Abort_Indication if the headset is not

		}

	return err;

	}

/*

MGavdpUser callback to indicate to the SymbianOS device that all the GAVDP_ConfigurationIndications

have been sent.

This callback should only occur if there have been no errored GAVDP_ConfigurationIndications

@see MGavdpUser

*/

TInt CGAVDPStateMachine::GAVDP_ConfigurationEndIndication()

	{	

	//the underlying GAVDP/AVDTP code should ensure that this 

	//callback from GAVDP never occurs once the headset has been configured

	__ASSERT_DEBUG((iCurrentState.State() != TGAVDPState::EGAVDPStreaming), Panic(EGavdpStateMachineUnexpectedCallback));

	__ASSERT_DEBUG(iConfigurationByRemoteHeadsetState.State() == TConfigurationByRemoteHeadsetState::ERemoteHeadsetConfigurationStart, Panic(EGavdpStateMachineBadConfigByRemoteHeadsetState));

	TInt err = KErrNone;

	TAvdtpMediaCodecCapabilities* configRequestedByRemoteHeadset = iConfigurationByRemoteHeadsetState.CodecConfigRequestedByRemoteHeadset();

	if (configRequestedByRemoteHeadset)

		{

		__ASSERT_DEBUG(iConfigurationByRemoteHeadsetState.SEPRequestedByRemoteHeadset().IsValid(), Panic(EGavdpStateMachineBadConfigByRemoteHeadsetState));

		//the headset settings have been accepted so use the headset settings

		//the only usable SEP shall be the once specified by the headset

		//for now this will always be SBC

		TUsableSEP SEP;

		SEP.iSEID = iConfigurationByRemoteHeadsetState.SEPRequestedByRemoteHeadset();

		TFourCC dataTypeSupport;

		switch (configRequestedByRemoteHeadset->MediaCodecType())

			{

			case EAudioCodecSBC:

				dataTypeSupport.Set(KMMFFourCCCodeSBC);

				break;

			case EAudioCodecMPEG12Audio:

				dataTypeSupport.Set(KMMFFourCCCodeMP3);

				break;

			case EAudioCodecMPEG24AAC:

				dataTypeSupport.Set(KMMFFourCCCodeAAC);

				break;

			case EAudioCodecATRAC:

				dataTypeSupport.Set(KMMFFourCCCodeATRAC3);

				break;

			default://should never get here

				Panic(EGavdpStateMachineBadConfigByRemoteHeadsetState);

				break;

			}

		SEP.iDataType.Set(dataTypeSupport);

		iUsableSEPs.Reset();

		err = iUsableSEPs.Append(SEP);

		//the only service capabilities are codec caps provided by the headset and transport

		if (!(iA2dpCodecSettings.UpdateRemoteCodecConfiguration(*configRequestedByRemoteHeadset)))

			{

			err = KErrNoMemory;

			}

		if (!err)

			{

			iSEPCapabilities.ResetAndDestroy();

			err = iSEPCapabilities.Append(iConfigurationByRemoteHeadsetState.TransportCapsRequestedByRemoteHeadset());

			if (!err)

				{

				err = iSEPCapabilities.Append(iConfigurationByRemoteHeadsetState.CodecConfigRequestedByRemoteHeadset());

				}

			}	

		}//	if (codecCaps)

	if (!err)

		{

		if ((iStateChangeInProgress) && (iInitialState.State() == TGAVDPState::EGAVDPIdle))

			{//the headset configured us during an a2dpheadsetif Initialize()

			//we're now configured so now wait for GAVDP_Bearer ready

			iCurrentState == TGAVDPState::EConfigured;

			}

		else if (iCurrentState == TGAVDPState::EGAVDPSuspended)

			{

			//we have reconfigured so the SBC codec needs reconfiguring

			err = iGAVDPStateChangeObserver.GAVDPStateMachineReconfigureByRemoteHeadset();

			}

		}

	if (err)

		{

		if ((iCurrentState.State() < TGAVDPState::EConfigured) && (iCurrentState.State() != TGAVDPState::EGAVDPIdle))

			{//we only abort if the remote headset has not been configured

			//need to abort using SEID of remote headset - this resets config at remote headset

			Cancel(); //probably not necessary - but just in case

			iGavdp.AbortStream(iConfigurationByRemoteHeadsetState.SEPRequestedByRemoteHeadset());

			}

		}

		//else

		//config is a reconfig in suspend streams 

		//wait on a Start_Indication if the headset is ok with the existing config

		//or an Abort_Indication if the headset is not

	iConfigurationByRemoteHeadsetState = TConfigurationByRemoteHeadsetState::ERemoteHeadsetConfigurationEnd;

	return err;

	}

/**

MGavdpUser callback to indicate to the SymbianOS device that it has started streaming

There are two circumstances we can get a start indication

1) The headset can request to start the streams itself once we are in the open state

2) The headset can request a restart after suspending the streams eg to perform a reconfiguration

@see MGavdpUser

*/

TInt CGAVDPStateMachine::GAVDP_StartIndication(TSEID aSEID)

	{

	__ASSERT_DEBUG((iCurrentState.State() == TGAVDPState::EGAVDPOpen) ||

	(iCurrentState.State() == TGAVDPState::EGAVDPSuspended), Panic(EGavdpStateMachineUnexpectedCallback));

	__ASSERT_DEBUG((iConfigurationByRemoteHeadsetState.State() != TConfigurationByRemoteHeadsetState::ERemoteHeadsetConfigurationStart),Panic(EGavdpStateMachineBadConfigByRemoteHeadsetState));

	//first check the callback is for the symbian device SEP we are using to 

	//send data to the a2dp headset - incase the Symbian device has more than one SEP

	if (aSEID == iSymbianDeviceSEID)

		{

		if (iCurrentState.State() ==  TGAVDPState::EGAVDPOpen)

			{

			if (iStateChangeInProgress)

				{

				if (iTargetState.State() == TGAVDPState::EGAVDPStreaming)

					{

					//a EGAVDPOpen->Streaming transistion

					//which has been completed for us by the headset

					Cancel();

					iGavdp.Cancel();

					iCurrentState = TGAVDPState::EGAVDPStreaming;

					StateChangeComplete();

					}

				//else only other state change would be open->idle

				//this is unlikely/impossible if we get a GAVDP_StartIndication

				//do nothing

				}

			else

				{

				//note if no state change is in progress then the headset itself

				//has put itself in the streaming state 

				//normally we put the headset in the streaming state

				//when we call OpenDevice() on the a2dpaudioif

				//but if the headset does this then it is no longer possible

				//for the client to change the audio settings 

				iCurrentState = TGAVDPState::EGAVDPStreaming;

				}

			}//(iCurrentState.State() ==  TGAVDPState::EGAVDPOpen)

		else if (iCurrentState.State() ==  TGAVDPState::EGAVDPSuspended)

			{//most probably restarting after a reconfigure

			iCurrentState = TGAVDPState::EGAVDPStreaming;

			iGAVDPStateChangeObserver.GAVDPStateMachineStreamResumedByRemoteHeadset();

			}

		}//if (aSEID == iSymbianDeviceSEID)

	return KErrNone;	

	}

/**

MGavdpUser callback to indicate to the SymbianOS device that the request to abort the headset

which means it is not configured has completed

Can request an abort stream if headset configuration fails

@see MGavdpUser

*/

void CGAVDPStateMachine::GAVDP_AbortStreamConfirm()

	{

	//if abort stream was caused by aborting the headset in response

	//to a headset configuration in GAVDP_ConfigurationIndication

	//then restart state machine from EConnectedToGavdp

	if (iConfigurationByRemoteHeadsetState.State() == TConfigurationByRemoteHeadsetState::ERemoteHeadsetConfigurationFailed)

		{//then the abort was caused an aborted configuration from the headset

		__ASSERT_DEBUG((iCurrentState.State() < TGAVDPState::EConfigured), Panic(EGavdpStateMachineUnexpectedCallback));

		//since we only aborted if the headset was not yet configured

		//there must be a state change in progress and since we cancelled

		//the GAVDPStateMachine should not be active

		__ASSERT_DEBUG((iStateChangeInProgress) && (!IsActive()), Panic(EGavdpStateMachineBadConfigByRemoteHeadsetState));

		iConfigurationByRemoteHeadsetState.Reset();	

		//just to make extra sure we'll rediscover the SEPs

		iPotentialSEPs.Reset();

		iUsableSEPs.Reset();

		iSEPCapabilities.ResetAndDestroy();

		iCurrentState = TGAVDPState::EConnectedToGavdp;

		iNextState = TGAVDPState::EConnectedToGavdp;

		iConfigurationByRemoteHeadsetState.Reset();

		iA2dpCodecSettings.Reset();

		iHeadsetSEID.Reset();

		iBearerSocket.Close();

		iLocalSEPConfigured = EFalse;

		iChangeOfSelectedHeadsetSEP = EFalse;

		iSignallingTransactionTimeout->Cancel();	

		NextState();

		}

	iConfigurationByRemoteHeadsetState.Reset();	

	}

/**

MGavdpUser callback to indicate to the SymbianOS device that the headset has aborted

ie it can no longer be regarded as configured

This makes a GAVDPStateMachineEvent MGAVDPStateChangeObserver callback on the CA2dpBTHeadsetAudioInterface

(which inturn will cause a Reset on the GAVDP state machine)

@see MGavdpUser