diff -r 000000000000 -r 29b1cd4cb562 bluetooth/btstack/linkmgr/linkmgr.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bluetooth/btstack/linkmgr/linkmgr.h Fri Jan 15 08:13:17 2010 +0200 @@ -0,0 +1,404 @@ +// Copyright (c) 1999-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: +// Defines the LinkMgr protocol class +// +// + +#ifndef LINKMGR_H +#define LINKMGR_H + +#include +#include +#include +#include "notification.h" +#include +#include +#include +#include "btfeatures.h" +#include "secman.h" +#include "linkmuxer.h" +#include "bt.h" +#include "btconsts.h" +#include "internaltypes.h" +#include +#include +#include + + +class CBTProtocolFamily; +class CLinkMgrProtocol; +class CBTInquiryMgr; +class CHCIFacade; +class CLinkMuxer; +class CACLDataQController; +class CBTSecMan; +class CPhysicalLinksManager; +class CACLLinkStateFactory; +class CSyncLinkStateFactory; +class CSubscriber; +class CVendorSAP; +class CHCIDirectAccessSAPsManager; +class CEirManServer; +class CEirPublisherTxPowerLevel; +class CEirPublisherLocalName; + +NONSHARABLE_CLASS(CRegistrySession) + : public CBase + { +friend class CLinkMgrProtocol; +public: + void Open(); + void Close(); + + RBTRegServ& RegServ(); + +private: // for use by CLinkMgrProtocol + static CRegistrySession* NewL(CLinkMgrProtocol& aLinkMgrProtocol); + ~CRegistrySession(); + + CRegistrySession(CLinkMgrProtocol& aLinkMgrProtocol); + void ConstructL(); + +private: + TInt iAccessCount; + RBTRegServ iRegServ; + CLinkMgrProtocol& iLinkMgrProtocol; + }; + +NONSHARABLE_CLASS(TBTTrackedLocalDevice) : public TBTLocalDevice + { +public: + void SetAddress(const TBTDevAddr& aAddr); + void SetDeviceClass(TUint32 aCod); + void SetDeviceName(const TDesC8& aName); + void SetScanEnable(THCIScanEnable aEnable); + void SetLimitedDiscoverable(TBool aOn); + void SetPowerSetting(TUint8 aPowerSetting); + void SetAFHChannelAssessmentMode(TBool aOn); + void SetAcceptPairedOnlyMode(TBool aOn); + + void Modify(TBTLocalDevice& aLocalDeviceSettings); + void ResetChangesMask(); + +private: + void StoreChange(TUint8 aChange); + +private: + TUint8 iChangedSettings; + }; + +NONSHARABLE_CLASS(CRegistryUpdater) : public CActive + { +public: + ~CRegistryUpdater(); + CRegistryUpdater(RBTLocalDevice& aLocalDevice, TBTTrackedLocalDevice& aSettings); + void Update(); +private: + void RunL(); + void DoCancel(); +private: + RBTLocalDevice& iLocalDevice; + TBTTrackedLocalDevice& iStackSettings; + TBTLocalDevice iRegistrySettings; + TBool iRepeatUpdate; + }; + + +NONSHARABLE_CLASS(CLinkMgrProtocol) : public CBluetoothProtocolBase + { +public: + // Create ourselves + static CLinkMgrProtocol* NewL(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan); + static void ProtocolIdentity(TServerProtocolDesc* aDesc); + + void LocalOpen(); + void LocalClose(); + + void Error(TInt anError,CProtocolBase* aSourceProtocol=NULL); + +private: // From CProtocolBase + // Factories + CHostResolvProvdBase* NewHostResolverL(); + CServProviderBase* NewSAPL(TUint aSockType); + + // Ref Counting + void Close(); + void Open(); + void CloseNow(); + + // Others + void InitL(TDesC &aTag); // From ProtocolManager before all binding. + void StartL(); // From Protocol Manager - after all binding + void BindL(CProtocolBase* protocol, TUint id); + void Identify(TServerProtocolDesc* aDesc)const; // Query function + +private: // from CBluetoothProtocolBase + TInt BearerConnectComplete(const TBTDevAddr& /*aAddr*/, CServProviderBase* /*aSAP*/) {return KErrNotSupported;}; + TInt ControlPlaneMessage(TBTControlPlaneMessage aMessage, TAny* aParam); + +public: + + void SetInquiryAndPageScanningL(); + void SetAcceptPairedOnlyMode(TBool aOn); + void SetSimplePairingDebugMode(TBool aOn); + + // LinkMgr specific functions + inline const TBTDevAddr& LocalBTAddress() const; // Get our local address + void SetLocalBTAddress(const TBTDevAddr& aAddr); + + void SetUIDiscovering(TInt aDiscoveringState); + + inline CPhysicalLinksManager& PhysicalLinksMgr() const; + inline CACLLinkStateFactory& ACLStateFactory() const; + inline CSyncLinkStateFactory& SyncStateFactory() const; + + // later - change local device management/notification to be nicer... + inline const TBTLocalDevice& LocalDevice() const; + void UpdateLocalDeviceName(const TDesC8& aName); + void UpdateLocalDeviceName(TBool aSucceeded); + void UpdateLocalDevicePower(TBTPowerState aState); + void UpdateLocalDeviceScanEnable(TBool aSucceeded); + void UpdateDeviceClass(TBool aSucceeded); + void UpdateAFHChannelAssessmentMode(TBool aSucceeded); + void UpdateLimitedDiscoverable(TBool aSucceeded); + + TBTDevHCIVersion GetHWHCIVersion() const; + + void SetLimitedDiscoverableIfChangedL(TBool aOn); + void SetLocalVersion(THCIErrorCode aErr, TBTDevHCIVersion aHCIVersion, TBTDevLMPVersion aLMPVersion); + void SetOverrideLPMTimeout(TUint aOverrideLPMTimeout); + void SetLocalFeatures(THCIErrorCode aErr, const TBTFeatures& aMask); + void SetLocalCommands(THCIErrorCode aErr, const TBluetoothHciCommands& aMask); + void SetDeviceClassL(TUint32 aCod); + TInt SetLocalDeviceName(const TDesC8& aName); + void SetAFHChannelAssessmentModeL(TBool aMode); + void SetAFHHostChannelClassificationL(const TBTAFHHostChannelClassification& aChannelClassification); + void SetUIConnecting(TBool aConnecting); + void SetUINumPhysicalLinks(TUint aNum); + void SetUINumSynchronousLinks(TUint aNum); + + inline CHCIFacade& HCIFacade() const; + inline CBTInquiryMgr& InquiryMgr() const; + inline CLinkMuxer& LinkMuxer() const; + inline CACLDataQController& ACLController() const; + TInt ACLPacketMTU() const; + + inline CVendorSAP* VendorSpecificSAP() const; + void UpdateDeviceClass(TBool aSucceeded, TUint aCoD); + void WriteClassOfDeviceL(TUint32 aCod); + void ClearPendingLocalDeviceSettingsCod(); + + void UpdateInquiryResponseTxPowerLevel(TInt8 aTxPowerLevel); + + inline const TBTFeatures& PacketsSupportedLocally() const; + inline TUint8 ModesSupportedLocally() const; + + void LocalSupportedFeaturesAvailable(); + + inline TBool IsEncryptionSupportedLocally() const; + inline TBool IsRoleSwitchSupportedLocally() const; + inline TBool IsSecureSimplePairingSupportedLocally() const; + inline TBool IsModeSupportedLocally(TBTLinkMode aMode) const; + inline TBool IsEncryptionPauseResumeSupportedLocally() const; + inline TBool IsExtendedInquiryResponseSupportedLocally() const; + inline TBool IsRssiWithInquiryResultsSupportedLocally() const; + + inline TBool IsCommandSupportedLocally(TBluetoothSupportedCommandsBits aCommand) const; + +private: + CLinkMgrProtocol(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan); + ~CLinkMgrProtocol(); + void DoSetLimitedDiscoverableL(TBool aOn); + void QueIdleTimerEntry(); + void RemoveIdleTimerEntry(); + static TInt TryToClose(TAny* aProtocol); + void UpdateSettings(); + virtual TInt StartProtocolListening(); + virtual void StopProtocolListening(); + TInt KickDiscoverabilitySubscriber(); + void DefinePublications(THCIScanEnable aHCIScanEnable); + void DeletePublications(); + + void ExternalOpenInit(); + void ExternalCloseCleanup(); + +private: +friend class CVendorSAP; +friend class CBTCodServiceMan; + TInt iExternalRef; + + // Singleton objects owned + CPhysicalLinksManager* iPhysicalLinksMgr; + + CRegistrySession* iRegSess; // owns an RBTRegServ for sharing. + RBTLocalDevice iLocalDevice; //subsession + TBTTrackedLocalDevice iLocalDeviceSettings; + TBTLocalDevice iPendingLocalDeviceSettings; + + RProperty iProperty; + + CBTInquiryMgr* iInquiryMgr; + CHCIFacade* iHCIFacade; + CLinkMuxer* iLinkMuxer; + CEirManServer* iEirManServer; + + CACLLinkStateFactory* iACLStateFactory; + CSyncLinkStateFactory* iSCOStateFactory; + + RPointerArray iSubscribers; + + TUint iOverrideLPMTimeout; + + // protocol state objects + TBool iClosePending; // the protocol is closing + TDeltaTimerEntry iIdleTimerEntry; + TBool iIdleEntryQueued; + + // features of the local hardware that dont need persisting + TBTDevAddr iLocalDeviceAddress; + TBTDevHCIVersion iHWHCIVersion; + TBTDevLMPVersion iHWLMPVersion; + TBTFeatures iHWFeatures; + TBluetoothHciCommands iHWCommands; + + CRegistryUpdater* iRegistryUpdater; + + // non-owned + CProtocolBase* iUpperProtocol; // L2CAP + CVendorSAP* iVendorSpecificSAP; + + + // Inquiry Response Transmit Power Level value + TInt8 iTxPowerLevel; + CEirPublisherLocalName* iLocalNamePublisher; + CEirPublisherTxPowerLevel* iTxPowerLevelPublisher; + + TInt iDebugModeDefinitionResult; + }; + +inline const TBTDevAddr& CLinkMgrProtocol::LocalBTAddress() const +/** + Return the local BT address. + This actually might not be set on initial startup, as it + takes a finite time to get the local address out of the + hardware. But it should not matter, as this local address + is not actually used for much (get local address ioctl + actually re-reads it from the hardware.) +**/ + { + return iLocalDeviceAddress; + } + +inline CPhysicalLinksManager& CLinkMgrProtocol::PhysicalLinksMgr() const + { + __ASSERT_DEBUG(iPhysicalLinksMgr, User::Panic(_L("linkmgr.h"), __LINE__)); + return *iPhysicalLinksMgr; + } + +inline const TBTLocalDevice& CLinkMgrProtocol::LocalDevice() const + { + return iLocalDeviceSettings; + } + +inline CBTInquiryMgr& CLinkMgrProtocol::InquiryMgr() const + { + return *iInquiryMgr; + } + +inline CHCIFacade& CLinkMgrProtocol::HCIFacade() const + { + return *iHCIFacade; + } + +inline CLinkMuxer& CLinkMgrProtocol::LinkMuxer() const + { + return *iLinkMuxer; + } + +inline CACLDataQController& CLinkMgrProtocol::ACLController() const + { + return LinkMuxer().DataQController(); + } + +inline CACLLinkStateFactory& CLinkMgrProtocol::ACLStateFactory() const + { + return *iACLStateFactory; + } + +inline CSyncLinkStateFactory& CLinkMgrProtocol::SyncStateFactory() const + { + return *iSCOStateFactory; + } + +inline CVendorSAP* CLinkMgrProtocol::VendorSpecificSAP() const + { + return iVendorSpecificSAP; + } + +inline TUint8 CLinkMgrProtocol::ModesSupportedLocally() const + { + // baseband spec: + // mode support is --------|-------x|xx------ + // **this method returns it in lowest bits of a uint8** + return TUint8(iHWFeatures.LinkModes()); + } + +inline const TBTFeatures& CLinkMgrProtocol::PacketsSupportedLocally() const + { + // not masking for now - disparate bits and in future have EV packets + return iHWFeatures; + } + +inline TBool CLinkMgrProtocol::IsModeSupportedLocally(TBTLinkMode aMode) const + { + // bits 6 to 8 show us modes supported + return iHWFeatures.IsModeSupported(aMode); + } + +inline TBool CLinkMgrProtocol::IsRoleSwitchSupportedLocally() const + { + return iHWFeatures.IsRoleSwitchSupported(); + } + +inline TBool CLinkMgrProtocol::IsEncryptionSupportedLocally() const + { + return iHWFeatures.IsEncryptionSupported(); + } + +inline TBool CLinkMgrProtocol::IsExtendedInquiryResponseSupportedLocally() const + { + return iHWFeatures.IsExtendedInquiryResponseSupported(); + } + +inline TBool CLinkMgrProtocol::IsRssiWithInquiryResultsSupportedLocally() const + { + return iHWFeatures.IsRssiWithInquiryResultsSupported(); + } + +inline TBool CLinkMgrProtocol::IsSecureSimplePairingSupportedLocally() const + { + return iHWFeatures.IsSecureSimplePairingSupported(); + } + +inline TBool CLinkMgrProtocol::IsEncryptionPauseResumeSupportedLocally() const + { + return iHWFeatures.IsEncryptionPauseResumeSupported(); + } + +inline TBool CLinkMgrProtocol::IsCommandSupportedLocally(TBluetoothSupportedCommandsBits aCommand) const + { + return iHWCommands[aCommand]; + } + +#endif