bluetooth: android: Implement RetrieveGattConnectedDevicesWithFilter

device/bluetooth/bluetooth_adapter_android.cc

 // Copyright 2015 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_android.h"
 
 #include <memory>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "device/bluetooth/android/wrappers.h"
 #include "device/bluetooth/bluetooth_advertisement.h"
 #include "device/bluetooth/bluetooth_device_android.h"
+#include "device/bluetooth/bluetooth_discovery_filter.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "jni/ChromeBluetoothAdapter_jni.h"
+#include "jni/ChromeBluetoothManager_jni.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::AppendJavaStringArrayToStringVector;
 using base::android::JavaParamRef;
 using base::android::JavaRef;
 
+namespace device {
+
 namespace {
 // The poll interval in ms when there is no active discovery. This
 // matches the max allowed advertisting interval for connectable
 // devices.
 enum { kPassivePollInterval = 11000 };
 // The poll interval in ms when there is an active discovery.
 enum { kActivePollInterval = 1000 };
 // The delay in ms to wait before purging devices when a scan starts.
 enum { kPurgeDelay = 500 };
+
+BluetoothDevice::UUIDList ConvertJavaStringArrayToUUIDList(
+    JNIEnv* env,
+    const JavaRef<jobjectArray>& j_uuids) {
+  std::vector<std::string> uuids_strings;
+  AppendJavaStringArrayToStringVector(env, j_uuids.obj(), &uuids_strings);
+
+  BluetoothDevice::UUIDList uuids;
+  for (std::string& uuid : uuids_strings) {
+    uuids.push_back(BluetoothUUID(std::move(uuid)));
+  }
+
+  return uuids;
 }
 
-namespace device {
+}  // namespace
 
 // static
 base::WeakPtr<BluetoothAdapter> BluetoothAdapter::CreateAdapter(
     const InitCallback& init_callback) {
   return BluetoothAdapterAndroid::Create(
-      BluetoothAdapterWrapper_CreateWithDefaultAdapter());
+      BluetoothAdapterWrapper_CreateWithDefaultAdapter(),
+      BluetoothManagerWrapper_CreateWithDefaultManager());
 }
 
 // static
 base::WeakPtr<BluetoothAdapterAndroid> BluetoothAdapterAndroid::Create(
     const JavaRef<jobject>&
-        bluetooth_adapter_wrapper) {  // Java Type: bluetoothAdapterWrapper
+        bluetooth_adapter_wrapper,  // Java Type: BluetoothAdapterWrapper
+    const JavaRef<jobject>&
+        bluetooth_manager_wrapper) {  // Java Type: BluetoothManagerWrapper
   BluetoothAdapterAndroid* adapter = new BluetoothAdapterAndroid();
 
   adapter->j_adapter_.Reset(Java_ChromeBluetoothAdapter_create(
       AttachCurrentThread(), reinterpret_cast<intptr_t>(adapter),
       bluetooth_adapter_wrapper));
 
+  adapter->j_manager_.Reset(Java_ChromeBluetoothManager_create(
+      AttachCurrentThread(), bluetooth_manager_wrapper));
+
   adapter->ui_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   return adapter->weak_ptr_factory_.GetWeakPtr();
 }
 
 // static
 bool BluetoothAdapterAndroid::RegisterJNI(JNIEnv* env) {
   return RegisterNativesImpl(env);  // Generated in BluetoothAdapter_jni.h
 }
 
@@ skipping 48 matching lines @@
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   NOTIMPLEMENTED();
 }
 
 bool BluetoothAdapterAndroid::IsDiscovering() const {
   return Java_ChromeBluetoothAdapter_isDiscovering(AttachCurrentThread(),
                                                    j_adapter_);
 }
 
+std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet>
+BluetoothAdapterAndroid::RetrieveGattConnectedDevicesWithDiscoveryFilter(
+    const BluetoothDiscoveryFilter& discovery_filter) {
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobjectArray> j_devices_and_uuids =
+      Java_ChromeBluetoothManager_retrieveGattConnectedDevices(env, j_manager_);
+
+  std::unordered_map<BluetoothDevice*, BluetoothDevice::UUIDSet>
+      connected_devices;
+  std::set<BluetoothUUID> filter_uuids;
+  discovery_filter.GetUUIDs(filter_uuids);
+
+  jsize size = env->GetArrayLength(j_devices_and_uuids.obj());
+  for (jsize i = 0; i < size; i++) {
+    ScopedJavaLocalRef<jobject> j_device_and_uuids(
+        env, env->GetObjectArrayElement(j_devices_and_uuids.obj(), i));
+
+    ScopedJavaLocalRef<jobject> j_device =
+        Java_DeviceAndUUIDs_getDevice(env, j_device_and_uuids.obj());
+
+    std::string address = ConvertJavaStringToUTF8(
+        Java_DeviceAndUUIDs_getAddress(env, j_device_and_uuids.obj()));
+
+    std::unique_ptr<BluetoothDeviceAndroid> device;
+    BluetoothDeviceAndroid* device_ptr = nullptr;
+
+    auto iter = devices_.find(address);
+    const bool new_device = iter == devices_.end();
+    if (new_device) {
+      device.reset(BluetoothDeviceAndroid::Create(this, j_device));
+      device_ptr = device.get();
+    } else {
+      device_ptr = static_cast<BluetoothDeviceAndroid*>(iter->second);
+    }
+
+    DCHECK(device_ptr);
+
+    ScopedJavaLocalRef<jobjectArray> j_device_uuids =
+        Java_DeviceAndUUIDs_getUuids(env, j_device_and_uuids.obj());
+
+    BluetoothDevice::UUIDList device_uuids_list =
+        ConvertJavaStringArrayToUUIDList(env, j_device_uuids);
+    BluetoothDevice::UUIDSet intersection;
+    for (BluetoothUUID& uuid : device_uuids_list) {
+      if (base::ContainsKey(filter_uuids, uuid)) {
+        intersection.insert(uuid);
+      }
+    }
+
+    if (!filter_uuids.empty() && intersection.empty()) {
+      continue;
+    }
+
+    connected_devices[device_ptr] = std::move(intersection);
+
+    if (new_device) {
+      devices_.add(device_ptr->GetAddress(), std::move(device));
+      for (auto& observer : observers_)
+        observer.DeviceAdded(this, device_ptr);
+    }
+  }
+
+  return connected_devices;
+}
+
 BluetoothAdapter::UUIDList BluetoothAdapterAndroid::GetUUIDs() const {
   NOTIMPLEMENTED();
   return UUIDList();
 }
 
 void BluetoothAdapterAndroid::CreateRfcommService(
     const BluetoothUUID& uuid,
     const ServiceOptions& options,
     const CreateServiceCallback& callback,
     const CreateServiceErrorCallback& error_callback) {
@@ skipping 57 matching lines @@
     is_new_device = true;
     device_android_owner.reset(
         BluetoothDeviceAndroid::Create(this, bluetooth_device_wrapper));
     device_android = device_android_owner.get();
   } else {
     // Existing device.
     device_android = static_cast<BluetoothDeviceAndroid*>(iter->second);
   }
   DCHECK(device_android);
 
-  std::vector<std::string> advertised_uuids_strings;
-  AppendJavaStringArrayToStringVector(env, advertised_uuids,
-                                      &advertised_uuids_strings);
-  BluetoothDevice::UUIDList advertised_bluetooth_uuids;
-  for (std::string& uuid : advertised_uuids_strings) {
-    advertised_bluetooth_uuids.push_back(BluetoothUUID(std::move(uuid)));
-  }
+  BluetoothDevice::UUIDList advertised_bluetooth_uuids =
+      ConvertJavaStringArrayToUUIDList(env, advertised_uuids);
 
   int8_t clamped_tx_power = BluetoothDevice::ClampPower(tx_power);
 
   device_android->UpdateAdvertisementData(
       BluetoothDevice::ClampPower(rssi), std::move(advertised_bluetooth_uuids),
       {} /* service_data */,
       // Android uses INT32_MIN to indicate no Advertised Tx Power.
       // https://developer.android.com/reference/android/bluetooth/le/ScanRecord.html#getTxPowerLevel()
       tx_power == INT32_MIN ? nullptr : &clamped_tx_power);
 
@@ skipping 104 matching lines @@
   // TODO(scheib): Support filters crbug.com/490401
   NOTIMPLEMENTED();
   error_callback.Run(UMABluetoothDiscoverySessionOutcome::NOT_IMPLEMENTED);
 }
 
 void BluetoothAdapterAndroid::RemovePairingDelegateInternal(
     device::BluetoothDevice::PairingDelegate* pairing_delegate) {
 }
 
 }  // namespace device