diff -r 000000000000 -r 29b1cd4cb562 bluetooth/btstack/avdtp/avdtpSignallingSession.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bluetooth/btstack/avdtp/avdtpSignallingSession.h Fri Jan 15 08:13:17 2010 +0200 @@ -0,0 +1,170 @@ +// 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 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 +