bluetooth: android: Implement RetrieveGattConnectedDevicesWithFilter

device/bluetooth/bluetooth_adapter_unittest.cc

 // Copyright 2014 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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 18 matching lines @@
 #include "device/bluetooth/test/bluetooth_test_android.h"
 #elif defined(OS_MACOSX)
 #include "device/bluetooth/test/bluetooth_test_mac.h"
 #elif defined(OS_WIN)
 #include "device/bluetooth/test/bluetooth_test_win.h"
 #elif defined(OS_CHROMEOS) || defined(OS_LINUX)
 #include "device/bluetooth/test/bluetooth_test_bluez.h"
 #endif
 
 using device::BluetoothDevice;
+using UUIDSet = BluetoothDevice::UUIDSet;
+using DeviceToUUIDs = std::unordered_map<BluetoothDevice*, UUIDSet>;
 
 namespace device {
 
 class TestBluetoothAdapter : public BluetoothAdapter {
  public:
   TestBluetoothAdapter() {
   }
 
   std::string GetAddress() const override { return ""; }
 
@@ skipping 809 matching lines @@
   device->CreateGattConnection(GetGattConnectionCallback(Call::EXPECTED),
                                GetConnectErrorCallback(Call::NOT_EXPECTED));
   SimulateGattConnection(device);
   EXPECT_EQ(1u, adapter_->GetDevices().size());
   RemoveTimedOutDevices();
   EXPECT_EQ(0, observer.device_removed_count());
   EXPECT_EQ(1u, adapter_->GetDevices().size());
 }
 #endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
-#if defined(OS_MACOSX)
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
+// Make sure devices have a timestamp when they are added.
+TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDevice_Timestamp) {
+  if (!PlatformSupportsLowEnergy()) {
+    LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
+    return;
+  }
+  InitWithFakeAdapter();
+  TestBluetoothAdapterObserver observer(adapter_);
+
+  SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
+  SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
+  BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
+      adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
+          discovery_filter);
+
+  EXPECT_EQ(2, observer.device_added_count());
+  EXPECT_EQ(0, observer.device_removed_count());
+  EXPECT_EQ(2u, adapter_->GetDevices().size());
+
+  observer.Reset();
+  RemoveTimedOutDevices();
+
+  EXPECT_EQ(0, observer.device_removed_count());
+  EXPECT_EQ(2u, adapter_->GetDevices().size());
+}
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
+
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 // Simulate two devices being connected before calling
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() with no service filter.
 TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDeviceWithNoFilter) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
   BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
-  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet> result =
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
       adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
           discovery_filter);
 
-  EXPECT_EQ(2u, result.size());
-  for (const auto& pair : result) {
-    EXPECT_TRUE(adapter_->GetDevice(pair.first->GetAddress()));
-    EXPECT_TRUE(pair.second.empty());
-  }
-  EXPECT_EQ(BluetoothDevice::UUIDSet({BluetoothUUID(kTestUUIDGenericAccess)}),
-            RetrieveConnectedPeripheralServiceUUIDs());
   EXPECT_EQ(2, observer.device_added_count());
   EXPECT_EQ(2u, adapter_->GetDevices().size());
+
+  BluetoothDevice* device1 = adapter_->GetDevice(kTestDeviceAddress1);
+  ASSERT_TRUE(device1);
+  BluetoothDevice* device2 = adapter_->GetDevice(kTestDeviceAddress2);
+  ASSERT_TRUE(device2);
+
+  EXPECT_EQ(DeviceToUUIDs({{device1, UUIDSet()}, {device2, UUIDSet()}}),
+            result);
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({BluetoothUUID(kTestUUIDGenericAccess)}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(1, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
 }
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 // Simulate two devices being connected before calling
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() with one service filter.
 TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDeviceWithFilter) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
   BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
   device::BluetoothUUID heart_service_uuid =
       device::BluetoothUUID(kTestUUIDHeartRate);
   discovery_filter.AddUUID(heart_service_uuid);
-  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet> result =
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
       adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
           discovery_filter);
 
-  EXPECT_EQ(1u, result.size());
-  for (const auto& pair : result) {
-    EXPECT_EQ(kTestDeviceAddress2, pair.first->GetAddress());
-    EXPECT_TRUE(adapter_->GetDevice(pair.first->GetAddress()));
-    EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}), pair.second);
-  }
-  EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}),
-            RetrieveConnectedPeripheralServiceUUIDs());
   EXPECT_EQ(1, observer.device_added_count());
   EXPECT_EQ(1u, adapter_->GetDevices().size());
+
+  BluetoothDevice* device = adapter_->GetDevice(kTestDeviceAddress2);
+  ASSERT_TRUE(device);
+  EXPECT_EQ(DeviceToUUIDs({{device, UUIDSet({heart_service_uuid})}}), result);
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({heart_service_uuid}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(1, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
 }
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 // Simulate two devices being connected before calling
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() with one service filter
 // that doesn't match.
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDeviceWithWrongFilter) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
   BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
   discovery_filter.AddUUID(device::BluetoothUUID(kTestUUIDLinkLoss));
-  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet> result =
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
       adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
           discovery_filter);
 
-  EXPECT_TRUE(result.empty());
-  EXPECT_EQ(
-      BluetoothDevice::UUIDSet({device::BluetoothUUID(kTestUUIDLinkLoss)}),
-      RetrieveConnectedPeripheralServiceUUIDs());
   EXPECT_EQ(0, observer.device_added_count());
   EXPECT_EQ(0u, adapter_->GetDevices().size());
+
+  EXPECT_TRUE(result.empty());
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({device::BluetoothUUID(kTestUUIDLinkLoss)}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(1, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
 }
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 // Simulate two devices being connected before calling
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() with two service filters
 // that both match.
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDeviceWithTwoFilters) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
   BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
   device::BluetoothUUID heart_service_uuid =
       device::BluetoothUUID(kTestUUIDHeartRate);
   discovery_filter.AddUUID(heart_service_uuid);
   device::BluetoothUUID generic_service_uuid =
       device::BluetoothUUID(kTestUUIDGenericAccess);
   discovery_filter.AddUUID(generic_service_uuid);
-  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet> result =
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
       adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
           discovery_filter);
 
-  EXPECT_EQ(2u, result.size());
-  for (const auto& pair : result) {
-    EXPECT_TRUE(adapter_->GetDevice(pair.first->GetAddress()));
-    if (pair.first->GetAddress() == kTestDeviceAddress2) {
-      EXPECT_EQ(
-          BluetoothDevice::UUIDSet({heart_service_uuid, generic_service_uuid}),
-          pair.second);
-    } else if (pair.first->GetAddress() == kTestDeviceAddress1) {
-      EXPECT_EQ(BluetoothDevice::UUIDSet({generic_service_uuid}), pair.second);
-    } else {
-      // Unknown device.
-      EXPECT_TRUE(false);
-    }
-  }
-  EXPECT_EQ(
-      BluetoothDevice::UUIDSet({generic_service_uuid, heart_service_uuid}),
-      RetrieveConnectedPeripheralServiceUUIDs());
   EXPECT_EQ(2, observer.device_added_count());
   EXPECT_EQ(2u, adapter_->GetDevices().size());
+
+  BluetoothDevice* device1 = adapter_->GetDevice(kTestDeviceAddress1);
+  ASSERT_TRUE(device1);
+  BluetoothDevice* device2 = adapter_->GetDevice(kTestDeviceAddress2);
+  ASSERT_TRUE(device2);
+
+  EXPECT_EQ(
+      DeviceToUUIDs(
+          {{device1, UUIDSet({generic_service_uuid})},
+           {device2, UUIDSet({heart_service_uuid, generic_service_uuid})}}),
+      result);
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({generic_service_uuid, heart_service_uuid}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(1, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
 }
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 // Simulate two devices being connected before calling
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() with one service filter
 // that one match device, and then
 // RetrieveGattConnectedDevicesWithDiscoveryFilter() again.
+#if defined(OS_ANDROID) || defined(OS_MACOSX)
 TEST_F(BluetoothTest, DiscoverConnectedLowEnergyDeviceTwice) {
   if (!PlatformSupportsLowEnergy()) {
     LOG(WARNING) << "Low Energy Bluetooth unavailable, skipping unit test.";
     return;
   }
   InitWithFakeAdapter();
   TestBluetoothAdapterObserver observer(adapter_);
 
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::GENERIC_DEVICE);
   SimulateConnectedLowEnergyDevice(ConnectedDeviceType::HEART_RATE_DEVICE);
+
   BluetoothDiscoveryFilter discovery_filter(BLUETOOTH_TRANSPORT_LE);
   device::BluetoothUUID heart_service_uuid =
       device::BluetoothUUID(kTestUUIDHeartRate);
   discovery_filter.AddUUID(heart_service_uuid);
-  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet> result =
+  std::unordered_map<BluetoothDevice*, UUIDSet> result =
       adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
           discovery_filter);
 
-  EXPECT_EQ(1u, result.size());
-  for (const auto& pair : result) {
-    EXPECT_EQ(kTestDeviceAddress2, pair.first->GetAddress());
-    EXPECT_TRUE(adapter_->GetDevice(pair.first->GetAddress()));
-    EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}), pair.second);
-  }
-  EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}),
-            RetrieveConnectedPeripheralServiceUUIDs());
   EXPECT_EQ(1, observer.device_added_count());
   EXPECT_EQ(1u, adapter_->GetDevices().size());
 
+  BluetoothDevice* device = adapter_->GetDevice(kTestDeviceAddress2);
+  ASSERT_TRUE(device);
+  EXPECT_EQ(DeviceToUUIDs({{device, UUIDSet({heart_service_uuid})}}), result);
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({heart_service_uuid}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(1, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
+
   observer.Reset();
+#if defined(OS_MACOSX)
   ResetRetrieveConnectedPeripheralServiceUUIDs();
+#endif  // defined(OS_MACOSX)
+
   result = adapter_->RetrieveGattConnectedDevicesWithDiscoveryFilter(
       discovery_filter);
 
-  EXPECT_EQ(1u, result.size());
-  for (const auto& pair : result) {
-    EXPECT_EQ(kTestDeviceAddress2, pair.first->GetAddress());
-    EXPECT_TRUE(adapter_->GetDevice(pair.first->GetAddress()));
-    EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}), pair.second);
-  }
-  EXPECT_EQ(BluetoothDevice::UUIDSet({heart_service_uuid}),
-            RetrieveConnectedPeripheralServiceUUIDs());
-
   EXPECT_EQ(0, observer.device_added_count());
   EXPECT_EQ(1u, adapter_->GetDevices().size());
+
+  EXPECT_EQ(DeviceToUUIDs({{device, UUIDSet({heart_service_uuid})}}), result);
+
+#if defined(OS_MACOSX)
+  EXPECT_EQ(UUIDSet({heart_service_uuid}),
+            RetrieveConnectedPeripheralServiceUUIDs());
+#elif defined(OS_ANDROID)
+  EXPECT_EQ(2, manager_get_connected_devices_attempts_);
+#endif  // defined(OS_MACOSX)
 }
-#endif  // defined(OS_MACOSX)
+#endif  // defined(OS_ANDROID) || defined(OS_MACOSX)
 
 }  // namespace device