diff -r 000000000000 -r 29b1cd4cb562 bluetooth/btstack/avdtp/gavdpinterface/gavdpinterface.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bluetooth/btstack/avdtp/gavdpinterface/gavdpinterface.h Fri Jan 15 08:13:17 2010 +0200 @@ -0,0 +1,687 @@ +// Copyright (c) 2004-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: +// Contains internalTechnology types, values etc to allow AVDTP and GAVDP to communicate +// +// + +/** + @file + @internalTechnology +*/ + + +#ifndef _GAVDPINTERFACE_H +#define _GAVDPINTERFACE_H + +#include +#include + +using namespace SymbianBluetoothAV; + +class AvdtpInternalUtils + { +public: + static inline TInt NumberOfTransportObjects(TBool aReporting, TBool aRecovery); +/* +@return SymbianOS error code +@param AVDTP error code +*/ + static inline TAvdtpSignallingErrorCode SymbianErrorToAvdtpError(TInt aSymbianError); + static inline void PacketErrorLeaveL(TAvdtpSignallingErrorCode aCode); + }; + + +enum TBTAVDTPOptions +/* +@internalTechnology +*/ + { + EDiscoverSEPs, + EGetCapabilities, + ESelectSEP, + ESetConfiguration, + EStartStreaming, + EStartConfiguringLocal, + EStartConfiguringRemote, + EAddCapabilitySelection, + ESuspendStreaming, + EAbortStream, + EGetProposedConfiguration, + EGetSecurityControl, + EGetAVDTPCapabilityResponse, + ERegisterSEP, + EAwaitPassiveSignallingChannel, + ESetAsSecondarySAP, + EBindToSecondarySAP, + EAwaitIndication, + ESendSetConfigurationResponse, + ESendSecurityControlResponse, + ESendStartResponse, + ESendSuspendResponse, + ESendConfigurationResponse, + ESendSecurityControl, + EStopAwaitPassiveSignallingChannel, + EGetReportingAndRecoveryConfig, + EShutdown, + }; + +/** +@internalTechnology +*/ +const TUint KMaximumRealSEID = KMaxTUint6; + +/** +@internalTechnology +*/ +const TTCID KInvalidTCID = KMaxTUint8; + +/** +@internalTechnology +*/ +const TTCID KDirectChannelTCID = KMaxTUint8-1; // the spec (unclearly) says that Direct channels have *no* TCID, not even one unseen by remote + +/** +@internalTechnology +*/ +const TTCID KRequestTCID = 0; + +/** +@internalTechnology +*/ +const TTCID KMinimumRealTCID = 1; + +/** +@internalTechnology +*/ +const TTSID KInvalidTSID = KMaxTUint8; + +/** +@internalTechnology +*/ +const TTCID KMinimumRealTSID = 1; + +/** +@internalTechnology +*/ +const TTCID KMinimumRealSEID = 1; + +/** +@internalTechnology +*/ +const TTSID KMaximumRealTSID = KMaxTUint5; + +/** +@internalTechnology +*/ +const TTCID KMaximumRealTCID = KMaxTUint5; + +/** +@internalTechnology +*/ +const TUint KAvdtpPacketSEIDOffset = 2; // the SEIDs are all in top 6 bits when in packets + +/** +@internalTechnology +*/ +const TUint KAvdtpPacketSEIDMask = 0x3f; + +/** +@internalTechnology +*/ +static const TUint KAvdtpServiceCapabilitiesHeaderLen = 2; +/** +@internalTechnology +*/ +static const TUint8 KUnknownLOSC = KMaxTUint8; +/** +@internalTechnology +Assign a matching error code here equal to the panic value. This can then be returned and used to panic the client. +New panic errors can be added by assigning a value between -994 and -999 in the TGavdp enum. +*/ +const TInt KErrPanicAvdtpOpenInBadState = EGavdpOpenInBadState; + +enum TAvdtpMessage +/* +@internalTechnology +*/ + { + EAvdtpNull =0xff, //This is a special value for asserting on + EReserved =0x00, + EAvdtpDiscover =0x01, + EAvdtpGetCapabilities =0x02, + EAvdtpSetConfiguration =0x03, + EAvdtpGetConfiguration =0x04, + EAvdtpReconfigure =0x05, + EAvdtpOpen =0x06, + EAvdtpStart =0x07, + EAvdtpRelease =0x08, + EAvdtpSuspend =0x09, + EAvdtpAbort =0x0a, + EAvdtpSecurityControl =0x0b, + /* This should be have the largest valid signal identifier value in TAvdtpMessage. + * In order to acheive this all the new signal identifier should be added before it. + */ + EAvdtpLargestValidSignalIndentifier + }; + +struct TInternalGetSEPCapability +/* +@internalTechnology - for communication from GAVDP to AVDTP +*/ + { + TSEID iSEID; + TAvdtpServiceCategory iServiceCategory; + }; + +struct TInternalGetProposedConfiguration +/* +@internalTechnology - for communication from GAVDP to AVDTP +This is used for casting purposes - to retrieve the configuration +an a descripto large enough (see indication) is created. This struct +is then overload into the HBuf to send information for the GetOpt +The outward direction contains the capability. +*/ + { + TSEID iSEID; //inward + }; + +struct TInternalGetSecurityControl +/* +@internalTechnology - for communication from GAVDP to AVDTP +This is used for casting purposes - to retrieve the securitycontrol +an a descripto large enough (see indication) is created. This struct +is then overload into the HBuf to send information for the GetOpt +The outward direction contains the securitycontrol. +*/ + { + TSEID iSEID; + }; + +struct TInternalSelectRemoteSEP +/* +@internalTechnology - for communication from GAVDP to AVDTP +*/ + { + TSEID iLocalSEID; + TSEID iRemoteSEID; + }; + +const TInt KAvdtpMaxInternalIndicationDataSize = 32; + +NONSHARABLE_CLASS(TInternalAvdtpIndication) +/** +@internalTechnology +*/ + { +public: + enum TInternalAvdtpIndicationType + { + EError, // internal initiated avdtp error needs propagation to gavdp + EAir, // inbound signalling command needs propagation to gavdp + EObject, // internal object wishes to communicate with gavdp + }; + TInternalAvdtpIndicationType iType; + }; + +NONSHARABLE_CLASS(TInternalAvdtpErrorIndication) : public TInternalAvdtpIndication + { +public: + inline TInternalAvdtpErrorIndication(); +public: + TInt iError; + }; + +NONSHARABLE_CLASS(TInternalAvdtpObjectIndication) : public TInternalAvdtpIndication + { +public: + enum TInternalAvdtpObjectIndicationType + { + ESignallingReady, + }; +public: + TInternalAvdtpObjectIndicationType iObjectIndication; + TBuf8 iBuf; +protected: + inline TInternalAvdtpObjectIndication(); + }; + + +NONSHARABLE_CLASS(TInternalAvdtpAirIndication) : public TInternalAvdtpIndication +/* +@internalTechnology +*/ + { +public: + inline TInternalAvdtpAirIndication(); +public: + TSEID iSEID; + TAvdtpMessage iIndication; + TInt iPayloadLength; + TAvdtpTransactionLabel iTransactionLabel; + }; + +/* +@internalTechnology +Used for SetConfiguration and Reconfigure +*/ +NONSHARABLE_CLASS(TInternalAvdtpConfigurationIndication) : public TInternalAvdtpAirIndication + { +public: + TSEID iINTSEID; + }; + +NONSHARABLE_CLASS(TInternalAvdtpStreamReadyIndication) : public TInternalAvdtpAirIndication +/* +@internalTechnology +*/ + { +public: + TInternalAvdtpStreamReadyIndication() + { + iPayloadLength = 0; + iIndication = EAvdtpOpen; + }; + TBool iReportingPresent; + TBool iRecoveryPresent; + TSEID iRemoteSEID; + }; + + +NONSHARABLE_CLASS(TInternalAvdtpSignallingReadyIndication) : public TInternalAvdtpObjectIndication +/* +@internalTechnology +*/ + { +public: + TInternalAvdtpSignallingReadyIndication() + { + iObjectIndication = ESignallingReady; + }; + }; + +/** +@internalTechnology +Base struct for returning responses to indications from GAVDP to AVDTP +*/ +struct TAvdtpInternalResponse + { + TSEID iSEID; + TAvdtpTransactionLabel iTransactionLabel; + TInt iResult; + }; + + +/** +@internalTechnology +Used to return from GC the result of a SetConfiguration or Reconfiguration indication +*/ +struct TAvdtpInternalConfigurationResponse : public TAvdtpInternalResponse + { + TAvdtpServiceCategory iCategory; + TBool iIsReconfigure; + }; + +/* +@internalTechnology +Used for sending security control command +*/ +struct TAvdtpInternalSendSecurityControl + { + TSEID iRemoteSEID; + TAvdtpSecurityControlInfo iSecurityControlInfo; + }; + + +/* +@internalTechnology +Used for sending security control response +*/ +struct TAvdtpInternalSecurityControlResponse : public TAvdtpInternalResponse + { + TAvdtpSecurityControlInfo iSecurityControlInfo; + }; + +/* +@internalTechnology +*/ +static const TInt KMaxAvdtpNumSEPs = 32; + +/* +@internalTechnology +*/ +struct TAvdtpInternalDiscoverConfirm + { + TInt iResult; + TInt iNumSEPs; + TPckgBuf > iDiscoveredSEPs; + }; + +/* +@internalTechnology +*/ +struct TAvdtpInternalStartResponse : public TAvdtpInternalResponse + { + }; + + +/* +@internalTechnology +*/ +struct TAvdtpInternalSuspendResponse : public TAvdtpInternalResponse + { + }; + + +// visitors for processing the config PDUs +NONSHARABLE_CLASS(CCapabilityVisitor) : public CBase + { +public: + /* + Return ETrue if visitor believes it's not worth iterating further + */ + virtual TBool Capability(TAvdtpServiceCategory aCat)=0; + + // begin the whole shebang + IMPORT_C void Process(TDes8& aCapabilityBuffer); + +protected: + // Constructor + IMPORT_C CCapabilityVisitor(); + + // Get a non-modifiable descriptor to the payload of the current capability + // (excluding Service Category and LOSC) + IMPORT_C const TDesC8& CapabilityPayload(); + + // Get a modifiable descriptor to the current capability data + // (including Service Category and LOSC) + IMPORT_C TDes8& CapabilityDes(); + +private: + TPtrC8 iCapabilityPayload; + TPtr8 iCapabilityPtr; + }; + +/* +@internalTechnology +*/ +NONSHARABLE_CLASS(CCapabilityPresentVisitor) : public CCapabilityVisitor + { +public: + IMPORT_C CCapabilityPresentVisitor(TAvdtpServiceCategory aRequiredCapability); + virtual TBool Capability(TAvdtpServiceCategory aCat); + inline TBool IsPresent() const + { + return iPresent; + } +private: + TAvdtpServiceCategory iRequiredCapability; + TBool iPresent; + }; + +/* +@internalTechnology +*/ +typedef TFixedArray TCapabilitiesArray; + + +/* +@internalTechnology +*/ +NONSHARABLE_CLASS(CCapabilityParseVisitor) : public CCapabilityVisitor + { +public: + IMPORT_C CCapabilityParseVisitor(TAvdtpServiceCategories aRequiredCategories); + IMPORT_C TCapabilitiesArray GetCapabilities(); + virtual TBool Capability(TAvdtpServiceCategory aCat); + virtual ~CCapabilityParseVisitor(); +private: + TCapabilitiesArray iCapabilities; + TAvdtpServiceCategories iRequiredCategories; + }; + +/* +@internalTechnology +*/ +NONSHARABLE_CLASS(CCapabilitySummaryVisitor) : public CCapabilityVisitor + { +public: + IMPORT_C CCapabilitySummaryVisitor(); + virtual TBool Capability(TAvdtpServiceCategory aCat); + IMPORT_C TAvdtpServiceCategories CapabilitiesPresent() const; +private: + TAvdtpServiceCategories iSeen; + }; + +/*static*/ inline TInt AvdtpInternalUtils::NumberOfTransportObjects(TBool aReporting, TBool aRecovery) + { + TInt num = 1; + num+= aReporting ? 1:0; + num+= aRecovery ? 1:0; + return num; + } + +class TAvdtpMultiplexingCapability : public TAvdtpServiceCapability +/* +@internalTechnology - used by bt_v2.prt and test code +*/ + { +public: + inline TAvdtpMultiplexingCapability(); + IMPORT_C virtual TInt AsProtocol(RBuf8& aBuffer) const; // write into buffer as per protocol + // this implementation always can do mux and frag + IMPORT_C virtual void Parse(const TDesC8& aDes); + IMPORT_C void Reset(); +public: + TBool iFrag; + + // cannot always know the semantics of each entry in the capability + // so it's up to the user to consult with objects to find that + // 0 will always be media + // 1 is either reporting or recovery + // 2 is always recovery if present + // a helper class is provided - see below + TFixedArray iSIDs; + TFixedArray iCIDs; + +private: + enum TAvdtpMultiplexingCapabilityPanic + { + EInvalidCapabilityDataLength, + }; + +private: + inline void Panic(TAvdtpMultiplexingCapabilityPanic aPanic); + }; + +inline void TAvdtpMultiplexingCapability::Panic(TAvdtpMultiplexingCapabilityPanic aPanic) + { + _LIT(KAvdtpMuxHelperPanic, "TAvdtpMultiplexingCapabilityPanic"); + User::Panic(KAvdtpMuxHelperPanic, aPanic); + } + +inline TAvdtpMultiplexingCapability::TAvdtpMultiplexingCapability() +: TAvdtpServiceCapability(EServiceCategoryMultiplexing) + { + // have to set packet length later for this capability + Reset(); + } + +/** +Helps getting/setting the right TCID and TSID in the capability +@see TAvdtpMultiplexingCapability +*/ +NONSHARABLE_CLASS(TAvdtpMultiplexingCapabilityHelper) + { +public: + inline TAvdtpMultiplexingCapabilityHelper(TAvdtpMultiplexingCapability& aMuxCap, + TBool aRequireReporting, + TBool aRequireRecovery); + inline TTCID MediaCID() const; + inline TTSID MediaSID() const; + inline TTCID ReportingCID() const; + inline TTSID ReportingSID() const; + inline TTCID RecoveryCID() const; + inline TTSID RecoverySID() const; + inline void SetMediaCID(TTCID aTCID); + inline void SetMediaSID(TTSID aTSID); + inline void SetReportingCID(TTCID aTCID); + inline void SetReportingSID(TTSID aTSID); + inline void SetRecoveryCID(TTCID aTCID); + inline void SetRecoverySID(TTSID aTSID); + +private: + TAvdtpMultiplexingCapability& iMuxCap; + const TInt iMediaIndex; + const TInt iReportingIndex; + TInt iRecoveryIndex; +#ifdef _DEBUG + TBool iRequireReporting; + TBool iRequireRecovery; + enum TAvdtpMuxHelperPanic + { + EAvdtpMuxHelperWronglyUsed, + }; + inline void Panic(TAvdtpMuxHelperPanic aPanic); +#endif + }; + +/** +Class used for communicating reporting and recovery configurations between Gavdp and Avdtp +@internalTechnology +*/ +NONSHARABLE_CLASS(TReportingAndRecovery) + { +public: + TSEID iSEID; + TBool iReporting; + TBool iRecovery; + }; + +const TInt KAvdtpMaxInternalIndicationSize = sizeof(TInternalAvdtpObjectIndication); + + +inline TAvdtpMultiplexingCapabilityHelper::TAvdtpMultiplexingCapabilityHelper( + TAvdtpMultiplexingCapability& aMuxCap, + TBool aRequireReporting, + TBool aRequireRecovery) +: iMuxCap(aMuxCap), iMediaIndex(0), iReportingIndex(1) + { +#ifdef _DEBUG + // to assert against later + iRequireReporting = aRequireReporting; + iRequireRecovery = aRequireRecovery; +#endif + iRecoveryIndex = aRequireReporting & aRequireRecovery ? 2 : 1; + } + +inline TTCID TAvdtpMultiplexingCapabilityHelper::MediaCID() const + { + return iMuxCap.iCIDs[iMediaIndex]; + } + +inline TTSID TAvdtpMultiplexingCapabilityHelper::MediaSID() const + { + return iMuxCap.iSIDs[iMediaIndex]; + } + +inline TTCID TAvdtpMultiplexingCapabilityHelper::ReportingCID() const + { + return iMuxCap.iCIDs[iReportingIndex]; + } + +inline TTSID TAvdtpMultiplexingCapabilityHelper::ReportingSID() const + { + return iMuxCap.iSIDs[iReportingIndex]; + } + +inline TTCID TAvdtpMultiplexingCapabilityHelper::RecoveryCID() const + { + return iMuxCap.iCIDs[iRecoveryIndex]; + } + +inline TTSID TAvdtpMultiplexingCapabilityHelper::RecoverySID() const + { + return iMuxCap.iSIDs[iRecoveryIndex]; + } + +inline void TAvdtpMultiplexingCapabilityHelper::SetMediaCID(TTCID aTCID) + { + iMuxCap.iCIDs[iMediaIndex] = aTCID; + } + +inline void TAvdtpMultiplexingCapabilityHelper::SetMediaSID(TTSID aTSID) + { + iMuxCap.iSIDs[iMediaIndex] = aTSID; + } + +inline void TAvdtpMultiplexingCapabilityHelper::SetReportingCID(TTCID aTCID) + { + __ASSERT_DEBUG(iRequireReporting, Panic(EAvdtpMuxHelperWronglyUsed)); + iMuxCap.iCIDs[iReportingIndex] = aTCID; + } + +inline void TAvdtpMultiplexingCapabilityHelper::SetReportingSID(TTSID aTSID) + { + __ASSERT_DEBUG(iRequireReporting, Panic(EAvdtpMuxHelperWronglyUsed)); + iMuxCap.iSIDs[iReportingIndex] = aTSID; + } + +inline void TAvdtpMultiplexingCapabilityHelper::SetRecoveryCID(TTCID aTCID) + { + __ASSERT_DEBUG(iRequireReporting, Panic(EAvdtpMuxHelperWronglyUsed)); + iMuxCap.iCIDs[iRecoveryIndex] = aTCID; + } + +inline void TAvdtpMultiplexingCapabilityHelper::SetRecoverySID(TTSID aTSID) + { + __ASSERT_DEBUG(iRequireReporting, Panic(EAvdtpMuxHelperWronglyUsed)); + iMuxCap.iSIDs[iRecoveryIndex] = aTSID; + } + + +inline TInternalAvdtpErrorIndication::TInternalAvdtpErrorIndication() + { + iType = TInternalAvdtpIndication::EError; + } + +inline TInternalAvdtpAirIndication::TInternalAvdtpAirIndication() + { + iType = TInternalAvdtpIndication::EAir; + } + +inline TInternalAvdtpObjectIndication::TInternalAvdtpObjectIndication() + { + iType = TInternalAvdtpIndication::EObject; + } + +#ifdef _DEBUG +inline void TAvdtpMultiplexingCapabilityHelper::Panic(TAvdtpMuxHelperPanic aPanic) + { + _LIT(KAvdtpMuxHelperPanic, "AVDTPMuxHelperPanic"); + User::Panic(KAvdtpMuxHelperPanic, aPanic); + } +#endif + +inline TAvdtpSignallingErrorCode AvdtpInternalUtils::SymbianErrorToAvdtpError(TInt aSymbianError) + { + return aSymbianError == KErrNotFound ? EAvdtpBadACPSEID : + static_cast(KErrAvdtpSignallingErrorBase-aSymbianError); + } + +inline void AvdtpInternalUtils::PacketErrorLeaveL(TAvdtpSignallingErrorCode aCode) + { + User::Leave(ConvertToSymbianError::AvdtpError(aCode)); + } + +#endif