feat: add bluetooth pairing handler

docs/api/session.md

@@ -823,6 +823,68 @@ app.whenReady().then(() => {
 })
 ```
 
+#### `ses.setBluetoothPairingHandler(handler)` _Windows_ _Linux_
+
+* `handler` Function | null
+  * `details` Object
+    * `deviceId` string
+    * `pairingKind` string - The type of pairing prompt being requested.
+      One of the following values:
+      * `confirm`
+        This prompt is requesting confirmation that the bluetooth device should
+        be paired.
+      * `confirmPin`
+        This prompt is requesting confirmation that the provided pin matches the
+        pin displayed on the device.
+      * `providePin`
+        This prompt is requesting that a pin be provided for the device.
+    * `frame` [WebFrameMain](web-frame-main.md)
+    * `pin` string - If the `pairingKind` is `confirmPin`, this value will be
+      the pin value to verify.
+  * `callback` Function
+    * `response` Object
+      * `confirmed` boolean - `false` should be passed in if the dialog is canceled.
+        If the `pairingKind` is `confirm` or `confirmPin`, this value should indicate
+        if the pairing is confirmed.  If the `pairingKind` is `providePin` the value
+        should be `true` when a value is provided.
+      * `pin` string | null (optional) - When the `pairingKind` is `providePin`
+        this value should be the required pin for the bluetooth device.
+
+Sets the handler which can be used to respond when a bluetooth device requires
+a response to pairing.  This handler allows developers to handle devices that
+require additional validation for pairing.
+To clear the handler, call `setBluetoothPairingHandler(null)`.
+
+```javascript
+
+const { session } = require('electron')
+
+session.defaultSession.setBluetoothPairingHandler((details, callback) => {
+  const response = {}
+
+  switch (details.pairingKind) {
+    case 'confirm': {
+      response.confirmed = confirm(`Do you want to connect to device ${details.deviceId}`)
+      break
+    }
+    case 'confirmPin': {
+      response.confirmed = confirm(`Does the pin ${details.pin} match the pin displayed on device ${details.deviceId}?`)
+      break
+    }
+    case 'providePin': {
+      const pin = prompt(`Please provide a pin for ${details.deviceId}`)
+      if (pin) {
+        response.pin = pin
+        response.confirmed = true
+      } else {
+        response.confirmed = false
+      }
+    }
+  }
+  callback(response)
+})
+```
+
 #### `ses.clearHostResolverCache()`
 
 Returns `Promise<void>` - Resolves when the operation is complete.

docs/fiddles/features/web-bluetooth/main.js

@@ -14,6 +14,31 @@ function createWindow () {
     } 
   })
 
+  mainWindow.webContents.session.setBluetoothPairingHandler((details, callback) => {
+    const response = {}
+
+    switch (details.pairingKind) {
+      case 'confirm': {
+        response.confirmed = confirm(`Do you want to connect to device ${details.deviceId}`)
+        break
+      }
+      case 'confirmPin': {
+        response.confirmed = confirm(`Does the pin ${details.pin} match the pin displayed on device ${details.deviceId}?`)
+        break
+      }
+      case 'providePin': {
+        const pin = prompt(`Please provide a pin for ${details.deviceId}`)
+        if (pin) {
+          response.pin = pin
+          response.confirmed = true
+        } else {
+          response.confirmed = false
+        }
+      }
+    }
+    callback(response)
+  })  
+
   mainWindow.loadFile('index.html')
 }
 

docs/tutorial/devices.md

@@ -16,6 +16,10 @@ with bluetooth devices. In order to use this API in Electron, developers will
 need to handle the [`select-bluetooth-device` event on the webContents](../api/web-contents.md#event-select-bluetooth-device)
 associated with the device request.
 
+Additionally, [`ses.setBluetoothPairingHandler(handler)`](../api/session.md#sessetbluetoothpairinghandlerhandler-windows-linux)
+can be used to handle pairing to bluetooth devices on Windows or Linux when
+additional validation such as a pin is needed.
+
 ### Example
 
 This example demonstrates an Electron application that automatically selects

shell/browser/api/electron_api_session.cc

@@ -674,6 +674,18 @@ void Session::SetDevicePermissionHandler(v8::Local<v8::Value> val,
   permission_manager->SetDevicePermissionHandler(handler);
 }
 
+void Session::SetBluetoothPairingHandler(v8::Local<v8::Value> val,
+                                         gin::Arguments* args) {
+  ElectronPermissionManager::BluetoothPairingHandler handler;
+  if (!(val->IsNull() || gin::ConvertFromV8(args->isolate(), val, &handler))) {
+    args->ThrowTypeError("Must pass null or function");
+    return;
+  }
+  auto* permission_manager = static_cast<ElectronPermissionManager*>(
+      browser_context()->GetPermissionControllerDelegate());
+  permission_manager->SetBluetoothPairingHandler(handler);
+}
+
 v8::Local<v8::Promise> Session::ClearHostResolverCache(gin::Arguments* args) {
   v8::Isolate* isolate = args->isolate();
   gin_helper::Promise<void> promise(isolate);
@@ -1225,6 +1237,8 @@ gin::ObjectTemplateBuilder Session::GetObjectTemplateBuilder(
                  &Session::SetDisplayMediaRequestHandler)
       .SetMethod("setDevicePermissionHandler",
                  &Session::SetDevicePermissionHandler)
+      .SetMethod("setBluetoothPairingHandler",
+                 &Session::SetBluetoothPairingHandler)
       .SetMethod("clearHostResolverCache", &Session::ClearHostResolverCache)
       .SetMethod("clearAuthCache", &Session::ClearAuthCache)
       .SetMethod("allowNTLMCredentialsForDomains",

shell/browser/api/electron_api_session.h

@@ -105,6 +105,8 @@ class Session : public gin::Wrappable<Session>,
                                  gin::Arguments* args);
   void SetDevicePermissionHandler(v8::Local<v8::Value> val,
                                   gin::Arguments* args);
+  void SetBluetoothPairingHandler(v8::Local<v8::Value> val,
+                                  gin::Arguments* args);
   v8::Local<v8::Promise> ClearHostResolverCache(gin::Arguments* args);
   v8::Local<v8::Promise> ClearAuthCache();
   void AllowNTLMCredentialsForDomains(const std::string& domains);

shell/browser/bluetooth/electron_bluetooth_delegate.cc

@@ -7,14 +7,18 @@
 #include <memory>
 #include <utility>
 
+#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/public/cpp/bluetooth_uuid.h"
 #include "shell/browser/api/electron_api_web_contents.h"
+#include "shell/browser/electron_permission_manager.h"
 #include "shell/browser/lib/bluetooth_chooser.h"
+#include "shell/common/gin_converters/frame_converter.h"
+#include "shell/common/gin_helper/dictionary.h"
 #include "third_party/blink/public/common/bluetooth/web_bluetooth_device_id.h"
 #include "third_party/blink/public/mojom/bluetooth/web_bluetooth.mojom.h"
 
@@ -23,6 +27,28 @@ using content::RenderFrameHost;
 using content::WebContents;
 using device::BluetoothUUID;
 
+namespace gin {
+
+template <>
+struct Converter<content::BluetoothDelegate::PairingKind> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      content::BluetoothDelegate::PairingKind paring_kind) {
+    switch (paring_kind) {
+      case content::BluetoothDelegate::PairingKind::kConfirmOnly:
+        return StringToV8(isolate, "confirm");
+      case content::BluetoothDelegate::PairingKind::kConfirmPinMatch:
+        return StringToV8(isolate, "confirmPin");
+      case content::BluetoothDelegate::PairingKind::kProvidePin:
+        return StringToV8(isolate, "providePin");
+      default:
+        return StringToV8(isolate, "unknown");
+    }
+  }
+};
+
+}  // namespace gin
+
 namespace electron {
 
 ElectronBluetoothDelegate::ElectronBluetoothDelegate() = default;
@@ -136,9 +162,48 @@ void ElectronBluetoothDelegate::ShowDevicePairPrompt(
     PairPromptCallback callback,
     PairingKind pairing_kind,
     const absl::optional<std::u16string>& pin) {
-  NOTIMPLEMENTED();
-  std::move(callback).Run(BluetoothDelegate::PairPromptResult(
-      BluetoothDelegate::PairPromptStatus::kCancelled));
+  pair_prompt_callback_ = std::move(callback);
+
+  auto* web_contents = content::WebContents::FromRenderFrameHost(frame);
+  if (web_contents) {
+    auto* permission_manager = static_cast<ElectronPermissionManager*>(
+        web_contents->GetBrowserContext()->GetPermissionControllerDelegate());
+
+    v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
+    v8::HandleScope scope(isolate);
+    gin_helper::Dictionary details =
+        gin_helper::Dictionary::CreateEmpty(isolate);
+    details.Set("deviceId", device_identifier);
+    details.Set("pairingKind", pairing_kind);
+    details.SetGetter("frame", frame);
+    if (pin.has_value()) {
+      details.Set("pin", pin.value());
+    }
+
+    permission_manager->CheckBluetoothDevicePair(
+        details, base::AdaptCallbackForRepeating(base::BindOnce(
+                     &ElectronBluetoothDelegate::OnDevicePairPromptResponse,
+                     weak_factory_.GetWeakPtr())));
+  }
+}
+
+void ElectronBluetoothDelegate::OnDevicePairPromptResponse(
+    base::Value::Dict response) {
+  BluetoothDelegate::PairPromptResult result;
+  if (response.FindBool("confirmed").value_or(false)) {
+    result.result_code = BluetoothDelegate::PairPromptStatus::kSuccess;
+  } else {
+    result.result_code = BluetoothDelegate::PairPromptStatus::kCancelled;
+  }
+
+  std::string* pin = response.FindString("pin");
+  if (pin) {
+    std::u16string trimmed_input;
+    base::TrimWhitespace(base::UTF8ToUTF16(*pin), base::TRIM_ALL,
+                         &trimmed_input);
+    result.pin = base::UTF16ToUTF8(trimmed_input);
+  }
+  std::move(pair_prompt_callback_).Run(result);
 }
 
 }  // namespace electron

shell/browser/bluetooth/electron_bluetooth_delegate.h

@@ -9,6 +9,7 @@
 #include <string>
 #include <vector>
 
+#include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/scoped_observation.h"
 #include "content/public/browser/bluetooth_delegate.h"
@@ -91,6 +92,13 @@ class ElectronBluetoothDelegate : public content::BluetoothDelegate {
   void AddFramePermissionObserver(FramePermissionObserver* observer) override;
   void RemoveFramePermissionObserver(
       FramePermissionObserver* observer) override;
+
+ private:
+  void OnDevicePairPromptResponse(base::Value::Dict response);
+
+  PairPromptCallback pair_prompt_callback_;
+
+  base::WeakPtrFactory<ElectronBluetoothDelegate> weak_factory_{this};
 };
 
 }  // namespace electron

shell/browser/electron_permission_manager.cc

@@ -130,6 +130,11 @@ void ElectronPermissionManager::SetDevicePermissionHandler(
   device_permission_handler_ = handler;
 }
 
+void ElectronPermissionManager::SetBluetoothPairingHandler(
+    const BluetoothPairingHandler& handler) {
+  bluetooth_pairing_handler_ = handler;
+}
+
 void ElectronPermissionManager::RequestPermission(
     blink::PermissionType permission,
     content::RenderFrameHost* render_frame_host,
@@ -276,6 +281,18 @@ ElectronPermissionManager::SubscribePermissionStatusChange(
 void ElectronPermissionManager::UnsubscribePermissionStatusChange(
     SubscriptionId id) {}
 
+void ElectronPermissionManager::CheckBluetoothDevicePair(
+    gin_helper::Dictionary details,
+    PairCallback pair_callback) const {
+  if (bluetooth_pairing_handler_.is_null()) {
+    base::Value::Dict response;
+    response.Set("confirmed", false);
+    std::move(pair_callback).Run(std::move(response));
+  } else {
+    bluetooth_pairing_handler_.Run(details, std::move(pair_callback));
+  }
+}
+
 bool ElectronPermissionManager::CheckPermissionWithDetails(
     blink::PermissionType permission,
     content::RenderFrameHost* render_frame_host,

shell/browser/electron_permission_manager.h

@@ -13,6 +13,7 @@
 #include "content/public/browser/permission_controller_delegate.h"
 #include "gin/dictionary.h"
 #include "shell/browser/electron_browser_context.h"
+#include "shell/common/gin_helper/dictionary.h"
 
 namespace base {
 class Value;
@@ -38,6 +39,7 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
       base::OnceCallback<void(blink::mojom::PermissionStatus)>;
   using StatusesCallback = base::OnceCallback<void(
       const std::vector<blink::mojom::PermissionStatus>&)>;
+  using PairCallback = base::OnceCallback<void(base::Value::Dict)>;
   using RequestHandler = base::RepeatingCallback<void(content::WebContents*,
                                                       blink::PermissionType,
                                                       StatusCallback,
@@ -50,11 +52,14 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
 
   using DeviceCheckHandler =
       base::RepeatingCallback<bool(const v8::Local<v8::Object>&)>;
+  using BluetoothPairingHandler =
+      base::RepeatingCallback<void(gin_helper::Dictionary, PairCallback)>;
 
   // Handler to dispatch permission requests in JS.
   void SetPermissionRequestHandler(const RequestHandler& handler);
   void SetPermissionCheckHandler(const CheckHandler& handler);
   void SetDevicePermissionHandler(const DeviceCheckHandler& handler);
+  void SetBluetoothPairingHandler(const BluetoothPairingHandler& handler);
 
   // content::PermissionControllerDelegate:
   void RequestPermission(blink::PermissionType permission,
@@ -81,6 +86,9 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
       base::Value::Dict details,
       StatusesCallback callback);
 
+  void CheckBluetoothDevicePair(gin_helper::Dictionary details,
+                                PairCallback pair_callback) const;
+
   bool CheckPermissionWithDetails(blink::PermissionType permission,
                                   content::RenderFrameHost* render_frame_host,
                                   const GURL& requesting_origin,
@@ -147,6 +155,7 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
   RequestHandler request_handler_;
   CheckHandler check_handler_;
   DeviceCheckHandler device_permission_handler_;
+  BluetoothPairingHandler bluetooth_pairing_handler_;
 
   PendingRequestsMap pending_requests_;
 };