// Copyright (c) 1999-2010 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:
// This implements the CLinkMgrProtocol object that is the contact point from
// BT PRT to the LinkMgr stack
// At present this class also remembers the configuration of the controller
// -- no particular reason - could be encapsulated in a class that the facade
// knows about.
//
//
#include <bt_sock.h>
#include <bluetooth/logger.h>
#include "debug.h"
#include <utf.h>
#include <bluetooth/hci/hciframe.h>
#include <bluetooth/aclsockaddr.h>
#include "linkmgr.h"
#include "hcifacade.h"
#include "bt.h"
#include "hostresolver.h"
#include "linkmuxer.h"
#include "physicallinksmanager.h"
#include "linkconsts.h"
#include "eirmanserver.h"
#include "eirmanager.h"
#include "eirpublisherlocalname.h"
#include "eirpublishertxpowerlevel.h"
#include "bredrcontrollerconfiguration.h"
#include "ProxySAP.h"
#include "SCOSAP.h"
#include "ACLSAP.h"
#include "VendorSAP.h"
#include "vendorspecific.h"
#include "Subscribers.h"
#include "BTSec.h"
#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_LINKMGR);
#endif
#ifdef _DEBUG
PANICCATEGORY("linkmgr");
#endif
const TInt KLengthOfDeviceClass = 11; // 11 bits in the device class portion of the CoD
const TInt KStartingOffsetOfDeviceClass = 2; // 2 LSB bits for format type
const TUint32 KDeviceClassReset = 0; // used to reset persistent data
// Constant which can be ANDed with a complete CoD bitmask to extract the device class portion.
const TInt KDeviceClassBitMask = ((1 << KLengthOfDeviceClass) - 1) << KStartingOffsetOfDeviceClass;
enum TLinkMgrPanic
{
ELinkMgrProtocolOpenedAfterClose,
ELinkMgrProtocolBadAFHHostChannelClassification,
EUnknownFatalError,
ELocalDeviceBadHandle,
ERegistrySessionClosedTooManyTimes,
ERegistrySessionDeletedWhenOpen,
};
void Panic(TLinkMgrPanic aPanic)
// Panic L2CAP due to stack bug.
{
LOG_STATIC_FUNC
_LIT(KL2CAPPanicName, "BTLinkMgr");
User::Panic(KL2CAPPanicName, aPanic);
}
// Construction & Initialisation
CLinkMgrProtocol::CLinkMgrProtocol(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan)
: CBluetoothProtocolBase(aSecMan, aControlPlane, aCodMan)
, iDebugModeDefinitionResult(KErrGeneral)
{
LOG_FUNC
TCallBack cb(TryToClose, this);
iIdleTimerEntry.Set(cb);
}
CLinkMgrProtocol::~CLinkMgrProtocol()
/**
Delete all our stuff
**/
{
LOG_FUNC
RemoveIdleTimerEntry();
// Delete setter P&S values
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetScanningStatus);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetLimitedDiscoverableStatus);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetDeviceClass);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetAFHHostChannelClassification);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetAFHChannelAssessmentMode);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetDeviceName);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetAcceptPairedOnlyMode);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetPageScanParameters);
// Delete standard P&S values (possibly trying to delete already deleted shared set+get values)
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetLocalDeviceAddress);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetPHYCount);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetConnectingStatus);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetScanningStatus);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetLimitedDiscoverableStatus);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetDeviceClass);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetDeviceName);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetAcceptPairedOnlyMode);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothHostResolverActive);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetSimplePairingDebugMode);
iProperty.Delete(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetPageScanParameters);
delete iPhysicalLinksMgr;
delete iInquiryMgr;
delete iEirManServer;
delete iACLStateFactory;
delete iSCOStateFactory;
SecMan().ClearHCICommandQueue(); // clears up the commands
SecMan().ClearLinksMgrProtocol();
SecMan().ClearPhysicalLinksMgr();
delete iLinkMuxer;
delete iHCIFacade;
delete iRegistryUpdater;
DeletePublications();
iSubscribers.ResetAndDestroy();
iLocalDevice.Close();
delete iRegSess;
}
CLinkMgrProtocol* CLinkMgrProtocol::NewL(CBTSecMan& aSecMan, RBTControlPlane& aControlPlane, CBTCodServiceMan& aCodMan)
{
LOG_STATIC_FUNC
CLinkMgrProtocol* i=new (ELeave) CLinkMgrProtocol(aSecMan, aControlPlane, aCodMan);
return i;
}
void CLinkMgrProtocol::InitL(TDesC& /*aTag*/)
/**
Pre-binding initialise.
Allocate any objects we need here.
ESOCK ensures that this function will only be called once per
object of this class, regardless of how long it hangs around.
**/
{
LOG_FUNC
__ASSERT_DEBUG(!iClosePending, Panic(ELinkMgrProtocolOpenedAfterClose));
__ASSERT_DEBUG(!iIdleEntryQueued, Panic(ELinkMgrProtocolOpenedAfterClose));
__ASSERT_DEBUG(!iHCIFacade, Panic(ELinkMgrProtocolOpenedAfterClose));
// Get the local device settings from persistent store
// By keeping a session open for the lifetime of this protocol
// we prevent RegServ being created during connection time.
LOG(_L("LinkMgr : Initialising RegistryServer"));
iRegSess = CRegistrySession::NewL(*this);
TInt err = iLocalDevice.Open(iRegSess->RegServ());
if (err ==KErrNone)
{
// read local device settings (e.g page scan\inquiry scan) from registry
err = iLocalDevice.Get(iLocalDeviceSettings); // ignore error - can continue
__ASSERT_DEBUG(err==KErrNone, Panic(EUnknownFatalError));
//
// Mask off the service class bits from the CoD -- we're not interested in the
// registry's values for anything other than the device class part.
// There's a nice terminology overload here, as the 'Class of Device' contains
// both a device class and a service class. It might have been nice if the
// getter and setter methods were 'ClassOfDevice', but even that wouldn't help
// much...
//
iLocalDeviceSettings.SetDeviceClass(iLocalDeviceSettings.DeviceClass() & KDeviceClassBitMask);
//NB - no (ELeave) here - in OOM we'd rather continue and not update the registry
//than Leave. All calls to methods are guarded by "if (iRegistryUpdater)"
iRegistryUpdater = new CRegistryUpdater(iLocalDevice, iLocalDeviceSettings);
}
LOG(_L("LinkMgr : Creating HCIFacade (and HCI)"));
iHCIFacade = CHCIFacade::NewL(*this); // Create HCI/HCIFacade first
iPhysicalLinksMgr = CPhysicalLinksManager::NewL(*this, *iHCIFacade, *iRegSess, SecMan(), CodMan());
iPhysicalLinksMgr->SetAcceptPairedOnlyMode(iLocalDeviceSettings.AcceptPairedOnlyMode()); // Tell the physical links manager the persisted value for the accept paired only mode
iHCIFacade->SetPhysicalLinksMgr(*iPhysicalLinksMgr); // Tell HCIFacade of ConnMgr
SecMan().SetPhysicalLinksMgr(*iPhysicalLinksMgr);
SecMan().SetLinksMgrProtocol(*this);
SecMan().SetHCICommandQueue(iHCIFacade->CommandQController());
LOG(_L("LinkMgr : Initialising Link Muxer"));
iLinkMuxer=CLinkMuxer::NewL(*this, *iHCIFacade);
iHCIFacade->SetLinkMuxer(*iLinkMuxer);
iACLStateFactory = CACLLinkStateFactory::NewL();
iSCOStateFactory = CSyncLinkStateFactory::NewL();
LOG(_L("LinkMgr : Initialising EirManServer"));
iEirManServer = CEirManServer::NewL(iHCIFacade->CommandQController(), *this);
LOG(_L("LinkMgr : Initialising InquiryMgr"));
iInquiryMgr = CBTInquiryMgr::NewL(*this);
iInquiryMgr->SetHCICommandQueue(iHCIFacade->CommandQController());
LOG(_L("LinkMgr : Configuring HCIFacade)"));
iHCIFacade->InitL(iLocalDeviceSettings);// passes ownership of device
// Inquiry and page scan is read from BT Registry and set it to P&S
// As there is no listening socket, they are set to OFF on HW yet!
// P&S value is taken to account as soon we open the first listening socket!
DefinePublications(iLocalDeviceSettings.ScanEnable());
// set up subscribers
CSubscriber* subscriber;
subscriber = CDiscoverabilitySubscriber::NewL(*this);
CleanupStack::PushL(subscriber);
User::LeaveIfError(iSubscribers.Append(subscriber));
CleanupStack::Pop(subscriber);
subscriber = CLimitedSubscriber::NewL(*this);
CleanupStack::PushL(subscriber);
User::LeaveIfError(iSubscribers.Append(subscriber));
CleanupStack::Pop(subscriber);
subscriber = CDeviceClassSubscriber::NewL(*this);
CleanupStack::PushL(subscriber);
User::LeaveIfError(iSubscribers.Append(subscriber));
CleanupStack::Pop(subscriber);
subscriber = CAFHHostChannelClassificationSubscriber::NewL(*this);
CleanupStack::PushL(subscriber);
User::LeaveIfError(iSubscribers.Append(subscriber));
CleanupStack::Pop(subscriber);
subscriber = CDeviceNameSubscriber::NewL(*this);
CleanupStack::PushL(subscriber);
User::LeaveIfError(iSubscribers.Append(subscriber));
CleanupStack::Pop(subscriber);
subscriber = CRegistryRemoteTableSubscriber::NewL(*this);
CleanupStack::PushL(subscriber);
User::LeaveIfError(iSubscribers.Append(subscriber));
CleanupStack::Pop(subscriber);
subscriber = CAcceptPairedOnlySubscriber::NewL(*this);
CleanupStack::PushL(subscriber);
User::LeaveIfError(iSubscribers.Append(subscriber));
CleanupStack::Pop(subscriber);
subscriber = CAFHChannelAssessmentModeSubscriber::NewL(*this);
CleanupStack::PushL(subscriber);
User::LeaveIfError(iSubscribers.Append(subscriber));
CleanupStack::Pop(subscriber);
if(iDebugModeDefinitionResult == KErrNone)
{
// Only subscribe on debug mode if we have managed to successfully define
// the key ourselves (this is because it needs to be protected with the very
// strong CommDD capability).
subscriber = CDebugModeSubscriber::NewL(*this);
CleanupStack::PushL(subscriber);
User::LeaveIfError(iSubscribers.Append(subscriber));
CleanupStack::Pop(subscriber);
}
subscriber = CPageScanParametersSubscriber::NewL(*this);
CleanupStack::PushL(subscriber);
User::LeaveIfError(iSubscribers.Append(subscriber));
CleanupStack::Pop(subscriber);
// set CoD - leave if goes wrong, user's device will be "unknown" otherwise
// NB - In future we should tie this to the SDP Server...(or someother higher API...)
if (iLocalDeviceSettings.DeviceClass() && iLocalDeviceSettings.IsValidDeviceClass())
// Some phones never set their CoD in s/w, we don't want to blat
// over their h/w settings
{
iPendingLocalDeviceSettings.SetDeviceClass(iLocalDeviceSettings.DeviceClass()); //we expect this after power on
}
CodMan().Initialise(); // Cod Service Manager can now get a valid CoD
if(iLocalDeviceSettings.AFHChannelAssessmentMode() == EFalse)
// If this feature is supported it will start off switched on
{
SetAFHChannelAssessmentModeL(iLocalDeviceSettings.AFHChannelAssessmentMode());
}
//Attempt to make sure that controller has the same value as the registry
//and that the P&S key 'KPropertyKeyBluetoothGetLimitedDiscoverableStatus'
//is, as a consequence, 'Set' appropriately (when the associated controller
//event arrives).
DoSetLimitedDiscoverableL(iLocalDeviceSettings.LimitedDiscoverable());
LOG(_L("LinkMgr : Initialising BR/EDR Controller Configuration"));
iBrEdrControllerConfiguration = CBrEdrControllerConfiguration::NewL(iHCIFacade->CommandQController(), *this);
LOG(_L("LinkMgr : Initialising complete"));
}
void CLinkMgrProtocol::DefinePublications(THCIScanEnable aHCIScanEnable)
{
LOG_FUNC
// 6 properties for setting.
// Its possible that these are re-defined below, but we are discarding any KErrAlreadyExists.
// As the setters require more capabilities we ensure that they get defined first.
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetScanningStatus,
RProperty::EInt,
KLOCAL_SERVICES_AND_NETWORK_CONTROL,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
// Even if we initialise KPropertyKeyBluetoothSetScanningStatus to Inquiry &
// Page scanning enabled, it's not turned on at this point. Only when first
// listening socket is opened, this value will control the inquiry scan & page scan
(void)(iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetScanningStatus,
aHCIScanEnable));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetLimitedDiscoverableStatus,
RProperty::EInt,
KLOCAL_SERVICES_AND_NETWORK_CONTROL,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetDeviceClass,
RProperty::EInt,
KLOCAL_SERVICES_AND_NETWORK_CONTROL,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetAFHHostChannelClassification,
RProperty::EByteArray,
KLOCAL_SERVICES_AND_NETWORK_CONTROL,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetAFHChannelAssessmentMode,
RProperty::EInt,
KLOCAL_SERVICES_AND_NETWORK_CONTROL,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetDeviceName,
RProperty::EText,
KLOCAL_SERVICES_AND_NETWORK_CONTROL,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetAcceptPairedOnlyMode,
RProperty::EInt,
KLOCAL_SERVICES_AND_NETWORK_CONTROL,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
iDebugModeDefinitionResult = (iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetSimplePairingDebugMode,
RProperty::EInt,
KLOCAL_SERVICES,
KCOMMDD
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetPageScanParameters,
RProperty::EInt,
KLOCAL_SERVICES_AND_NETWORK_CONTROL,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void) RProperty::Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetPageScanParameters,
EStandardPageScanParameters);
// Original Get P&S value definitions.
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetLocalDeviceAddress,
RProperty::EByteArray,
KLOCAL_SERVICES,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetPHYCount,
RProperty::EInt,
KLOCAL_SERVICES,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetConnectingStatus,
RProperty::EInt,
KLOCAL_SERVICES,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetScanningStatus,
RProperty::EInt,
KLOCAL_SERVICES,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetLimitedDiscoverableStatus,
RProperty::EInt,
KLOCAL_SERVICES,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetDeviceClass,
RProperty::EInt,
KLOCAL_SERVICES,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetDeviceName,
RProperty::EText,
KLOCAL_SERVICES,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetAcceptPairedOnlyMode,
RProperty::EInt,
KLOCAL_SERVICES,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void) (iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothHostResolverActive,
RProperty::EInt,
KLOCAL_SERVICES,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetSimplePairingDebugMode,
RProperty::EInt,
KLOCAL_SERVICES,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void)(iProperty.Define(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetPageScanParameters,
RProperty::EInt,
KLOCAL_SERVICES_AND_NETWORK_CONTROL,
KLOCAL_SERVICES_AND_NETWORK_CONTROL
));
(void) RProperty::Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetPageScanParameters,
EStandardPageScanParameters);
}
void CLinkMgrProtocol::DeletePublications()
{
LOG_FUNC
//we own them, so they'll get deleted
iProperty.Close();
}
void CLinkMgrProtocol::StartL()
/**
Binding complete.
Startup call from esock. Do nothing
If HCI needs any start-up, do it here.
**/
{
LOG_FUNC
}
// From higher protocol
void CLinkMgrProtocol::BindL(CProtocolBase* protocol, TUint /* id*/)
{
LOG_FUNC
TServerProtocolDesc prtDesc;
protocol->Identify(&prtDesc);
#ifdef TCI
if(prtDesc.iAddrFamily!=KBTAddrFamily || prtDesc.iProtocol!=KTCIL2CAP)
#else
if(prtDesc.iAddrFamily!=KBTAddrFamily || prtDesc.iProtocol!=KL2CAP)
#endif
{
User::Leave(KErrBtEskError);
}
// Store this for error propogation
//
iUpperProtocol = protocol;
}
// Factory functions
CHostResolvProvdBase* CLinkMgrProtocol::NewHostResolverL()
{
LOG_FUNC
return iInquiryMgr->NewHostResolverL();
}
// Query functions
void CLinkMgrProtocol::Identify(TServerProtocolDesc* aDesc) const
//
// Identify request from SOCKET server
//
{
LOG_FUNC
CLinkMgrProtocol::ProtocolIdentity(aDesc);
}
void CLinkMgrProtocol::ProtocolIdentity(TServerProtocolDesc* aDesc)
{
LOG_STATIC_FUNC
_LIT(name,"BTLinkManager");
aDesc->iProtocol=KBTLinkManager;
aDesc->iName=name;
aDesc->iAddrFamily=KBTAddrFamily;
aDesc->iSockType=KUndefinedSockType; // various!
aDesc->iVersion=TVersion(KBTMajor,KBTMinor,KBTBuild);
aDesc->iByteOrder=ELittleEndian;
/*
The following sockets are exposed as RSockets
'Proxy' = a SAP attached to a baseband connection that can influence it
'SCO' = a SAP providing SCO services
Higher protocols can additionally ask for ACL SAPs, but these are not
available as RSockets
This guides the direction of the ServiceInfo below
*/
aDesc->iServiceInfo=KSIDatagram|KSIGracefulClose|KSIBroadcast|KSIQOS|KSICanReconnect|KSIConnectData|KSIDisconnectData; // slightly hijacked connectData
aDesc->iNamingServices=KNSNameResolution;
aDesc->iSecurity=KSocketNoSecurity;
aDesc->iMessageSize=Max(CHctlSynchronousDataFrame::KHCTLMaxSynchronousDataSize, CHctlAclDataFrame::KHCTLMaxACLDataSize);
aDesc->iServiceTypeInfo=ESocketSupport|ECantProcessMBufChains|ENeedMBufs|ETransport
|EPreferDescriptors|EUseCanSend;
aDesc->iNumSockets=100; // one per baseband - including many parked!
}
void CLinkMgrProtocol::Error(TInt aErr, CProtocolBase* /*aProt*/)
{
LOG_FUNC
// A fatal error has occurred (Power off hopefully!). Notify the upper protocol
// (of there is one) and the inquiry manager.
__ASSERT_DEBUG(aErr==KErrHardwareNotAvailable, Panic(EUnknownFatalError));
iInquiryMgr->CompleteCommands(aErr);
iPhysicalLinksMgr->FatalError(aErr);
}
void CLinkMgrProtocol::CloseNow()
/**
Close command from base class.
Called when ref count reaches 0.
We don't actually have to close now, but when we finally
do, we must call CanClose (done within TryToClose). That'll
actually delete us. In the mean time, if a new client tries
to connect to LinkMgr, ESOCK will use this existing one and just
call Open on it.
What we do here, is queue an idle timer entry. It's expiry will
call TryToClose, which'll actually do the close.
**/
{
LOG_FUNC
// synchronously update stack state in Registry
iLocalDevice.Modify(iLocalDeviceSettings); //ignore error
iClosePending = ETrue;
QueIdleTimerEntry();
}
void CLinkMgrProtocol::Open()
/**
Open LinkMgr protocol.
Called everytime a new client (of LinkMgr) wants to use it.
**/
{
LOG_FUNC
LocalOpen();
if(iExternalRef++ == 0)
{
ExternalOpenInit();
}
}
void CLinkMgrProtocol::Close()
{
LOG_FUNC
if(--iExternalRef == 0)
{
ExternalCloseCleanup();
}
LocalClose();
}
void CLinkMgrProtocol::LocalOpen()
{
LOG_FUNC
iClosePending = EFalse;
RemoveIdleTimerEntry();
CProtocolBase::Open();
}
void CLinkMgrProtocol::LocalClose()
{
LOG_FUNC
CProtocolBase::Close();
}
void CLinkMgrProtocol::ExternalOpenInit()
{
LOG_FUNC
TRAP_IGNORE(iLocalNamePublisher = CEirPublisherLocalName::NewL(*iEirManServer));
TRAP_IGNORE(iTxPowerLevelPublisher = CEirPublisherTxPowerLevel::NewL(*iEirManServer));
if(iLocalNamePublisher)
{
// Publish the initial name.
iLocalNamePublisher->UpdateName(iLocalDeviceSettings.DeviceName());
}
}
void CLinkMgrProtocol::ExternalCloseCleanup()
{
LOG_FUNC
// Currently just the internal publishers
delete iLocalNamePublisher;
iLocalNamePublisher = NULL;
delete iTxPowerLevelPublisher;
iTxPowerLevelPublisher = NULL;
}
void CLinkMgrProtocol::QueIdleTimerEntry()
/**
Queue idle timer entry.
When this timer expires, it'll call TryToClose, which actually
causes the thing to finally close down.
**/
{
LOG_FUNC
RemoveIdleTimerEntry();
iIdleEntryQueued = ETrue;
BTSocketTimer::Queue(KLinkMgrProtocolIdleTimer, iIdleTimerEntry);
}
void CLinkMgrProtocol::RemoveIdleTimerEntry()
/**
Called whenever we're opened.
Checks there are no idle timer entries queued.
**/
{
LOG_FUNC
if (!iIdleEntryQueued)
return;
BTSocketTimer::Remove(iIdleTimerEntry);
iIdleEntryQueued = EFalse;
}
/*static*/ TInt CLinkMgrProtocol::TryToClose(TAny* aProtocol)
/**
Actually try to close the protocol.
Called after the idle timeout period by the BTSocketTimer. If
we're all set to close down, the thing is closed.
**/
{
LOG_STATIC_FUNC
CLinkMgrProtocol* p=static_cast<CLinkMgrProtocol*>(aProtocol);
p->iIdleEntryQueued = EFalse;
if (p->iClosePending)
{
p->CanClose(); // deletes this
}
return EFalse;
}
CServProviderBase* CLinkMgrProtocol::NewSAPL(TUint aSockType)
/**
Create a new SAP.
The SAP returned is owned by the caller -- this protocol will not clean it up.
esock uses this function to create a new SAP, and esock will delete when it
is finished with it.
**/
{
LOG_FUNC
CServProviderBase* sap = NULL;
switch (aSockType)
{
case KSockBluetoothTypeESCO:
{
sap = CeSCOLink::NewL(*iPhysicalLinksMgr, NULL);
break;
}
case KSockBluetoothTypeSCO:
{
sap = CSCOLink::NewL(*iPhysicalLinksMgr, NULL);
break;
}
case KSockBluetoothTypeACL:
{
// an explicit ACL link has been asked for (by L2CAP)
sap = CACLLink::NewL(*iPhysicalLinksMgr, NULL, *this); // don't know for which PHY at this stage
break;
}
case KSockBluetoothTypeVendorSpecific:
{
if (!iVendorSpecificSAP)
{
sap = CVendorSAP::NewL(*this);
}
else
{
User::Leave(KErrInUse); // only support one :o)
}
break;
}
case KSockBluetoothTypeRawBroadcast:
default:
{
__ASSERT_DEBUG((aSockType > KHCIMinimumHandle && aSockType < KHCIMaximumHandle)||(aSockType==KSockBluetoothTypeRawBroadcast), Panic(EBTProxySAPInvalidCreate));
// if the connection handle has been specified - find the connection: aSockType *is* a ConnectionHandle in this case
CPhysicalLink* phySAP = NULL;
if (aSockType!=KSockBluetoothTypeRawBroadcast)
{
// it's a proxy sap which we should try to bind to the PHY
//
phySAP = iPhysicalLinksMgr->FindPhysicalLink(static_cast<THCIConnHandle>(aSockType));
}
// create Proxy telling it the possible PHY
CBTProxySAP* proxySAP = CBTProxySAP::NewLC(*iPhysicalLinksMgr, phySAP);
CleanupStack::Pop(proxySAP);
sap = proxySAP;
}
}
ASSERT_DEBUG(sap);
return sap;
}
TBTDevHCIVersion CLinkMgrProtocol::GetHWHCIVersion() const
{
LOG_FUNC
return iHWHCIVersion;
}
void CLinkMgrProtocol::SetLocalVersion(THCIErrorCode aErr, TBTDevHCIVersion aHCIVersion, TBTDevLMPVersion aLMPVersion)
{
LOG_FUNC
// we store this for possibly useful later use :-)
if (aErr == EOK)
{
iHWHCIVersion = aHCIVersion; // not especially useful for us: but maybe to exploit >BT1.1
iHWLMPVersion = aLMPVersion; // the LM in the HC ;-)
}
}
void CLinkMgrProtocol::SetOverrideLPMTimeout(TUint aOverrideLPMTimeout)
{
LOG_FUNC
iOverrideLPMTimeout =aOverrideLPMTimeout;
}
TInt CLinkMgrProtocol::StartProtocolListening()
{
LOG_FUNC
return KickDiscoverabilitySubscriber();
}
// oh Dear! void again, how to report failure...
void CLinkMgrProtocol::StopProtocolListening()
{
LOG_FUNC
// NB. If 'KickDiscoverabilitySubscriber' returns an error, then
// we've tried to get the value for ScanStatus, but we've failed.
// Not a lot we can do about it. This means that we may be
// leaving inquiry and page scan enabled with no listeners.
(void)KickDiscoverabilitySubscriber();
}
TInt CLinkMgrProtocol::KickDiscoverabilitySubscriber()
{
/*
Reset P&S with its current value. This will kick
CDiscoverabilitySubscriber's RunL which calls
SetInquiryAndPageScanningL to check for the current
user wishes AND the existance of listeners before
sending the appropriate WriteScanEnable command to
the controller.
*/
LOG_FUNC
TInt scanVal;
TInt err = iProperty.Get(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetScanningStatus, scanVal);
if (err != KErrNone)
{
return err;
}
THCIScanEnable scan = static_cast<THCIScanEnable>(scanVal);
// force CDiscoverabilitySubscriber to try to enable Page and Inquiry scan to HW, when set
(void)(iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetScanningStatus,
scan));
return err;
}
void CLinkMgrProtocol::LocalSupportedFeaturesAvailable()
{
// Set options based on the features
iInquiryMgr->SetInquiryMode();
iEirManServer->NotifyFeaturesReady();
}
void CLinkMgrProtocol::SetLocalFeatures(THCIErrorCode aErr, const TBTFeatures& aMask)
{
LOG_FUNC
if (aErr == EOK)
{
// we store this for possibly useful later use :-)
iHWFeatures = aMask;
}
// else ignore for now...
iEirManServer->NotifyFeaturesReady();
}
void CLinkMgrProtocol::SetLocalCommands(THCIErrorCode aErr, const TBluetoothHciCommands& aMask)
{
LOG_FUNC
if (aErr == EOK)
{
// we store this for possibly useful later use :-)
iHWCommands = aMask;
}
// else ignore for now...
}
void CLinkMgrProtocol::SetInquiryAndPageScanningL()
{
LOG_FUNC
TInt requestedScanVal = 0; // no Inquiry or Page Scanning as default
TInt err = iProperty.Get(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothSetScanningStatus,
requestedScanVal
);
THCIScanEnable requestedScanSetting;
if (!err)
{
requestedScanSetting = static_cast<THCIScanEnable>(requestedScanVal);
}
else
{
// If err == KErrNotFound, we have not published this property yet, but in all error cases
// we will use the current device setting to define the scanning requirements instead.
requestedScanSetting = iLocalDeviceSettings.ScanEnable();
}
// we need to check to see if we have any listeners before we can enable page & inquiry scan
THCIScanEnable validScanSetting;
if(!IsListening() || (requestedScanSetting == EInquiryScanOnly))
{
validScanSetting = ENoScansEnabled;
}
else
{
validScanSetting = requestedScanSetting;
}
iPendingLocalDeviceSettings.SetScanEnable(validScanSetting);
iHCIFacade->WriteScanEnableL(iPendingLocalDeviceSettings.ScanEnable());
if (!err)
{
// Update registry with the requested settings from the _set_ key
iLocalDeviceSettings.SetScanEnable(static_cast<THCIScanEnable>(requestedScanVal));
UpdateSettings();
}
}
void CLinkMgrProtocol::SetAcceptPairedOnlyMode(TBool aOn)
/*
THIS WORKS DIFFERENTLY: It does not involve the controller - it is
purely a stack setting. It is called directly when the user requests
the stack value to be reset.
*/
{
LOG_FUNC
iLocalDeviceSettings.SetAcceptPairedOnlyMode(aOn);
//update UI
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetAcceptPairedOnlyMode,
iLocalDeviceSettings.AcceptPairedOnlyMode()
);
UpdateSettings();
}
void CLinkMgrProtocol::SetSimplePairingDebugMode(TBool aOn)
/*
THIS WORKS DIFFERENTLY: It does not involve the controller - it is
purely a stack setting.
*/
{
LOG_FUNC
//update UI
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetSimplePairingDebugMode,
aOn
);
}
void CLinkMgrProtocol::SetDeviceClassL(TUint32 aCoD)
{
LOG_FUNC
// This method is called from Subscribers when the P&S is used to write a new CoD
TInt err = KErrNone;
err = CodMan().PandSCodHandler(aCoD); // Cod Service Manager will decide what gets written
User::LeaveIfError(err); // P&S CoD failed to write, but at least Codman has a record of it
}
void CLinkMgrProtocol::WriteClassOfDeviceL(TUint32 aCoD)
{
LOG_FUNC
// Only write the CoD bits if they have changed from the existing setting
if (iPendingLocalDeviceSettings.DeviceClass() != aCoD)
{
TRAPD(err, iHCIFacade->WriteDeviceClassL(aCoD));
if (err == KErrNone)
{
iPendingLocalDeviceSettings.SetDeviceClass(aCoD);
}
else
{
/* If the function errors, it is probably becuase the power is off, so we'll save the setting for power on
If the error is for a different reason, setting this doesn't do any harm anyway - it will get picked
up the next time the power is turned on */
iDesiredLocalDeviceSettings.SetDeviceClass(aCoD);
User::Leave(err);
}
}
}
TInt CLinkMgrProtocol::SetLocalDeviceName(const TDesC8& aName)
{
LOG_FUNC
// We trap this HCI command and not the others in Set... to keep the
// error path up to CBTHostResolver::SetHostName
TRAPD(err, iHCIFacade->WriteLocalNameL(aName));
if (err == KErrNone)
{
iPendingLocalDeviceSettings.SetDeviceName(aName);
}
else
{
/* If the function leaves, it is probably becuase the power is off, so we'll save the setting for power on
If the leave is for a different reason, setting this doesn't do any harm anyway - it will get picked
up the next time the power is turned on */
iDesiredLocalDeviceSettings.SetDeviceName(aName);
}
return err;
}
void CLinkMgrProtocol::SetAFHHostChannelClassificationL(const TBTAFHHostChannelClassification& aChannelClassification)
{
LOG_FUNC
iHCIFacade->SetAFHHostChannelClassificationL(aChannelClassification);
}
void CLinkMgrProtocol::SetAFHChannelAssessmentModeL(TBool aMode)
{
LOG_FUNC
TRAPD(err, iHCIFacade->WriteAFHChannelAssessmentModeL(aMode));
if (err == KErrNone)
{
iPendingLocalDeviceSettings.SetAFHChannelAssessmentMode(aMode);
}
else
{
/* If the function leaves, it is probably becuase the power is off, so we'll save the setting for power on
If the leave is for a different reason, setting this doesn't do any harm anyway - it will get picked
up the next time the power is turned on */
iDesiredLocalDeviceSettings.SetAFHChannelAssessmentMode(aMode);
User::Leave(err);
}
}
void CLinkMgrProtocol::SetLimitedDiscoverableIfChangedL(TBool aOn)
{
LOG_FUNC
// Set limited discoverable if value differs from cached (= registry) value
// and previous change going the opposite way is not pending completion
// See also DoSetLimitedDiscoverableL
if ((aOn == iLocalDeviceSettings.LimitedDiscoverable()) &&
(iPendingLocalDeviceSettings.LimitedDiscoverable() == iLocalDeviceSettings.LimitedDiscoverable()))
return;
DoSetLimitedDiscoverableL(aOn);
}
void CLinkMgrProtocol::DoSetLimitedDiscoverableL(TBool aOn)
{
LOG_FUNC
// HCI spec says we can always send >1 IAC! Controllers will take first
// so we can do what GAP says easily
TUint8 numIACs =0;
TUint iacs[2];
if (aOn)
{
// turn on LIAC
TRAPD(err, WriteClassOfDeviceL(iPendingLocalDeviceSettings.DeviceClass() | (EMajorServiceLimitedDiscoverableMode <<
(KLengthOfDeviceClass+KStartingOffsetOfDeviceClass))));
if (err == KErrNone)
{
iPendingLocalDeviceSettings.SetLimitedDiscoverable(ETrue);
}
else
{
/* If the function leaves, it is probably becuase the power is off, so we'll save the setting for power on
If the leave is for a different reason, setting this doesn't do any harm anyway - it will get picked
up the next time the power is turned on */
iDesiredLocalDeviceSettings.SetLimitedDiscoverable(ETrue);
User::Leave(err);
}
numIACs = 2;
iacs[0] = KLIAC;
iacs[1] = KGIAC;
}
else
{
// turn off LIAC - could do the 1 minute GAP timer?
TRAPD(err, WriteClassOfDeviceL(iPendingLocalDeviceSettings.DeviceClass() & ~(EMajorServiceLimitedDiscoverableMode <<
(KLengthOfDeviceClass+KStartingOffsetOfDeviceClass))));
if (err == KErrNone)
{
iPendingLocalDeviceSettings.SetLimitedDiscoverable(EFalse);
}
else
{
/* If the function leaves, it is probably becuase the power is off, so we'll save the setting for power on
If the leave is for a different reason, setting this doesn't do any harm anyway - it will get picked
up the next time the power is turned on */
iDesiredLocalDeviceSettings.SetLimitedDiscoverable(EFalse);
User::Leave(err);
}
numIACs = 1;
iacs[0] = KGIAC;
}
iHCIFacade->WriteIACLAPL(numIACs, iacs);
}
void CLinkMgrProtocol::UpdateLocalDevicePower(TBTPowerState aState)
{
LOG_FUNC
iLocalDeviceSettings.SetPowerSetting(static_cast<TUint8>(aState));
UpdateSettings();
}
// This is an update method for dealing with the result of asking what the device
// name is. It is used to keep iLocalDeviceSettings.DeviceName(), the P&S device
// name value and the h/w value in sync
void CLinkMgrProtocol::UpdateLocalDeviceName(const TDesC8& aName)
{
LOG_FUNC
iLocalDeviceSettings.SetDeviceName(aName);
// Update the UI with the unicode DeviceName
TBuf16<KHCILocalDeviceNameMaxLength> unicodeName;
(void) CnvUtfConverter::ConvertToUnicodeFromUtf8(unicodeName, iLocalDeviceSettings.DeviceName());
// The return from the above should never be > 0 since aName should have a length <= KHCILocalDeviceNameMaxLength
// hence we shouldn't have any unconverted chars left over. If we get another error then we just have to publish
// the resulting unicode name anyway.
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetDeviceName,
unicodeName
);
UpdateSettings();
}
// This is an update method for dealing with the result of telling the h/w what the device
// name should be. It is used to keep iLocalDeviceSettings.DeviceName(), the P&S device
// name value and the h/w value in sync
void CLinkMgrProtocol::UpdateLocalDeviceName(TBool aSucceeded)
{
LOG_FUNC
if (aSucceeded)
{
TBool isDifferentName =
(iLocalDeviceSettings.DeviceName() != iPendingLocalDeviceSettings.DeviceName());
iLocalDeviceSettings.SetDeviceName(iPendingLocalDeviceSettings.DeviceName());
if(iLocalNamePublisher && isDifferentName)
{
iLocalNamePublisher->UpdateName(iLocalDeviceSettings.DeviceName());
}
}
// Update the UI with the unicode DeviceName
TBuf16<KHCILocalDeviceNameMaxLength> unicodeName;
(void) CnvUtfConverter::ConvertToUnicodeFromUtf8(unicodeName, iLocalDeviceSettings.DeviceName());
// The return from the above should never be > 0 since unicodeName is the same size as utf8Name
// hence we shouldn't have any unconverted chars left over. Similarly ret should not be < 0
// because when we received DeviceName in Unicode we where able to convert it to UTF-8
// without a problem so reversing the conversion should be okay.
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetDeviceName,
unicodeName
);
UpdateSettings();
}
void CLinkMgrProtocol::UpdateLocalDeviceScanEnable(TBool aSucceeded)
{
LOG_FUNC
TInt scan;
TInt err = KErrNone;
// Set scan to be the actual scan enable state of the hardware
if(aSucceeded)
{
// We've set it to the value in iLocalDeviceSettings
scan = iPendingLocalDeviceSettings.ScanEnable();
}
else
{
// We haven't changed it, current value is in the _get_ key
err = iProperty.Get(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetScanningStatus,
scan);
}
if(!err)
{
//update UI with the hardware's settings using the _get_ key
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetScanningStatus,
scan
);
}
}
void CLinkMgrProtocol::UpdateLimitedDiscoverable(TBool aSucceeded)
{
LOG_FUNC
if (aSucceeded)
{
iLocalDeviceSettings.SetLimitedDiscoverable(
iPendingLocalDeviceSettings.LimitedDiscoverable());
}
//update UI
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetLimitedDiscoverableStatus,
iLocalDeviceSettings.LimitedDiscoverable()
);
UpdateSettings();
}
void CLinkMgrProtocol::UpdateDeviceClass(TBool aSucceeded)
{
LOG_FUNC
if (aSucceeded)
{
iLocalDeviceSettings.SetDeviceClass(
iPendingLocalDeviceSettings.DeviceClass());
}
//update UI
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetDeviceClass,
iLocalDeviceSettings.DeviceClass()
);
UpdateSettings();
}
void CLinkMgrProtocol::UpdateDeviceClass(TBool aSucceeded, TUint aCoD)
{
LOG_FUNC
if (aSucceeded)
{
iLocalDeviceSettings.SetDeviceClass(aCoD);
//update UI
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetDeviceClass,
aCoD
);
UpdateSettings();
}
}
void CLinkMgrProtocol::UpdateAFHChannelAssessmentMode(TBool aSucceeded)
{
LOG_FUNC
if (aSucceeded)
{
iLocalDeviceSettings.SetAFHChannelAssessmentMode(
iPendingLocalDeviceSettings.AFHChannelAssessmentMode());
}
UpdateSettings();
}
void CLinkMgrProtocol::UpdateSettings()
{
LOG_FUNC
//Careful! - we new'd it without ELeave
if (iRegistryUpdater)
{
iRegistryUpdater->Update();
}
}
void CLinkMgrProtocol::UpdateInquiryResponseTxPowerLevel(TInt8 aTxPowerLevel)
{
LOG_FUNC
if(iTxPowerLevelPublisher)
{
iTxPowerLevelPublisher->UpdateTxPowerLevel(aTxPowerLevel);
}
}
void CLinkMgrProtocol::SetUIConnecting(TBool aConnecting)
{
LOG_FUNC
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetConnectingStatus,
aConnecting);
}
void CLinkMgrProtocol::SetUINumPhysicalLinks(TUint aNum)
{
LOG_FUNC
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetPHYCount,
aNum);
}
void CLinkMgrProtocol::SetLocalBTAddress(const TBTDevAddr& aAddr)
{
LOG_FUNC
iLocalDeviceAddress = aAddr;
// Also update registry with local device address
iLocalDeviceSettings.SetAddress(iLocalDeviceAddress);
UpdateSettings();
// publish this number - might be useful
const TDesC8& des = aAddr.Des();
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothGetLocalDeviceAddress,
des);
}
void CLinkMgrProtocol::SetUIDiscovering(TInt aDiscoveringState)
{
LOG_FUNC
(void)iProperty.Set(KPropertyUidBluetoothCategory,
KPropertyKeyBluetoothHostResolverActive,
aDiscoveringState);
}
TInt CLinkMgrProtocol::ACLPacketMTU() const
{
LOG_FUNC
return iLinkMuxer->ACLPacketMTU();
}
TInt CLinkMgrProtocol::ControlPlaneMessage(TBTControlPlaneMessage aMessage, TAny* aParam)
{
LOG_FUNC
TInt rerr = KErrNotFound;
CPhysicalLink* con = NULL;
if ((aMessage == ESubscribePhysicalLink) || (aMessage == EUnsubscribePhysicalLink))
{
TPhysicalLinkSubscriptionInfo& subscriptionInfo = *reinterpret_cast<TPhysicalLinkSubscriptionInfo*>(aParam);
con = iPhysicalLinksMgr->FindPhysicalLink(subscriptionInfo.iAddr);
}
else if ((aMessage == ETryToAndThenPreventHostEncryptionKeyRefresh))
{
// For EPreventAutoEncryptionKeyRefresh we pass the address as a TBTDevAddr**
const TBTDevAddr& addr = **reinterpret_cast<const TBTDevAddr**>(aParam);
con = iPhysicalLinksMgr->FindPhysicalLink(addr);
}
else
{
const TBTDevAddr& addr = *reinterpret_cast<const TBTDevAddr*>(aParam);
con = iPhysicalLinksMgr->FindPhysicalLink(addr);
}
if (con)
{
switch (aMessage)
{
case EOverridePark:
rerr = con->OverridePark();
break;
case EUndoOverridePark:
rerr = con->UndoOverridePark();
break;
case EOverrideLPMWithTimeout:
rerr = con->OverrideLPMWithTimeout(iOverrideLPMTimeout);
break;
case EOverrideLPM:
rerr = con->OverrideLPM();
break;
case EUndoOverrideLPM:
rerr = con->UndoOverrideLPM();
break;
case ESubscribePhysicalLink:
{
const TPhysicalLinkSubscriptionInfo& subscriptionInfo = *reinterpret_cast<TPhysicalLinkSubscriptionInfo*>(aParam);
con->SubscribeLinkObserver(subscriptionInfo.iMPhysicalLinkObserver);
break;
}
case EUnsubscribePhysicalLink:
{
const TPhysicalLinkSubscriptionInfo& subscriptionInfo = *reinterpret_cast<TPhysicalLinkSubscriptionInfo*>(aParam);
con->UnsubscribeLinkObserver(subscriptionInfo.iMPhysicalLinkObserver);
break;
}
case ETryToAndThenPreventHostEncryptionKeyRefresh:
{
rerr = con->TryToAndThenPreventHostEncryptionKeyRefresh(aParam);
break;
}
default:
rerr = KErrNotSupported;
break;
};
}
return rerr;
}
void CLinkMgrProtocol::ClearPendingLocalDeviceSettingsCod()
{
LOG_FUNC
// If we know that the h/w has been reset, then we need to ensure that our persistent
// value reflects this. That way we will force the CoD re-write to the hardware.
iPendingLocalDeviceSettings.SetDeviceClass(KDeviceClassReset);
}
void CLinkMgrProtocol::SetPageScanParameters(TPageScanParameterSettings aPageScanParameters)
{
LOG_FUNC
iBrEdrControllerConfiguration->SetPageScanParameters(aPageScanParameters);
}
//
// CRegistrySession
//
CRegistrySession* CRegistrySession::NewL(CLinkMgrProtocol& aLinkMgrProtocol)
{
LOG_STATIC_FUNC
CRegistrySession* self = new(ELeave) CRegistrySession(aLinkMgrProtocol);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
void CRegistrySession::Open()
{
LOG_FUNC
if(iAccessCount++ == 0)
{
iLinkMgrProtocol.LocalOpen();
}
}
void CRegistrySession::Close()
{
LOG_FUNC
__ASSERT_DEBUG(iAccessCount > 0, Panic(ERegistrySessionClosedTooManyTimes));
if(--iAccessCount == 0)
{
iLinkMgrProtocol.LocalClose();
}
}
CRegistrySession::CRegistrySession(CLinkMgrProtocol& aLinkMgrProtocol)
: CBase()
, iAccessCount(0)
, iLinkMgrProtocol(aLinkMgrProtocol)
{
LOG_FUNC
}
void CRegistrySession::ConstructL()
{
LOG_FUNC
User::LeaveIfError(iRegServ.Connect());
}
CRegistrySession::~CRegistrySession()
{
LOG_FUNC
__ASSERT_DEBUG(iAccessCount == 0, Panic(ERegistrySessionDeletedWhenOpen));
iRegServ.Close();
}
RBTRegServ& CRegistrySession::RegServ()
{
LOG_FUNC
return iRegServ;
}
//class CRegistryUpdater
CRegistryUpdater::~CRegistryUpdater()
{
LOG_FUNC
Cancel();
}
CRegistryUpdater::CRegistryUpdater(RBTLocalDevice& aLocalDevice,TBTTrackedLocalDevice& aSettings) :
CActive(CActive::EPriorityStandard),iLocalDevice(aLocalDevice),iStackSettings(aSettings),iRepeatUpdate(EFalse)
{
LOG_FUNC
CActiveScheduler::Add(this);
}
void CRegistryUpdater::Update()
{
LOG_FUNC
__ASSERT_DEBUG(iLocalDevice.SubSessionHandle(), Panic(ELocalDeviceBadHandle));
if (!IsActive())
{
TInt err;
err = iLocalDevice.Get(iRegistrySettings);
// if we can't get settings from registry, we won't be able to update them
if ( err == KErrNone )
{
iStackSettings.Modify(iRegistrySettings);
iStackSettings.ResetChangesMask();
iLocalDevice.Modify(iRegistrySettings,iStatus);
SetActive();
iRepeatUpdate = EFalse;
}
}
else
{
// Even if multiple requests come in while this object is active we only need to
// perform one update since iLocalDevice will accumulated required new settings.
LOG(_L(" -- CRegistryUpdaterAO already active so will repeat the update later."));
iRepeatUpdate = ETrue;
}
}
void CRegistryUpdater::RunL()
{
LOG_FUNC
if (iRepeatUpdate)
{
Update();
}
}
void CRegistryUpdater::DoCancel()
{
LOG_FUNC
iLocalDevice.CancelRequest(iStatus);
iRepeatUpdate = EFalse;
}
//class TBTTrackedLocalDevice
void TBTTrackedLocalDevice::SetAddress(const TBTDevAddr& aAddr)
{
LOG_FUNC
if (aAddr != Address())
{
TBTLocalDevice::SetAddress(aAddr);
StoreChange(EAddress);
}
}
void TBTTrackedLocalDevice::SetDeviceClass(TUint32 aCod)
{
LOG_FUNC
if (aCod != DeviceClass())
{
TBTLocalDevice::SetDeviceClass(aCod);
StoreChange(ECoD);
}
}
void TBTTrackedLocalDevice::SetDeviceName(const TDesC8& aName)
{
LOG_FUNC
if (aName != DeviceName())
{
TBTLocalDevice::SetDeviceName(aName);
StoreChange(EDeviceName);
}
}
void TBTTrackedLocalDevice::SetScanEnable(THCIScanEnable aEnable)
{
LOG_FUNC
if (aEnable != ScanEnable())
{
TBTLocalDevice::SetScanEnable(aEnable);
StoreChange(EScanEnable);
}
}
void TBTTrackedLocalDevice::SetLimitedDiscoverable(TBool aOn)
{
LOG_FUNC
if (aOn != LimitedDiscoverable())
{
TBTLocalDevice::SetLimitedDiscoverable(aOn);
StoreChange(ELimitedDiscoverable);
}
}
void TBTTrackedLocalDevice::SetPowerSetting(TUint8 aPowerSetting)
{
LOG_FUNC
if (aPowerSetting != PowerSetting())
{
TBTLocalDevice::SetPowerSetting(aPowerSetting);
StoreChange(EPowerSetting);
}
}
void TBTTrackedLocalDevice::SetAFHChannelAssessmentMode(TBool aOn)
{
LOG_FUNC
if (aOn != AFHChannelAssessmentMode())
{
TBTLocalDevice::SetAFHChannelAssessmentMode(aOn);
StoreChange(EAFHChannelAssessmentMode);
}
}
void TBTTrackedLocalDevice::SetAcceptPairedOnlyMode(TBool aOn)
{
LOG_FUNC
if (aOn != AcceptPairedOnlyMode())
{
TBTLocalDevice::SetAcceptPairedOnlyMode(aOn);
StoreChange(EAcceptPairedOnlyMode);
}
}
void TBTTrackedLocalDevice::StoreChange(TUint8 aChange)
{
LOG_FUNC
iChangedSettings |= aChange;
}
void TBTTrackedLocalDevice::ResetChangesMask()
{
LOG_FUNC
iChangedSettings = 0;
}
void TBTTrackedLocalDevice::Modify(TBTLocalDevice& aLocalDeviceSettings)
{
LOG_FUNC
if ( iChangedSettings & EAddress )
{
aLocalDeviceSettings.SetAddress(Address());
}
if ( iChangedSettings & ECoD )
{
aLocalDeviceSettings.SetDeviceClass(DeviceClass());
}
if ( iChangedSettings & EDeviceName )
{
aLocalDeviceSettings.SetDeviceName(DeviceName());
}
if ( iChangedSettings & EPowerSetting )
{
aLocalDeviceSettings.SetPowerSetting(PowerSetting());
}
if ( iChangedSettings & EScanEnable )
{
aLocalDeviceSettings.SetScanEnable(ScanEnable());
}
if ( iChangedSettings & ELimitedDiscoverable )
{
aLocalDeviceSettings.SetLimitedDiscoverable(LimitedDiscoverable());
}
if ( iChangedSettings & EAFHChannelAssessmentMode )
{
aLocalDeviceSettings.SetAFHChannelAssessmentMode(AFHChannelAssessmentMode());
}
if ( iChangedSettings & EAcceptPairedOnlyMode )
{
aLocalDeviceSettings.SetAcceptPairedOnlyMode(AcceptPairedOnlyMode());
}
}