[Bluetooth] Improve the adapter's awareness of connected devices.

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 <string>
@@ skipping 120 matching lines @@
     int psm,
     const CreateServiceCallback& callback,
     const CreateServiceErrorCallback& error_callback) {
   scoped_refptr<BluetoothSocketMac> socket = BluetoothSocketMac::CreateSocket();
   socket->ListenUsingL2cap(
       this, uuid, psm, base::Bind(callback, socket), error_callback);
 }
 
 void BluetoothAdapterMac::DeviceFound(BluetoothDiscoveryManagerMac* manager,
                                       IOBluetoothDevice* device) {
+  // TODO(isherman): The list of discovered devices is never reset. This should
+  // probably key off of |devices_| instead. Currently, if a device is paired,
+  // then unpaired, then paired again, the app would never hear about the second
+  // pairing.
   std::string device_address = BluetoothDeviceMac::GetDeviceAddress(device);
   if (discovered_devices_.find(device_address) == discovered_devices_.end()) {
     BluetoothDeviceMac device_mac(device);
     FOR_EACH_OBSERVER(
         BluetoothAdapter::Observer, observers_, DeviceAdded(this, &device_mac));
     discovered_devices_.insert(device_address);
   }
 }
 
 void BluetoothAdapterMac::DiscoveryStopped(
     BluetoothDiscoveryManagerMac* manager,
     bool unexpected) {
   DCHECK_EQ(manager, classic_discovery_manager_.get());
   if (unexpected) {
     DVLOG(1) << "Discovery stopped unexpectedly";
     num_discovery_sessions_ = 0;
     MarkDiscoverySessionsAsInactive();
   }
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
                     observers_,
                     AdapterDiscoveringChanged(this, false));
 }
 
+void BluetoothAdapterMac::DeviceConnected(IOBluetoothDevice* device) {
+  // TODO(isherman): Call -registerForDisconnectNotification:selector:, and
+  // investigate whether this method can be replaced with a call to
+  // +registerForConnectNotifications:selector:.
+  std::string device_address = BluetoothDeviceMac::GetDeviceAddress(device);
+  DVLOG(1) << "Adapter registered a new connection from device with address: "
+           << device_address;
+
+  // Only notify once per device.
+  if (devices_.count(device_address))
+    return;
+
+  scoped_ptr<BluetoothDeviceMac> device_mac(new BluetoothDeviceMac(device));
+  FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
+                    observers_,
+                    DeviceAdded(this, device_mac.get()));
+  devices_[device_address] = device_mac.release();
+}
+
 void BluetoothAdapterMac::AddDiscoverySession(
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   DVLOG(1) << __func__;
   if (num_discovery_sessions_ > 0) {
     DCHECK(IsDiscovering());
     num_discovery_sessions_++;
     callback.Run();
     return;
   }
@@ skipping 81 matching lines @@
   if (was_present != is_present) {
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       AdapterPresentChanged(this, is_present));
   }
   if (powered_ != powered) {
     powered_ = powered;
     FOR_EACH_OBSERVER(BluetoothAdapter::Observer, observers_,
                       AdapterPoweredChanged(this, powered_));
   }
 
+  // TODO(isherman): This doesn't detect when a device is unpaired.
   IOBluetoothDevice* recent_device =
       [[IOBluetoothDevice recentDevices:1] lastObject];
   NSDate* access_timestamp = [recent_device recentAccessDate];
   if (recently_accessed_device_timestamp_ == nil ||
       access_timestamp == nil ||
       [recently_accessed_device_timestamp_ compare:access_timestamp] ==
           NSOrderedAscending) {
-    UpdateDevices([IOBluetoothDevice pairedDevices]);
+    UpdateDevices();
     recently_accessed_device_timestamp_.reset([access_timestamp copy]);
   }
 
   ui_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&BluetoothAdapterMac::PollAdapter,
                  weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kPollIntervalMs));
 }
 
-void BluetoothAdapterMac::UpdateDevices(NSArray* devices) {
-  // TODO(armansito): This code never calls
-  // BluetoothAdapter::Observer::DeviceRemoved. It should, if a device
-  // no longer exists.
-  STLDeleteValues(&devices_);
-  for (IOBluetoothDevice* device in devices) {
+void BluetoothAdapterMac::UpdateDevices() {
+  // Snapshot the devices observers were previously notified of.
+  // Note that the code below is careful to take ownership of any values that
+  // are erased from the map, since the map owns the memory for all its mapped
+  // devices.
+  DevicesMap old_devices = devices_;
+
+  // Add all the paired devices.
+  devices_.clear();
+  for (IOBluetoothDevice* device in [IOBluetoothDevice pairedDevices]) {
     std::string device_address = BluetoothDeviceMac::GetDeviceAddress(device);
-    devices_[device_address] = new BluetoothDeviceMac(device);
+    scoped_ptr<BluetoothDevice> device_mac(old_devices[device_address]);
+    if (!device_mac)
+      device_mac.reset(new BluetoothDeviceMac(device));
+    devices_[device_address] = device_mac.release();
+    old_devices.erase(device_address);
   }
+
+  // Add any unpaired connected devices.
+  for (const auto& old_device : old_devices) {
+    if (!old_device.second->IsConnected())
+      continue;
+
+    const std::string& device_address = old_device.first;
+    DCHECK(!devices_.count(device_address));
+    devices_[device_address] = old_device.second;
+    old_devices.erase(device_address);
+  }
+
+  // TODO(isherman): Notify observers of any devices that are no longer in
+  // range. Note that it's possible for a device to be neither paired nor
+  // connected, but to still be in range.
+  STLDeleteValues(&old_devices);
 }
 
 }  // namespace device