diff -r 000000000000 -r 29b1cd4cb562 bluetooth/btstack/avdtp/avdtpSignallingMessages.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bluetooth/btstack/avdtp/avdtpSignallingMessages.h Fri Jan 15 08:13:17 2010 +0200 @@ -0,0 +1,679 @@ +// 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 message +// The signalling message encapsulates the parsing and generation of signalling messages as outlined +// in the AVDTP specification. +// The signalling channel is called once the incoming signalling messages have parsed themselves +// If a parse error occurs then: +// - for commands, the parser leaves. The leave is trapped and an appropriate Rejection is sent by the +// signalling channel +// - for responses the error is sent to the signalling channel for delivery to the correct signalling session +// so that client requests may be completed + +/** +@file +@internalComponent +*/ + + +#ifndef AVDTPSIGNALLINGMESSAGES_H +#define AVDTPSIGNALLINGMESSAGES_H + +#include +#include "avdtpMessage.h" +#include "gavdpinterface.h" +#include "avdtpAllocators.h" +#include "avdtputil.h" + +class CSignallingChannel; +class CRemoteSEPCache; +class CCapabilityVisitor; +class RAvdtpTransactionLabel; +class RMBufChain; + +enum TPostSendAction + { + EKeepSetRTX, //< commands with timeouts + EKeepDontSetRTX, //< commands without timeouts + EDiscard //< responses + }; + +enum TAvdtpPacketType + { + ESingle =0x00, + EStart =0x01, + EContinue =0x02, + EEnd =0x03, + }; + +enum TAvdtpMessageType + { + ECommand =0x00, + EGeneralReject =0x01, + EResponseAccept =0x02, + EResponseReject =0x03, + }; + +const TUint KAvdtpMinimumSignallingSinglePacketLength = 2; +const TUint KAvdtpMinimumSignallingStartPacketLength = 3; +const TUint KAvdtpMinimumSignallingContinuePacketLength = 1; +const TUint KAvdtpMinimumSignallingEndPacketLength = 1; + +// min/max lengths for signalling packets - not including the signalling header +const TUint KAvdtpSignallingUnboundedMaximumLength = KMaxTUint; +// Discover +const TUint KAvdtpDiscoverCommandMinimumLength = 0; +const TUint KAvdtpDiscoverCommandMaximumLength = 0; +const TUint KAvdtpDiscoverAcceptMinimumLength = 2; +const TUint KAvdtpDiscoverAcceptMaximumLength = 64; // 32 SEPs +const TUint KAvdtpDiscoverRejectMinimumLength = 1; +const TUint KAvdtpDiscoverRejectMaximumLength = 1; +// Getcaps +const TUint KAvdtpGetCapsCommandMinimumLength = 1; +const TUint KAvdtpGetCapsCommandMaximumLength = 1; +const TUint KAvdtpGetCapsAcceptMinimumLength = KAvdtpServiceCapabilitiesHeaderLen; +const TUint KAvdtpGetCapsAcceptMaximumLength = KAvdtpSignallingUnboundedMaximumLength; +const TUint KAvdtpGetCapsRejectMinimumLength = 1; +const TUint KAvdtpGetCapsRejectMaximumLength = 1; +// SetConfig +const TUint KAvdtpSetConfigCommandMinimumLength = 2+KAvdtpServiceCapabilitiesHeaderLen; +const TUint KAvdtpSetConfigCommandMaximumLength = KAvdtpSignallingUnboundedMaximumLength; +const TUint KAvdtpSetConfigAcceptMinimumLength = 0; +const TUint KAvdtpSetConfigAcceptMaximumLength = 0; +const TUint KAvdtpSetConfigRejectMinimumLength = 2; +const TUint KAvdtpSetConfigRejectMaximumLength = 2; +// GetConfig +const TUint KAvdtpGetConfigCommandMinimumLength = 1; +const TUint KAvdtpGetConfigCommandMaximumLength = 1; +const TUint KAvdtpGetConfigAcceptMinimumLength = KAvdtpServiceCapabilitiesHeaderLen; +const TUint KAvdtpGetConfigAcceptMaximumLength = KAvdtpSignallingUnboundedMaximumLength; +const TUint KAvdtpGetConfigRejectMinimumLength = 1; +const TUint KAvdtpGetConfigRejectMaximumLength = 1; +// ReConfig +const TUint KAvdtpReConfigCommandMinimumLength = 1+KAvdtpServiceCapabilitiesHeaderLen; +const TUint KAvdtpReConfigCommandMaximumLength = KAvdtpSignallingUnboundedMaximumLength; +const TUint KAvdtpReConfigAcceptMinimumLength = 0; +const TUint KAvdtpReConfigAcceptMaximumLength = 0; +const TUint KAvdtpReConfigRejectMinimumLength = 2; +const TUint KAvdtpReConfigRejectMaximumLength = 2; +// Open +const TUint KAvdtpOpenCommandMinimumLength = 1; +const TUint KAvdtpOpenCommandMaximumLength = 1; +const TUint KAvdtpOpenAcceptMinimumLength = 0; +const TUint KAvdtpOpenAcceptMaximumLength = 0; +const TUint KAvdtpOpenRejectMinimumLength = 1; +const TUint KAvdtpOpenRejectMaximumLength = 1; +// Close +const TUint KAvdtpCloseCommandMinimumLength = 1; +const TUint KAvdtpCloseCommandMaximumLength = 1; +const TUint KAvdtpCloseAcceptMinimumLength = 0; +const TUint KAvdtpCloseAcceptMaximumLength = 0; +const TUint KAvdtpCloseRejectMinimumLength = 1; +const TUint KAvdtpCloseRejectMaximumLength = 1; +// Start +const TUint KAvdtpStartCommandMinimumLength = 1; +const TUint KAvdtpStartCommandMaximumLength = 32; // all SEIDs +const TUint KAvdtpStartAcceptMinimumLength = 0; +const TUint KAvdtpStartAcceptMaximumLength = 0; +const TUint KAvdtpStartRejectMinimumLength = 2; +const TUint KAvdtpStartRejectMaximumLength = 2; +// Suspend +const TUint KAvdtpSuspendCommandMinimumLength = 1; +const TUint KAvdtpSuspendCommandMaximumLength = 32; // all SEIDs +const TUint KAvdtpSuspendAcceptMinimumLength = 0; +const TUint KAvdtpSuspendAcceptMaximumLength = 0; +const TUint KAvdtpSuspendRejectMinimumLength = 2; +const TUint KAvdtpSuspendRejectMaximumLength = 2; +// Abort +const TUint KAvdtpAbortCommandMinimumLength = 1; +const TUint KAvdtpAbortCommandMaximumLength = 1; +const TUint KAvdtpAbortAcceptMinimumLength = 0; +const TUint KAvdtpAbortAcceptMaximumLength = 0; +// no Abort reject +// SecurityControl +const TUint KAvdtpSecurityControlCommandMinimumLength = 1; +const TUint KAvdtpSecurityControlCommandMaximumLength = KAvdtpSignallingUnboundedMaximumLength; +const TUint KAvdtpSecurityControlAcceptMinimumLength = 1; +const TUint KAvdtpSecurityControlAcceptMaximumLength = KAvdtpSignallingUnboundedMaximumLength; +const TUint KAvdtpSecurityControlRejectMinimumLength = 1; +const TUint KAvdtpSecurityControlRejectMaximumLength = 1; +// General reject +const TUint KAvdtpGeneralRejectLength = 0; + + +// and ones for minimum and maximum LOSC for service categories in Set/Reconfig and GetCaps +const TUint KAvdtpLOSCUnboundedMaximumLength = KMaxTUint; + +const TUint KAvdtpCapabilityMediaTransportMinimumLOSC = 0; +const TUint KAvdtpCapabilityMediaTransportMaximumLOSC = 0; +const TUint KAvdtpCapabilityReportingMinimumLOSC = 0; +const TUint KAvdtpCapabilityReportingMaximumLOSC = 0; +const TUint KAvdtpCapabilityRecoveryMinimumLOSC = 3; +const TUint KAvdtpCapabilityRecoveryMaximumLOSC = 3; +const TUint KAvdtpCapabilityMediaCodecMinimumLOSC = 2; +const TUint KAvdtpCapabilityMediaCodecMaximumLOSC = KAvdtpLOSCUnboundedMaximumLength; +const TUint KAvdtpCapabilityContentProtectionMinimumLOSC = 2; +const TUint KAvdtpCapabilityContentProtectionMaximumLOSC = KAvdtpLOSCUnboundedMaximumLength; +const TUint KAvdtpCapabilityHeaderCompressionMinimumLOSC = 1; +const TUint KAvdtpCapabilityHeaderCompressionMaximumLOSC = 1; +const TUint KAvdtpCapabilityMultiplexingMinimumLOSC = 3; +const TUint KAvdtpCapabilityMultiplexingMaximumLOSC = 7; + +const TUint KAvdtpPacketTypeOffset = 0x02; +const TUint KAvdtpPacketTypeMask = 0x03 << KAvdtpPacketTypeOffset; + +const TUint KAvdtpTransactionLabelOffset = 0x04; +const TUint KAvdtpTransactionLabelMask = 0x0f << KAvdtpTransactionLabelOffset; + +const TUint KAvdtpMessageTypeOffset = 0x00; +const TUint KAvdtpMessageTypeMask = 0x3 << KAvdtpMessageTypeOffset; + +const TUint KAvdtpSignalIdentifierMask = 0x3f; + +const TUint KAvdtpMediaTypeOffset = 4; // see 8.6.2 +const TUint KAvdtpTSEPOffset = 3; +const TUint KAvdtpPacketSEPInfoSize = 2; // see 8.6.2 +const TUint KAvdtpInUseFlagOffset = 1; + +NONSHARABLE_CLASS(TAvdtpFragmentationInfo) + { +public: + TAvdtpFragmentationInfo() : iFragmented(EFalse) {} + TBool iFragmented; + TInt iTotalPackets; + TInt iPacketNumber; + }; + +NONSHARABLE_CLASS(CAvdtpSignallingMessage) : public CAvdtpMessage + { +public: + void SetType(TAvdtpMessageType aType,TAvdtpMessage aMessage); + inline TAvdtpMessage Signal() const; +protected: + CAvdtpSignallingMessage(); +protected: + TAvdtpMessageType iMessageType; + TAvdtpMessage iSignal; + }; + +inline TAvdtpMessage CAvdtpSignallingMessage::Signal() const + { + return iSignal; + } + +NONSHARABLE_CLASS(CAvdtpInboundSignallingMessage) : public CAvdtpSignallingMessage +/** +represents outgoing signalling messages, and has parsing methods for inbound packets +*/ + { +public: + explicit CAvdtpInboundSignallingMessage(CSignallingChannel& aSignallingChannel); + virtual TInt NewData(TUint aCount); +private: + static TAvdtpMessage SignalIdentifier(const RMBufChain& aMessage); + static RMBufChain MessageL(RMBufChain& aPacket, const TAvdtpPacketType aPacketType); + static TUint8 NumberSignalPackets(const RMBufChain& aChain); + +private: + TInt CheckPacketType(RMBufChain& aFragment,TAvdtpPacketType& aPacketType, TAvdtpMessageType& aMessageType, TAvdtpTransactionLabel& aTransactionLabel); + void Process(TAvdtpTransactionLabel aLabel); + + static void HandleDiscoverL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + static void HandleGetCapsL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + static void HandleSetConfigL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + static void HandleGetConfigL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + static void HandleReconfigL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + static void HandleOpenL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + static void HandleStartL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + static void HandleReleaseL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + static void HandleSuspendL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + static void HandleAbortL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + static void HandleSecurityControlL(CAvdtpInboundSignallingMessage& aThat, TAvdtpTransactionLabel aLabel); + + void DoHandleDiscoverL(TAvdtpTransactionLabel aLabel); + void DoHandleGetCapsL(TAvdtpTransactionLabel aLabel); + void DoHandleSetConfigL(TAvdtpTransactionLabel aLabel); + void DoHandleGetConfigL(TAvdtpTransactionLabel aLabel); + void DoHandleReconfigL(TAvdtpTransactionLabel aLabel); + void DoHandleOpenL(TAvdtpTransactionLabel aLabel); + void DoHandleStartL(TAvdtpTransactionLabel aLabel); + void DoHandleReleaseL(TAvdtpTransactionLabel aLabel); + void DoHandleSuspendL(TAvdtpTransactionLabel aLabel); + void DoHandleAbortL(TAvdtpTransactionLabel aLabel); + void DoHandleSecurityControlL(TAvdtpTransactionLabel aLabel); + + TSEID LocalSEIDL(); + TSEID RemoteSEIDL(); + TSEID SEIDL(TBool aIsSemanticallyLocal); // common helper + + TInt CheckPacketLength(TUint aMin, TUint aMax); + void CheckPacketLengthL(TUint aMin, TUint aMax); + +private: + enum TPacketBuildState + { + EAwaitingNew, // single or start + EAwaitingContinue, + EAwaitingEnd, + }; + TPacketBuildState iPacketBuildState; + TAvdtpFragmentationInfo iFragmentationInfo; + CSignallingChannel& iSignallingChannel; + TAvdtpTransactionLabel iPacketBuildLabel; + }; + +NONSHARABLE_CLASS(CAvdtpOutboundSignallingMessage) : public CAvdtpSignallingMessage + { +friend class CSignallingChannel; //que'd in the SignallingChannel +public: + TInt AllocateTransactionLabel(TTransactionLabelManager& aManager); + void SetTransactionLabel(TAvdtpTransactionLabel aLabel); + void AddSEPInfoL(const TAvdtpSEPInfo& aSEPInfo); + void AddSEPCapabilityL(const TAvdtpServiceCapability& aCapability); + TBool GetNextOutboundFragmentL(RMBufChain& aDest, TInt aMaxSize); + TPostSendAction PostSendAction() const; + inline TAvdtpTransactionLabel TransactionLabel() const; + virtual ~CAvdtpOutboundSignallingMessage(); +private: + void Deque(); + static void PrependSignallingHeaderL(RMBufChain& aDest, + const TAvdtpPacketType& aPacketType, + const TAvdtpTransactionLabel& aTransLabel, + const TAvdtpMessageType& aMessageType, + TAvdtpMessage aSigId=EAvdtpNull, + TInt aNoSigPkts=0 + ); + virtual TInt NewData(TUint aCount); // pure - panic if called in this class +private: + TDblQueLink iLink; //so we can be put in ques + TAvdtpFragmentationInfo iFragInfo; + // next 2 are logically a union, but the R-class has a ctor, so cannot be a C++ union + RAvdtpTransactionLabel iCommandLabel; + TAvdtpTransactionLabel iResponseLabel; + }; + + +inline TAvdtpTransactionLabel CAvdtpOutboundSignallingMessage::TransactionLabel() const + { + //OutBound Signalling message should never be EReserved + __ASSERT_DEBUG(Signal() != EReserved,Panic(EAvdtpInvalidReservedValueInOutboundSignallingMessage)); + return (iMessageType==ECommand) ? iCommandLabel.TransactionLabel() : iResponseLabel; + } + +using namespace SymbianBluetoothAV; + +/*static*/ namespace AvdtpSignallingMessage + { + static TInt AppendSEID(CAvdtpOutboundSignallingMessage& aSignallingMessage,TSEID aACPSEID); + + NONSHARABLE_CLASS(Command) + { + }; + NONSHARABLE_CLASS(Response) + { + protected: + static TInt AppendResult(CAvdtpOutboundSignallingMessage& aSignallingMessage, TBluetoothAvDistributionError aResult); + }; + NONSHARABLE_CLASS(Reject) + { + public: + static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TBluetoothAvDistributionError aRejectionCode, const TDesC8* aRejectionData=NULL); + private: + static void FormatL(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TBluetoothAvDistributionError aRejectionCode, const TDesC8* aRejectionData=NULL); + }; + } + + +namespace AvdtpSignallingMessageDiscover + { + NONSHARABLE_CLASS(Response) + { + public: + static TInt ParseL(const RMBufChain& aMessageData, + TDes8& aClientBuffer, + CRemoteSEPCache& aSEPCache, + const TBTDevAddr& aAddr); + }; + } + +namespace AvdtpSignallingMessageOpen + { + NONSHARABLE_CLASS(Command) : public AvdtpSignallingMessage::Command + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID); + }; + NONSHARABLE_CLASS(Response) : public AvdtpSignallingMessage::Response + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TBluetoothAvDistributionError aResult); + }; + } + + +namespace AvdtpSignallingMessageStreamRelease + { + NONSHARABLE_CLASS(Command) : public AvdtpSignallingMessage::Command + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID); + }; + NONSHARABLE_CLASS(Response) : public AvdtpSignallingMessage::Response + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TBluetoothAvDistributionError aResult); + }; + } + +namespace AvdtpSignallingMessageSecurityControl + { + NONSHARABLE_CLASS(Command) : public AvdtpSignallingMessage::Command + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID, const TDesC8& aSecurityData); + }; + NONSHARABLE_CLASS(Accept) : public AvdtpSignallingMessage::Response + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, const TDesC8* aSecurityData = NULL); + }; + } + + +namespace AvdtpSignallingMessageAbort + { + NONSHARABLE_CLASS(Command) : public AvdtpSignallingMessage::Command + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID); + }; + } + +namespace AvdtpSignallingMessageGetCapabilities + { + NONSHARABLE_CLASS(Command) : public AvdtpSignallingMessage::Command + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID); + }; + } + +/** +Common stuff for Set and Re configure responses +*/ +namespace AvdtpSignallingMessageConfigure + { + NONSHARABLE_CLASS(Response) : public AvdtpSignallingMessage::Response + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aMessage, TAvdtpServiceCategory aCategory); + }; + } + +namespace AvdtpSignallingMessageSetConfiguration + { + NONSHARABLE_CLASS(Command) : public AvdtpSignallingMessage::Command + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID, TSEID aINTSEID, const RBuf8& aConfiguration); + private: + static void FormatL(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID, TSEID aINTSEID, const RBuf8& aConfiguration); + }; + NONSHARABLE_CLASS(Response) : public AvdtpSignallingMessageConfigure::Response + { + }; + } + +namespace AvdtpSignallingMessageReconfigure + { + NONSHARABLE_CLASS(Command) : public AvdtpSignallingMessage::Command + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID, const RBuf8& aConfiguration); + private: + static void FormatL(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID, const RBuf8& aConfiguration); + }; + NONSHARABLE_CLASS(Response) : public AvdtpSignallingMessageConfigure::Response + { + }; + } + +namespace AvdtpSignallingMessageStart + { + NONSHARABLE_CLASS(Command) : public AvdtpSignallingMessage::Command + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID); + }; + NONSHARABLE_CLASS(Response) : public AvdtpSignallingMessage::Response + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TBluetoothAvDistributionError aResult); + }; + } + +namespace AvdtpSignallingMessageSuspend + { + NONSHARABLE_CLASS(Command) : public AvdtpSignallingMessage::Command + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID); + }; + NONSHARABLE_CLASS(Response) : public AvdtpSignallingMessage::Response + { + public: + inline static TInt Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TBluetoothAvDistributionError aResult); + }; + } + + + +/*static*/ +inline TInt AvdtpSignallingMessage::Reject::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TBluetoothAvDistributionError aRejectionCode, const TDesC8* aRejectionData/*=NULL*/) + { + TRAPD(err, FormatL(aSignallingMessage, aRejectionCode, aRejectionData)); + return err; + } + + +/*static*/ +inline TInt AvdtpSignallingMessageStart::Command::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID) + { + return AvdtpSignallingMessage::AppendSEID(aSignallingMessage, aACPSEID); + } + +inline TInt AvdtpSignallingMessageStart::Response::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TBluetoothAvDistributionError aResult) + { + return Response::AppendResult(aSignallingMessage, aResult); + } + +/*static*/ +inline TInt AvdtpSignallingMessageSuspend::Command::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, TSEID aACPSEID) + { + return AvdtpSignallingMessage::AppendSEID(aSignallingMessage, aACPSEID); + } + +inline TInt AvdtpSignallingMessageSuspend::Response::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TBluetoothAvDistributionError aResult) + { + return Response::AppendResult(aSignallingMessage, aResult); + } + +/*static*/ +inline TInt AvdtpSignallingMessageStreamRelease::Command::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TSEID aACPSEID) + { + return AvdtpSignallingMessage::AppendSEID(aSignallingMessage, aACPSEID); + } + +/*static*/ +inline TInt AvdtpSignallingMessageSecurityControl::Command::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TSEID aACPSEID, const TDesC8& aSecurityData) + { + TInt res = AvdtpSignallingMessage::AppendSEID(aSignallingMessage, aACPSEID); + if (res==KErrNone) + { + TRAP(res, aSignallingMessage.AppendDataL(aSecurityData)); + } + return res; + } + +/*static*/ +inline TInt AvdtpSignallingMessageSecurityControl::Accept::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + const TDesC8* aSecurityData) + { + TInt res=KErrNone; + + if (aSecurityData) + { + TRAP(res, aSignallingMessage.AppendDataL(*aSecurityData)); + } + return res; + } + +/*static*/ +inline TInt AvdtpSignallingMessageAbort::Command::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TSEID aACPSEID) + { + return AvdtpSignallingMessage::AppendSEID(aSignallingMessage, aACPSEID); + } + +/*static*/ +inline TInt AvdtpSignallingMessageGetCapabilities::Command::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TSEID aACPSEID) + { + return AvdtpSignallingMessage::AppendSEID(aSignallingMessage, aACPSEID); + } + +/*static*/ +inline TInt AvdtpSignallingMessageSetConfiguration::Command::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TSEID aACPSEID, + TSEID aINTSEID, + const RBuf8& aConfiguration) + { + TRAPD(err, FormatL(aSignallingMessage, aACPSEID, aINTSEID, aConfiguration)); + return err; + } + +/*static*/ +inline TInt AvdtpSignallingMessageReconfigure::Command::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TSEID aACPSEID, + const RBuf8& aConfiguration) + { + TRAPD(err, FormatL(aSignallingMessage, aACPSEID, aConfiguration)); + return err; + } + +/*static*/ +inline TInt AvdtpSignallingMessageConfigure::Response::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TAvdtpServiceCategory aCategory) + { + TRAPD(err, aSignallingMessage.AppendDataL(aCategory)); + return err; + } + +/*static*/ +inline TInt AvdtpSignallingMessageOpen::Response::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TBluetoothAvDistributionError aResult) + { + return Response::AppendResult(aSignallingMessage, aResult); + } + +/*static*/ +inline TInt AvdtpSignallingMessageOpen::Command::Format(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TSEID aACPSEID) + { + return AvdtpSignallingMessage::AppendSEID(aSignallingMessage, aACPSEID); + } + + +/*static*/ +inline TInt AvdtpSignallingMessage::AppendSEID(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TSEID aACPSEID) + { + TRAPD(err, aSignallingMessage.AppendDataL(aACPSEID.PacketValue())); + return err; + } + +/*static*/ +inline TInt AvdtpSignallingMessage::Response::AppendResult(CAvdtpOutboundSignallingMessage& aSignallingMessage, + TBluetoothAvDistributionError aResult) + { + TRAPD(err, aSignallingMessage.AppendDataL(aResult)); + return err; + } + +// internalComponent stack capability visitors + + +/* +@internalComponent +*/ +NONSHARABLE_CLASS(CCapabilityExtractorVisitor) : public CCapabilityVisitor + { +public: + CCapabilityExtractorVisitor(TAvdtpServiceCategory aRequiredCapability); + TPtrC8 GetCapability() const; + TBool Capability(TAvdtpServiceCategory aCat); +private: + TAvdtpServiceCategory iRequiredCapability; + TPtrC8 iPtr; + }; + + + + +/* +@internalComponent +goes through to see if spec unknown capabilities present +*/ +NONSHARABLE_CLASS(CCapabilityValidateVisitor) : public CCapabilityVisitor + { +public: + virtual TBool Capability(TAvdtpServiceCategory aCat); + inline TInt Result() const; + inline TAvdtpServiceCategory InvalidCategory() const; +private: + inline TBool IsLOSCValid(TUint aLOSC, TUint aMin, TUint aMax); + TInt iResult; // the error to use if invalid, or KErrNone + TAvdtpServiceCategory iInvalidCategory; + }; + +/* +@internalComponent +goes through to remove spec unknown capabilities +*/ +NONSHARABLE_CLASS(CCapabilityRemoveUnknownVisitor) : public CCapabilityVisitor + { +public: + virtual TBool Capability(TAvdtpServiceCategory aCat); + }; + +#ifdef _DEBUG +/* +@internalComponent +*/ +NONSHARABLE_CLASS(CCapabilityFlogVisitor) : public CCapabilityVisitor + { +public: + virtual TBool Capability(TAvdtpServiceCategory aCat); + }; +#endif + + +#endif //AVDTPSIGNALLINGMESSAGES_H