1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_BLUETOOTH_BLUETOOTH_DEVICE_CHOOSER_CONTROLLER_H_
#define CONTENT_BROWSER_BLUETOOTH_BLUETOOTH_DEVICE_CHOOSER_CONTROLLER_H_
#include <optional>
#include <string>
#include <unordered_set>
#include "base/memory/raw_ptr.h"
#include "base/memory/raw_ref.h"
#include "base/memory/weak_ptr.h"
#include "base/timer/timer.h"
#include "content/browser/devtools/devtools_device_request_prompt_info.h"
#include "content/common/content_export.h"
#include "content/public/browser/bluetooth_chooser.h"
#include "third_party/blink/public/mojom/bluetooth/web_bluetooth.mojom.h"
namespace device {
class BluetoothAdapter;
class BluetoothDevice;
class BluetoothDiscoverySession;
class BluetoothDiscoveryFilter;
} // namespace device
namespace content {
class RenderFrameHost;
class WebBluetoothServiceImpl;
// Class that interacts with a chooser and starts a bluetooth discovery session.
// This class needs to be re-instantiated for each call to GetDevice(). Calling
// GetDevice() twice for the same instance will DCHECK.
class CONTENT_EXPORT BluetoothDeviceChooserController final {
public:
using Callback =
base::OnceCallback<void(blink::mojom::WebBluetoothResult result,
blink::mojom::WebBluetoothRequestDeviceOptionsPtr,
const std::string& device_address)>;
enum class TestScanDurationSetting { IMMEDIATE_TIMEOUT, NEVER_TIMEOUT };
// |web_bluetooth_service_| service that owns this class.
// |render_frame_host| should be the RenderFrameHost that owns the
// |web_bluetooth_service_|.
// |adapter| should be the adapter used to scan for Bluetooth devices.
BluetoothDeviceChooserController(
WebBluetoothServiceImpl* web_bluetooth_service_,
RenderFrameHost& render_frame_host,
scoped_refptr<device::BluetoothAdapter> adapter);
~BluetoothDeviceChooserController();
// This function performs the following checks before starting a discovery
// session:
// - Validates filters in |request_device_options|.
// - Removes any blocklisted UUIDs from
// |request_device_options.optinal_services|.
// - Checks if the request came from a cross-origin iframe.
// - Checks if the request came from a unique origin.
// - Checks if the adapter is present.
// - Checks if the Web Bluetooth API has been disabled.
// - Checks if we are allowed to ask for scanning permission.
// If any of the previous checks failed then this function runs |callback|
// with the corresponding error. Otherwise this function populates the
// embedder provided BluetoothChooser with existing devices and starts a new
// discovery session.
//
// This function should only be called once per
// BluetoothDeviceChooserController instance. Calling this function more than
// once will DCHECK.
void GetDevice(
blink::mojom::WebBluetoothRequestDeviceOptionsPtr request_device_options,
Callback callback);
// Adds a device to the chooser. Should only be called after GetDevice and
// before either of the callbacks are run.
void AddFilteredDevice(const device::BluetoothDevice& device);
// Stops the current discovery session and notifies the chooser
// that the adapter changed states.
void AdapterPoweredChanged(bool powered);
// Received Signal Strength Indicator (RSSI) is a measurement of the power
// present in a received radio signal.
static int CalculateSignalStrengthLevel(int8_t rssi);
// After this method is called, any new instance of
// BluetoothDeviceChooserController will have a scan duration determined by
// the |setting| enum. The possible enumerations are described below:
// IMMEDIATE_TIMEOUT: Sets the scan duration to 0 seconds.
// NEVER_TIMEOUT: Sets the scan duration to INT_MAX seconds.
static void SetTestScanDurationForTesting(
TestScanDurationSetting setting =
TestScanDurationSetting::IMMEDIATE_TIMEOUT);
static std::unique_ptr<device::BluetoothDiscoveryFilter> ComputeScanFilter(
const std::optional<
std::vector<blink::mojom::WebBluetoothLeScanFilterPtr>>& filters);
private:
class BluetoothDeviceRequestPromptInfo final
: public DevtoolsDeviceRequestPromptInfo {
public:
explicit BluetoothDeviceRequestPromptInfo(
BluetoothDeviceChooserController& controller);
~BluetoothDeviceRequestPromptInfo() override;
std::vector<DevtoolsDeviceRequestPromptDevice> GetDevices() override;
bool SelectDevice(const std::string& device_id) override;
void Cancel() override;
private:
// The controller that owns this instance.
raw_ref<BluetoothDeviceChooserController> controller_;
};
// Checks adapter permissions and powered states and starts getting devices
// if the adapter status allows us to do so. It can be called multiple times
// to re-check the adapter status when it has changed.
void CheckAdapterAndStartGettingDevices();
// Populates the chooser with the GATT connected devices.
void PopulateConnectedDevices();
// Notifies the chooser that discovery is starting and starts a discovery
// session.
void StartDeviceDiscovery();
// Stops the discovery session and notifies the chooser.
void StopDeviceDiscovery();
// StartDiscoverySessionWithFilter callbacks:
void OnStartDiscoverySessionSuccess(
std::unique_ptr<device::BluetoothDiscoverySession> discovery_session);
void OnStartDiscoverySessionFailed();
// BluetoothChooser::EventHandler:
// Runs |error_callback_| if the chooser was cancelled or if we weren't able
// to show the chooser. Otherwise runs |success_callback_| with
// |device_address|.
void OnBluetoothChooserEvent(BluetoothChooserEvent event,
const std::string& device_address);
// Helper function to asynchronously run success_callback_.
void PostSuccessCallback(const std::string& device_address);
// Helper function to asynchronously run error_callback_.
void PostErrorCallback(blink::mojom::WebBluetoothResult result);
// Stores the scan duration to use for the discovery session timer.
// The default value is 60 seconds.
static int64_t scan_duration_;
// The adapter used to get existing devices and start a discovery session.
scoped_refptr<device::BluetoothAdapter> adapter_;
// The WebBluetoothServiceImpl that owns this instance.
raw_ptr<WebBluetoothServiceImpl> web_bluetooth_service_;
// The RenderFrameHost that owns web_bluetooth_service_.
raw_ref<RenderFrameHost> render_frame_host_;
BluetoothDeviceRequestPromptInfo prompt_info_;
// Contains the filters and optional services used when scanning.
blink::mojom::WebBluetoothRequestDeviceOptionsPtr options_;
// Callback to be called with the result of the chooser.
Callback callback_;
// The currently opened BluetoothChooser.
std::unique_ptr<BluetoothChooser> chooser_;
// Automatically stops Bluetooth discovery a set amount of time after it was
// started.
base::RetainingOneShotTimer discovery_session_timer_;
// The last discovery session to be started.
// TODO(ortuno): This should be null unless there is an active discovery
// session. We need to null it when the platform stops discovery.
// http://crbug.com/611852
std::unique_ptr<device::BluetoothDiscoverySession> discovery_session_;
// The device ids that are currently shown in the chooser.
std::unordered_set<std::string> device_ids_;
// Weak pointer factory for generating 'this' pointers that might live longer
// than we do.
// Note: This should remain the last member so it'll be destroyed and
// invalidate its weak pointers before any other members are destroyed.
base::WeakPtrFactory<BluetoothDeviceChooserController> weak_ptr_factory_{
this};
};
} // namespace content
#endif // CONTENT_BROWSER_BLUETOOTH_BLUETOOTH_DEVICE_CHOOSER_CONTROLLER_H_
|
