bluetooth: mac: add connected LE devices to chooser

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 168 matching lines @@
 }
 
 bool BluetoothAdapterMac::IsDiscovering() const {
   bool is_discovering = classic_discovery_manager_->IsDiscovering();
   if (IsLowEnergyAvailable())
     is_discovering =
         is_discovering || low_energy_discovery_manager_->IsDiscovering();
   return is_discovering;
 }
 
+std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet>
+BluetoothAdapterMac::RetrieveGattConnectedDevicesWithDiscoveryFilter(
+    const BluetoothDiscoveryFilter& discovery_filter) {
+  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet>
+      connected_devices;
+  std::set<device::BluetoothUUID> uuids;
+  discovery_filter.GetUUIDs(uuids);
+  if (uuids.empty()) {
+    for (BluetoothDevice* device :
+         RetrieveGattConnectedDevicesWithService(nullptr)) {
+      connected_devices[device] = BluetoothDevice::UUIDSet();
+    }
+    return connected_devices;
+  }
+  for (const BluetoothUUID& uuid : uuids) {
+    for (BluetoothDevice* device :
+         RetrieveGattConnectedDevicesWithService(&uuid)) {
+      connected_devices[device].insert(uuid);
+    }
+  }
+  return connected_devices;
+}
+
 BluetoothAdapter::UUIDList BluetoothAdapterMac::GetUUIDs() const {
   NOTIMPLEMENTED();
   return UUIDList();
 }
 
 void BluetoothAdapterMac::CreateRfcommService(
     const BluetoothUUID& uuid,
     const ServiceOptions& options,
     const CreateServiceCallback& callback,
     const CreateServiceErrorCallback& error_callback) {
@@ skipping 293 matching lines @@
     int rssi) {
   BluetoothLowEnergyDeviceMac* device_mac =
       GetBluetoothLowEnergyDeviceMac(peripheral);
   // If has no entry in the map, create new device and insert into |devices_|,
   // otherwise update the existing device.
   const bool is_new_device = device_mac == nullptr;
   if (is_new_device) {
     VLOG(1) << "LowEnergyDeviceUpdated new device";
     // A new device has been found.
     device_mac = new BluetoothLowEnergyDeviceMac(this, peripheral);
-  } else {
-    // Check that there are no collisions.
-    std::string stored_device_id = device_mac->GetIdentifier();
-    std::string updated_device_id =
-        BluetoothLowEnergyDeviceMac::GetPeripheralIdentifier(peripheral);
-    if (stored_device_id != updated_device_id) {
-      VLOG(1)
-          << "LowEnergyDeviceUpdated stored_device_id != updated_device_id: "
-          << std::endl
-          << "  " << stored_device_id << std::endl
-          << "  " << updated_device_id;
-      // Collision, two identifiers map to the same hash address.  With a 48 bit
-      // hash the probability of this occuring with 10,000 devices
-      // simultaneously present is 1e-6 (see
-      // https://en.wikipedia.org/wiki/Birthday_problem#Probability_table).  We
-      // ignore the second device by returning.
-      return;
-    }
+  } else if (DoesCollideWithKnownDevice(peripheral, device_mac)) {
+    return;
   }
 
   DCHECK(device_mac);
 
   // Get Advertised UUIDs
   BluetoothDevice::UUIDList advertised_uuids;
   NSArray* service_uuids =
       [advertisement_data objectForKey:CBAdvertisementDataServiceUUIDsKey];
   for (CBUUID* uuid in service_uuids) {
     advertised_uuids.push_back(BluetoothUUID([[uuid UUIDString] UTF8String]));
@@ skipping 45 matching lines @@
   // Add any new paired devices.
   for (IOBluetoothDevice* device in [IOBluetoothDevice pairedDevices]) {
     // pairedDevices sometimes includes unknown devices that are not paired.
     // Radar issue with id 2282763004 has been filed about it.
     if ([device isPaired]) {
       ClassicDeviceAdded(device);
     }
   }
 }
 
+std::vector<BluetoothDevice*>
+BluetoothAdapterMac::RetrieveGattConnectedDevicesWithService(
+    const BluetoothUUID* uuid) {
+  NSArray* cbUUIDs = nil;
+  if (!uuid) {
+    // It is not possible to ask for all connected peripherals with
+    // -[CBCentralManager retrieveConnectedPeripheralsWithServices:] by passing
+    // nil. To try to get most of the peripherals, the search is done with
+    // Generic Access service.
+    CBUUID* genericAccessServiceUUID = [CBUUID UUIDWithString:@"1800"];
+    cbUUIDs = @[ genericAccessServiceUUID ];
+  } else {
+    NSString* uuidString =
+        base::SysUTF8ToNSString(uuid->canonical_value().c_str());
+    cbUUIDs = @[ [CBUUID UUIDWithString:uuidString] ];
+  }
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpartial-availability"

[ortuno, 2016/11/07 03:12:33]

nit: I think we can remove this now.

[jlebel, 2016/11/07 05:56:39]

Ah yes!

+  // Can remove ignore -Wpartial-availability when 10.8 will not be supported
+  // anymore.
+  // TODO(crbug.com/653056)
+  NSArray* peripherals = [low_energy_central_manager_
+      retrieveConnectedPeripheralsWithServices:cbUUIDs];
+#pragma clang diagnostic pop
+  std::vector<BluetoothDevice*> connected_devices;
+  for (CBPeripheral* peripheral in peripherals) {
+    BluetoothLowEnergyDeviceMac* device_mac =
+        GetBluetoothLowEnergyDeviceMac(peripheral);
+    const bool is_new_device = device_mac == nullptr;
+
+    if (!is_new_device && DoesCollideWithKnownDevice(peripheral, device_mac)) {
+      continue;
+    }
+    if (is_new_device) {
+      device_mac = new BluetoothLowEnergyDeviceMac(this, peripheral);
+      std::string device_address =
+          BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(peripheral);
+      devices_.add(device_address,
+                   std::unique_ptr<BluetoothDevice>(device_mac));
+      for (auto& observer : observers_) {
+        observer.DeviceAdded(this, device_mac);
+      }
+    }
+    connected_devices.push_back(device_mac);
+  }
+  return connected_devices;
+}
+
 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 50 matching lines @@
 BluetoothAdapterMac::GetBluetoothLowEnergyDeviceMac(CBPeripheral* peripheral) {
   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);
 }
 
+bool BluetoothAdapterMac::DoesCollideWithKnownDevice(
+    CBPeripheral* peripheral,
+    BluetoothLowEnergyDeviceMac* device_mac) {
+  // Check that there are no collisions.
+  std::string stored_device_id = device_mac->GetIdentifier();
+  std::string updated_device_id =
+      BluetoothLowEnergyDeviceMac::GetPeripheralIdentifier(peripheral);
+  if (stored_device_id != updated_device_id) {
+    VLOG(1) << "LowEnergyDeviceUpdated stored_device_id != updated_device_id: "
+            << std::endl
+            << "  " << stored_device_id << std::endl
+            << "  " << updated_device_id;
+    // Collision, two identifiers map to the same hash address.  With a 48 bit
+    // hash the probability of this occuring with 10,000 devices
+    // simultaneously present is 1e-6 (see
+    // https://en.wikipedia.org/wiki/Birthday_problem#Probability_table).  We
+    // ignore the second device by returning.
+    return true;
+  }
+  return false;
+}
+
 }  // namespace device