Bluetooth: mac: add connected BLE devices at startup

device/bluetooth/bluetooth_adapter_mac.mm

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "device/bluetooth/bluetooth_adapter_mac.h"
 
 #import <IOBluetooth/objc/IOBluetoothDevice.h>
 #import <IOBluetooth/objc/IOBluetoothHostController.h>
 #include <stddef.h>
 
@@ skipping 13 matching lines @@
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "device/bluetooth/bluetooth_classic_device_mac.h"
 #include "device/bluetooth/bluetooth_common.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "device/bluetooth/bluetooth_low_energy_central_manager_delegate.h"
 #include "device/bluetooth/bluetooth_socket_mac.h"
 
+@interface CBCentralManager (PartialAvailability)

[ortuno, 2016/08/15 23:58:09]

This doesn't seem to be a pattern we follow through the code base?

[jracle (use Gerrit), 2016/08/16 20:14:17]

Actually, I think I've got it from a landed CL, but I'm not sure (that's
holidays downside!)..
Anyway it needs at least a couple of comments in code here.. 
Also if I can be pointed to the correct way to handle that'd be awesome!

[jlebel, 2016/08/31 12:03:28]

I think you can just #import <CoreBluetooth/CoreBluetooth.h> or did I miss
something?

[jracle (use Gerrit), 2016/08/31 17:21:22]

Indeed, as you state in other comment, that's a partial method.

Sorry for the late reply.

+
+- (NSArray<CBPeripheral*>*)retrieveConnectedPeripheralsWithServices:
+    (NSArray<CBUUID*>*)serviceUUIDs;
+
+@end
+
 namespace {
 
 // The frequency with which to poll the adapter for updates.
 const int kPollIntervalMs = 500;
 
 }  // namespace
 
 namespace device {
 
 // static
@@ skipping 324 matching lines @@
     // Begin a low energy discovery session or update it if one is already
     // running.
     if (IsLowEnergyAvailable())
       low_energy_discovery_manager_->StartDiscovery(
           BluetoothDevice::UUIDList());
   }
   return true;
 }
 
 void BluetoothAdapterMac::Init() {
+  if (IsLowEnergyAvailable())
+    AddConnectedLowEnergyDevices();
   ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   PollAdapter();
 }
 
 void BluetoothAdapterMac::InitForTest(
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner) {
   ui_task_runner_ = ui_task_runner;
 }
 
 void BluetoothAdapterMac::PollAdapter() {
@@ skipping 56 matching lines @@
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile5(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "461181 BluetoothAdapterMac::PollAdapter::RemoveTimedOutDevices"));
   RemoveTimedOutDevices();
 
   // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/461181
   // is fixed.
   tracked_objects::ScopedTracker tracking_profile6(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "461181 BluetoothAdapterMac::PollAdapter::AddPairedDevices"));
-  AddPairedDevices();
+          "461181 BluetoothAdapterMac::PollAdapter::AddPairedClassicDevices"));
+  AddPairedClassicDevices();
 
   ui_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&BluetoothAdapterMac::PollAdapter,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kPollIntervalMs));
 }
 
 void BluetoothAdapterMac::ClassicDeviceAdded(IOBluetoothDevice* device) {
   std::string device_address =
@@ skipping 50 matching lines @@
   VLOG(2) << "LowEnergyDeviceUpdated";
   device_mac->Update(advertisement_data, rssi);
   // TODO(scheib): Call DeviceChanged only if UUIDs change. crbug.com/547106
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                     DeviceChanged(this, device_mac));
 }
 
 // TODO(krstnmnlsn): Implement. crbug.com/511025
 void BluetoothAdapterMac::LowEnergyCentralManagerUpdatedState() {}
 
-void BluetoothAdapterMac::AddPairedDevices() {
-  // Add any new paired devices.
+void BluetoothAdapterMac::AddPairedClassicDevices() {
   for (IOBluetoothDevice* device in [IOBluetoothDevice pairedDevices]) {
-    ClassicDeviceAdded(device);
+    IOBluetoothSDPServiceRecord* pnp_information =
+        [device getServiceRecordForUUID:
+                    [IOBluetoothSDPUUID
+                        uuid16:kBluetoothSDPUUID16ServiceClassPnPInformation]];
+
+    // IOBluetoothDevice instance is a Bluetooth Classic device if it has a PNP

[ortuno, 2016/08/15 23:58:09]

Could you add a link to some documentation that states that this is always true
for Classic devices and false for Low Energy Devices?

[jracle (use Gerrit), 2016/08/16 20:14:17]

I need to cross-check with Logitech guys who pointed me to this logic.
Just did a quick test with a couple of devices.
I'll get back to commenting it when I have such data.

[jracle (use Gerrit), 2016/08/17 21:21:15]

While checking for official documentation, here is a link
(https://epxx.co/artigos/bluetooth_gatt.html) that explains what I thought : SDP
is required only for BR-EDR and dual-mode devices. It is not needed for LE
devices, cause ATT protocol replaces it.

Yet, another solution would be to match information from IOBluetoothDevice
(IOKit) and CBPeripheral (CoreBluetooth). This requires redesigning codebase +
matching those entities.

+    // information service SDP entry.
+    if (pnp_information) {
+      ClassicDeviceAdded(device);
+    }
   }
 }
 
+void BluetoothAdapterMac::AddConnectedLowEnergyDevices() {
+  // Look for Device Information Service. BLE devices should advertise it.

[ortuno, 2016/08/15 23:58:09]

nit: Well if it's connected it's not really advertising anything :)

[jracle (use Gerrit), 2016/08/16 20:14:17]

Indeed.. does 'implement' look better? ("Most BLE devices should implement it")

+  CBUUID* device_information_uuid = [CBUUID UUIDWithString:@"180A"];
+
+  // This list of devices contain both devices that are connected by other apps
+  // or by system. In that case, user will need to connect peripheral using
+  // CBCentralManager's connectPeripheral:options: method.
+  NSArray<CBPeripheral*>* connected_peripherals = [low_energy_central_manager_
+      retrieveConnectedPeripheralsWithServices:@[ device_information_uuid ]];

[ortuno, 2016/08/15 23:58:09]

Just pass nil. There is no requirement that a device has that service and we
want to add all devices.

[jracle (use Gerrit), 2016/08/16 20:14:17]

Agree with you. Documentation says passing nil will return all connected
peripherals, but in practice this doesn't seem to work (at least I gonna
re-check). Hence I'm looking for DIS, which I also think is not compulsory (I'll
cross-check with the specialists here). In practice, most LE devices should
implement it.

+
+  for (CBPeripheral* peripheral in connected_peripherals) {
+    BluetoothLowEnergyDeviceMac* device_mac =
+        GetBluetoothLowEnergyDeviceMac(peripheral);
+
+    if (!device_mac) {
+      device_mac = new BluetoothLowEnergyDeviceMac(this, peripheral);
+      std::string device_address =
+          BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
+      devices_.add(device_address,
+                   std::unique_ptr<BluetoothDevice>(device_mac));
+      FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,

[ortuno, 2016/08/15 23:58:09]

We probably want to also start a service discovery for this device.

[jracle (use Gerrit), 2016/08/16 20:14:17]

I don't do it here, cause user will have to connect peripheral from API
(chrome.bluetoothLowEnergy or web-bluetooth), and services will be enumerated
upon connection success.

Connected peripherals returned here could have been connected by other apps or
by system. This list is actually a list of physically connected peripherals.
User App will have to check whether LE peripheral is (logically) connected (see
BluetoothLowEnergyDeviceMac::IsGattConnected()) before eventually connecting it
(see BluetoothAdapterMac::CreateGattConnection()). Upon connection, service
discovery will be done. See
BluetoothAdapterMac::DidConnectPeripheral(CBPeripheral* peripheral).

+                        DeviceAdded(this, device_mac));
+    }
+  }
+}
+
 void BluetoothAdapterMac::CreateGattConnection(
     BluetoothLowEnergyDeviceMac* device_mac) {
   [low_energy_central_manager_ connectPeripheral:device_mac->peripheral_
                                          options:nil];
 }
 
 void BluetoothAdapterMac::DisconnectGatt(
     BluetoothLowEnergyDeviceMac* device_mac) {
   [low_energy_central_manager_
       cancelPeripheralConnection:device_mac->peripheral_];
@@ skipping 48 matching lines @@
   std::string device_address =
       BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
   DevicesMap::const_iterator iter = devices_.find(device_address);
   if (iter == devices_.end()) {
     return nil;
   }
   return static_cast<BluetoothLowEnergyDeviceMac*>(iter->second);
 }
 
 }  // namespace device