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

//

#ifndef __GAVDPSTATEMACHINE_H__

#define __GAVDPSTATEMACHINE_H__

#include <e32base.h>

#include <bttypes.h> //TBTDevAddr

#include <es_sock.h> //RSocketServer, RSocket

#include <gavdp.h> //MGavdpUser, RGavdp

#include <bluetoothav.h> //TAvdtpSEPInfo, TSEID

#include <mmf/common/mmfutilities.h> //TFourCC

#include <mmf/server/sounddevice.h> //TMMFStereoSupport

#include "GavdpStates.h"

const TUint KGAVDPCallbackTimeout = 30000000;

class CGavdpTimeout; //fwd ref

class CA2dpAudioCodecConfiguration;

using namespace SymbianSBC;

using namespace SymbianBluetoothAV;	

/**

structure used internally in the GAVDP state machine to keep

track of seps than can be used on the headset to send audio and 

the local symbian device SEPs

*/

struct TUsableSEP

	{

	TSEID iSEID;

	TFourCC iDataType;

	};

/**

Callback class implemented by CA2dpBTHeadsetAudioInterface to get events

back from CGAVDPStateMachine

*/	

class MGAVDPStateChangeObserver

	{

public:

/**

Callback when the CGAVDPStateMachine has completed a state change

initiated by a call to ChangeState

@internalComponent

@param aInitialState The state the CGAVDPStateMachine prior to calling ChangeState

@param standard SymbianOS error

*/

	void virtual GAVDPStateChangeComplete(const TGAVDPState& aInitialState, TInt aError) = 0;

/**

Callback when the GAVDPStateMachine detects an error condition

event while no state change is in progress

@internalComponent

@param aError standard SymbianOS error

*/

	void virtual GAVDPStateMachineEvent(TInt aError) = 0;

/**

Callback when the headset suspends the streaming

@internalComponent

*/

	void virtual GAVDPStateMachineStreamSuspendedByRemoteHeadset() = 0;

/**

Callback when the headset requested a reconfiguration of the settings

@internalComponent

@return an error code indicating whether it was possible to perform the reconfiguration

*/

	TInt virtual GAVDPStateMachineReconfigureByRemoteHeadset() = 0;

/**

Callback when the headset starts (or restarts) the streaming

@internalComponent

*/

	void virtual GAVDPStateMachineStreamResumedByRemoteHeadset() = 0;

	};

/**

GAVDP state machine used by the CA2dpBTHeadsetAudioInterface.

This class is used by the CA2dpBTHeadsetAudioInterface to

initialize and open the headset, which involved finding SEPs,

configuring , getting a bearer and streaming.  The CGAVDPStateMachine

uses the MGAVDPStateChangeObserver callback to inform the CA2dpBTHeadsetAudioInterface

of when the state change is complete, error conditions, and state changes

initiated by the headset itself

@internalComponent

*/

NONSHARABLE_CLASS(CGAVDPStateMachine) : public CActive, public MGavdpUser  

	{

	friend class CGavdpTimeout;

public:

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

	~CGAVDPStateMachine();

	void SetBTAddress(const TBTDevAddr& aRemoteAddress);

	TInt Reconfigure(TBool aSettingsHaveChanged);

	TInt ChangeState(const TGAVDPState& aNewState);

	void CancelChangeState(); //external request to cancel state change

	TGAVDPState State() const;

	RArray<TUsableSEP>& UsableSEPs() const;

	RSocket& BearerSocket() const;

	TBTDevAddr& BTAddress() const;

	TInt CodecCaps(TAvdtpMediaCodecCapabilities*& aCodecCaps) const;

	//used by a2dp instead of CodecCaps

	TAvdtpMediaCodecCapabilities* RemoteCodecConfiguration();

private:

	CGAVDPStateMachine(MGAVDPStateChangeObserver& aGAVDPStateChangeObserver, CA2dpAudioCodecConfiguration& aA2dpCodecSettings, RSocketServ& aSocketServer); 

	void ConstructL();

	TInt RegisterLocalSEP();

	void ConnectToGAVDP();

	void DiscoverRemoteSEPs();

	void GetRemoteSEPCapability();

	void GetRemoteSEPCapabilities();

	void ConfigureSEP();

	TInt ConfigureLocalSEP();

	TInt ConfigureRemoteSEP();

	void CreateBearerSocket();

	void StartStream();

	void SuspendStream();

	void NextState();

	void StateChangeComplete();

	void CancelChangeState(TInt aReason); //internal request to cancel state change eg due to an error condition

	void Reset(); //utility to reset state to idle and all variables

	//MGavdpUser

	virtual void GAVDP_ConnectConfirm(const TBTDevAddr& aDevice);

	virtual void GAVDP_SEPDiscovered(const TAvdtpSEPInfo& aSEP);

	virtual void GAVDP_SEPDiscoveryComplete();	

	virtual void GAVDP_SEPCapability(TAvdtpServiceCapability* aCapability);

	virtual void GAVDP_SEPCapabilityComplete();		

	virtual void GAVDP_AbortStreamConfirm();

	virtual void GAVDP_StartStreamsConfirm();	

	virtual void GAVDP_SuspendStreamsConfirm();

	virtual void GAVDP_SecurityControlConfirm(const TDesC8& /*aResponseData*/) {};	

	virtual void GAVDP_ConfigurationConfirm();

	virtual void GAVDP_ConfigurationStartIndication(TSEID aLocalSEID, TSEID aRemoteSEID);

	virtual TInt	GAVDP_ConfigurationIndication(TAvdtpServiceCapability* aCapability);

	virtual TInt	GAVDP_ConfigurationEndIndication();

	virtual TInt	GAVDP_StartIndication(TSEID aSEID);

	virtual TInt	GAVDP_SuspendIndication(TSEID aSEID);

	virtual TInt	GAVDP_SecurityControlIndication(TSEID /*aSEID*/, TDes8& /*aSecurityData*/) {return KErrNotSupported;};

	virtual void GAVDP_AbortIndication(TSEID aSEID);

	virtual void GAVDP_ReleaseIndication(TSEID aSEID);

	virtual void GAVDP_BearerReady(RSocket aSocket, const TAvdtpSockAddr& aAddress);

	virtual void GAVDP_Error(TInt aError, const TDesC8& aErrorData);

	//CActive

	void RunL();

	void DoCancel();

private:

	MGAVDPStateChangeObserver& iGAVDPStateChangeObserver;

	TGAVDPState iInitialState;

	TGAVDPState iCurrentState;

	TGAVDPState iNextState;

	TGAVDPState	iTargetState;

	TConfigurationByRemoteHeadsetState iConfigurationByRemoteHeadsetState;

	CA2dpAudioCodecConfiguration& iA2dpCodecSettings;

	TBool iLocalSEPConfigured;

	TBool iChangeOfSelectedHeadsetSEP;

	TBTDevAddr iBTDevAddr;

	TBool iStateChangeInProgress;

	RSocketServ& iSocketServer;

	RSocket iBearerSocket;

	RGavdp		iGavdp;

	TSEID		iSymbianDeviceSEID;

	TSEID		iHeadsetSEID;

	RArray<TSEID> iPotentialSEPs;

	RArray<TUsableSEP> iSymbianDeviceSEPs;

	RArray<TUsableSEP> iUsableSEPs; //SEPs that can actually be used to stream audio

	RPointerArray<TAvdtpServiceCapability> iSEPCapabilities;

	TUint iSEPIterator; //used to iterate through potential SEPs when getting caps

	TUint iSEPCapabilityEntry;

	//heap members owned by CGAVDPStateMachine

	CGavdpTimeout* iSignallingTransactionTimeout;

	};

/**

The SEP discovery and GetCapabilities do not have built in timeouts,

so a timeout is required

@internalComponent

*/

NONSHARABLE_CLASS(CGavdpTimeout) : public CTimer

	{

public:

	static CGavdpTimeout* NewL(CGAVDPStateMachine& aGAVDPStateMachine);

	void StartTimer(TTimeIntervalMicroSeconds32 aTimeInterval);

private:

	CGavdpTimeout();

	void ConstructL(CGAVDPStateMachine& aGAVDPStateMachine);

	virtual void RunL();

private:

	CGAVDPStateMachine* iGAVDPStateMachine;

	};

#endif