MCL/sf/os/bt: comparison bluetooth/btstack/linkmgr/linkmgr.cpp

equal deleted inserted replaced

-:8a27654f7b62
+:20fda83a6398
-// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).
+// 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".
 #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"
 	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,	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;
 		// 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);
 		}
 		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
 	//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)
 							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,
 							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
 	{
 	LOG_FUNC
 	// Only write the CoD bits if they have changed from the existing setting
 	if (iPendingLocalDeviceSettings.DeviceClass() != aCoD)
 		{
-		iPendingLocalDeviceSettings.SetDeviceClass(aCoD);
+		TRAPD(err, iHCIFacade->WriteDeviceClassL(aCoD));
-		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)
 	{
 	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)
 	{
 	}
 void CLinkMgrProtocol::SetAFHChannelAssessmentModeL(TBool aMode)
 	{
 	LOG_FUNC
-	iPendingLocalDeviceSettings.SetAFHChannelAssessmentMode(aMode);
+	TRAPD(err, iHCIFacade->WriteAFHChannelAssessmentModeL(aMode));
-	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
 	TUint iacs[2];
 	if (aOn)
 		{
 		// turn on LIAC
-		iPendingLocalDeviceSettings.SetLimitedDiscoverable(ETrue);
+		TRAPD(err, WriteClassOfDeviceL(iPendingLocalDeviceSettings.DeviceClass() | (EMajorServiceLimitedDiscoverableMode <<
-		WriteClassOfDeviceL(iPendingLocalDeviceSettings.DeviceClass() | (EMajorServiceLimitedDiscoverableMode <<
+				(KLengthOfDeviceClass+KStartingOffsetOfDeviceClass))));
-				(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?
-		iPendingLocalDeviceSettings.SetLimitedDiscoverable(EFalse);
+		TRAPD(err, WriteClassOfDeviceL(iPendingLocalDeviceSettings.DeviceClass() & ~(EMajorServiceLimitedDiscoverableMode <<
-		WriteClassOfDeviceL(iPendingLocalDeviceSettings.DeviceClass() & ~(EMajorServiceLimitedDiscoverableMode <<
+				(KLengthOfDeviceClass+KStartingOffsetOfDeviceClass))));
-				(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::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,
 	// 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
 //
 RBTRegServ& CRegistrySession::RegServ()
 	{
 	LOG_FUNC
 	return iRegServ;
 	}
 //class CRegistryUpdater
 CRegistryUpdater::~CRegistryUpdater()
 	{
 //class TBTTrackedLocalDevice
 void TBTTrackedLocalDevice::SetAddress(const TBTDevAddr& aAddr)
 	{
 	LOG_FUNC
-	TBTLocalDevice::SetAddress(aAddr);
+	if (aAddr != Address())
-	StoreChange(EAddress);
+		{
+		TBTLocalDevice::SetAddress(aAddr);
+		StoreChange(EAddress);
+		}
 	}
 void TBTTrackedLocalDevice::SetDeviceClass(TUint32 aCod)
 	{
 	LOG_FUNC
-	TBTLocalDevice::SetDeviceClass(aCod);
+	if (aCod != DeviceClass())
-	StoreChange(ECoD);
+		{
+		TBTLocalDevice::SetDeviceClass(aCod);
+		StoreChange(ECoD);
+		}
 	}
 void TBTTrackedLocalDevice::SetDeviceName(const TDesC8& aName)
 	{
 	LOG_FUNC
-	TBTLocalDevice::SetDeviceName(aName);
+	if (aName != DeviceName())
-	StoreChange(EDeviceName);
+		{
+		TBTLocalDevice::SetDeviceName(aName);
+		StoreChange(EDeviceName);
+		}
 	}
 void TBTTrackedLocalDevice::SetScanEnable(THCIScanEnable aEnable)
 	{
 	LOG_FUNC
-	TBTLocalDevice::SetScanEnable(aEnable);
+	if (aEnable != ScanEnable())
-	StoreChange(EScanEnable);
+		{
+		TBTLocalDevice::SetScanEnable(aEnable);
+		StoreChange(EScanEnable);
+		}
 	}
 void TBTTrackedLocalDevice::SetLimitedDiscoverable(TBool aOn)
 	{
 	LOG_FUNC
-	TBTLocalDevice::SetLimitedDiscoverable(aOn);
+	if (aOn != LimitedDiscoverable())
-	StoreChange(ELimitedDiscoverable);
+		{
+		TBTLocalDevice::SetLimitedDiscoverable(aOn);
+		StoreChange(ELimitedDiscoverable);
+		}
 	}
 void TBTTrackedLocalDevice::SetPowerSetting(TUint8 aPowerSetting)
 	{
 	LOG_FUNC
-	TBTLocalDevice::SetPowerSetting(aPowerSetting);
+	if (aPowerSetting != PowerSetting())
-	StoreChange(EPowerSetting);
+		{
+		TBTLocalDevice::SetPowerSetting(aPowerSetting);
+		StoreChange(EPowerSetting);
+		}
 	}
 void TBTTrackedLocalDevice::SetAFHChannelAssessmentMode(TBool aOn)
 	{
 	LOG_FUNC
-	TBTLocalDevice::SetAFHChannelAssessmentMode(aOn);
+	if (aOn != AFHChannelAssessmentMode())
-	StoreChange(EAFHChannelAssessmentMode);
+		{
+		TBTLocalDevice::SetAFHChannelAssessmentMode(aOn);
+		StoreChange(EAFHChannelAssessmentMode);
+		}
 	}
 void TBTTrackedLocalDevice::SetAcceptPairedOnlyMode(TBool aOn)
 	{
 	LOG_FUNC
-	TBTLocalDevice::SetAcceptPairedOnlyMode(aOn);
+	if (aOn != AcceptPairedOnlyMode())
-	StoreChange(EAcceptPairedOnlyMode);
+		{
+		TBTLocalDevice::SetAcceptPairedOnlyMode(aOn);
+		StoreChange(EAcceptPairedOnlyMode);
+		}
 	}
 void TBTTrackedLocalDevice::StoreChange(TUint8 aChange)
 	{
 	LOG_FUNC

branch	RCL_3
changeset 11	20fda83a6398
parent 0	29b1cd4cb562
child 17	32ba20339036