blob: b2e16cb09f815d8f594104554e510c1209ca7693 (
plain)
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
|
// Copyright 2016 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.
#ifndef CONTENT_BROWSER_BLUETOOTH_BLUETOOTH_DEVICE_CHOOSER_CONTROLLER_H_
#define CONTENT_BROWSER_BLUETOOTH_BLUETOOTH_DEVICE_CHOOSER_CONTROLLER_H_
#include <string>
#include <unordered_set>
#include "base/memory/weak_ptr.h"
#include "base/optional.h"
#include "base/time/time.h"
#include "base/timer/timer.h"
#include "content/common/content_export.h"
#include "content/public/browser/bluetooth_chooser.h"
#include "third_party/blink/public/platform/modules/bluetooth/web_bluetooth.mojom.h"
namespace device {
class BluetoothAdapter;
class BluetoothDevice;
class BluetoothDiscoverySession;
}
namespace content {
class RenderFrameHost;
class WebContents;
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:
typedef base::Callback<void(blink::mojom::WebBluetoothRequestDeviceOptionsPtr,
const std::string& device_address)>
SuccessCallback;
typedef base::Callback<void(blink::mojom::WebBluetoothResult result)>
ErrorCallback;
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,
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
// |error_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,
const SuccessCallback& success_callback,
const ErrorCallback& error_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);
private:
// 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(BluetoothChooser::Event 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.
device::BluetoothAdapter* adapter_;
// The WebBluetoothServiceImpl that owns this instance.
WebBluetoothServiceImpl* web_bluetooth_service_;
// The RenderFrameHost that owns web_bluetooth_service_.
RenderFrameHost* render_frame_host_;
// The WebContents that owns render_frame_host_.
WebContents* web_contents_;
// Contains the filters and optional services used when scanning.
blink::mojom::WebBluetoothRequestDeviceOptionsPtr options_;
// Callbacks to be called with the result of the chooser.
SuccessCallback success_callback_;
ErrorCallback error_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 time when scanning starts.
base::Optional<base::TimeTicks> scanning_start_time_;
// 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_;
};
} // namespace content
#endif // CONTENT_BROWSER_BLUETOOTH_BLUETOOTH_DEVICE_CHOOSER_CONTROLLER_H_
|
