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