// Copyright (c) 2003-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:

// Signalling session

// A signalling session represents one RGavdp object.  It is-a transport session.

// Each signalling session is bound to a signalling channel - a signalling channel can support many

// signalling sessions.

// The multiplexing allows for many applications to stream to the same remote device

// A signalling session also "manages" each of the stream endpoints registered by an RGavdp client.

// A RGavdp client may register many (local) seps.

// The signalling session receives indications from the signalling channel - since the signalling channel

// (intentionally) doesn't know which SEPs are managed by which session various protocol events are

// offered to all of the signalling sessions.

// The signalling sessions should then see if they manage a sep for which the protocol event has happened

// and "consume" the event.

// At certain stages in the protocol state machine the local seps may "grow" a stream.  Subsequent protocol

// primitives may then be called via the sep's stream.

// The specification does not define Signalling Sessions.  However they are required to fulfill the need to 

// support streams from multiple applications to the same target device. 

// the session is then "fixed" to that remote.  Therefore all SEPs managed by the session

// become available only for use with that remote.  The user *can* (if this is important)

// still use multiple SEPs by placing one SEP in one RGavdp (implies one signalling session)

// a future extension would be to see from which remote address a configure had been received

// Hence there is one SEP pointer recording the SEP undergoing configuration

// 

//

/**

 @note This design has a restriction at this point in time. Once connected to a remote

 @note At present this design allows for at most one SEP to undergo configuration at a time from all remote devices

*/

#ifndef AVDTPSIGNALLINGSESSION_H

#define AVDTPSIGNALLINGSESSION_H

#include "avdtpTransportSession.h"

#include "avdtpStream.h"

const TInt KAvdtpACPReleaseChannelCloseTimeout = 10000000;

class CTransportChannel;

class CAvdtpSAP;

class CAvdtpProtocol;

class CSignallingChannel;

class CSEPConfigurator;

class CLocalSEP;

NONSHARABLE_CLASS(CSignallingSession) : public CTransportSession, public XAvdtpSignalReceiver, public MAvdtpStreamNotify

	{

friend class CLocalSEPConfigurator;

friend class CRemoteSEPConfigurator;

public:

	static CSignallingSession* NewLC(CAvdtpProtocol& aProtocol, CAvdtpSAP& aSAP);

	static CSignallingSession* NewL(CAvdtpProtocol& aProtocol, CAvdtpSAP& aSAP);

	virtual TInt SetOption(TUint aLevel, TUint aName, const TDesC8 &aOption);

	virtual TInt GetOption(TUint aLevel, TUint aName, TDes8& aOption) const; 

	virtual void Ioctl(TUint aLevel, TUint aName, const TDesC8* aOption);

	virtual void CancelIoctl(TUint aLevel, TUint aName);

	virtual TInt Send(RMBufChain& aData, TUint aOptions, TSockAddr* aAddr);

	virtual TInt GetData(RMBufChain& aData);

	virtual void DoShutdown();

	virtual TInt ActiveOpen();

	~CSignallingSession();

private:

//from signal receiver - we're interested in most, but not all service upcalls

	virtual TInt DiscoverIndication(TAvdtpTransactionLabel aLabel, CAvdtpOutboundSignallingMessage& aDiscoverResponsePacket);

	virtual TInt GetCapsIndication(TAvdtpTransactionLabel aLabel,

									TSEID aSEID,

									CAvdtpOutboundSignallingMessage& aGetCapsResponseMessage);

	virtual TInt SetConfigIndication(TAvdtpTransactionLabel aLabel, TSEID aLocalSEID,

											TSEID aINTSEID, RBuf8& aConfigData);

	virtual TInt GetConfigIndication(TAvdtpTransactionLabel aLabel, TSEID aLocalSEID,

									CAvdtpOutboundSignallingMessage& /*aGetConfigResponseMessage*/);

	virtual TInt ReconfigIndication(TAvdtpTransactionLabel aLabel,

													TSEID aLocalSEID,

													RBuf8& aNewConfig);

	virtual TInt OpenIndication(TSEID aLocalSEID);

	virtual TInt StartIndication(TAvdtpTransactionLabel aLabel, TSEID aLocalSEID);

	virtual TInt ReleaseIndication(TAvdtpTransactionLabel aLabel, TSEID aLocalSEID);

	virtual TInt SuspendIndication(TAvdtpTransactionLabel aLabel, TSEID aLocalSEID);

	virtual TInt AbortIndication(TAvdtpTransactionLabel aLabel, TSEID aLocalSEID);

	virtual TInt SecurityControlIndication(TAvdtpTransactionLabel aLabel, TSEID aLocalSEID, const HBufC8* aSecurityData);

	virtual void SignallingChannelError(TInt aError);

// protocol confirms

// no labels needed

	virtual void DiscoverConfirm(TInt aResult, const TAvdtpInternalDiscoverConfirm* const aConfirm);

	virtual void GetCapsConfirm(TInt aResult, TSEID aRemoteSEID, TAvdtpServiceCatBitMask aSeen);

	virtual void AbortConfirm(TSEID aRemoteSEID);

	virtual void SecurityControlConfirm(TInt aResult, TSEID aRemoteSEID, const TDesC8& aResponseData);

// interface from stream

	virtual void StreamStarted(TSEID aLocalSEID);

	virtual void StreamSuspended(TSEID aLocalSEID);

	virtual void StreamAccepted(TSEID aLocalSEID, TSEID aRemoteSEID, TBool aWithReporting, TBool aWithRecovery);

	virtual void StreamConfigured(TSEID aLocalSEID, TInt aError, TAvdtpServiceCategory aFailedCategory);

	virtual void StreamInitiatedServiceFailed(const CAVStream& aStream, TInt aError);

	virtual void StreamReadyForStartIndication(const TAvdtpTransactionLabel aLabel, const TSEID aSEID);

// callbacks from signalling channel

	virtual void ServiceError(TInt aError);

	virtual void SignallingChannelReady(CSignallingChannel& aNewChannel);

private:

	void DoConfigureStreamL(RBuf8& aConfigBuffer,

							CLocalSEP& aLocalSEP,

							TSEID aRemoteSEID,

							TBool aReportingConfigured,

							TBool aRecoveryConfigured);

	TInt SendAbort(TSEID aRemoteSEID);

	void CreateLocalSEPL(TAvdtpSEPInfo& aSEPInfo); // note, not const ref

	CLocalSEP& FindLocalSEPL(TSEID aSEID) const;

	CLocalSEP* FindLocalSEP(TSEID aSEID) const;

	CSignallingSession(CAvdtpProtocol& aProtocol, CAvdtpSAP& aSAP);

	void ConstructL();

	TInt DoAddCapabilitySetOpt(const TDesC8& aOption);

	inline void CompleteBasicService(TInt aErr);

	CAVStream* FindStreamFromRemoteSEID(const TSEID& aRemoteSEID) const;

	void ClearSignallingChannel();

	void DestroyLocalSEPs();

	void DestroyStream(CAVStream* aStream, TInt aError);

private:

	CSignallingChannel*		iSignallingChannel; // non-owned

	CSEPConfigurator*		iSEPConfigurator;

	mutable TDblQue<CLocalSEP>	iLocalSEPs; // those awaiting discover (by "our" app)

	TBool					iIsListening;

	};

/*

@internalComponent

*/

// goes through to see if remote has proposed unsupported local categories

NONSHARABLE_CLASS(CCapabilityNotAllowedVisitor) : public CCapabilityVisitor

	{

public:

	CCapabilityNotAllowedVisitor(TAvdtpServiceCategories aLocallySupported);

	virtual TBool Capability(TAvdtpServiceCategory aCat);

	inline TBool IsValid() const;

	inline TAvdtpServiceCategory WrongCategory() const;

private:

	TAvdtpServiceCategories iLocallySupported;

	TBool	iIsValid;

	TAvdtpServiceCategory iWrongCategory;

	};

#endif //AVDTPSIGNALLINGSESSION_H