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