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
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
// Copyright 2013 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 DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H
#define DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H
#include <string>
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/sequenced_task_runner.h"
#include "dbus/object_path.h"
#include "device/bluetooth/bluetooth_device.h"
#include "device/bluetooth/bluetooth_export.h"
#include "device/bluetooth/dbus/bluetooth_device_client.h"
#include "device/bluetooth/dbus/bluetooth_gatt_service_client.h"
namespace device {
class BluetoothSocketThread;
} // namespace device
namespace chromeos {
class BluetoothAdapterChromeOS;
class BluetoothPairingChromeOS;
// The BluetoothDeviceChromeOS class implements BluetoothDevice for the
// Chrome OS platform.
//
// This class is not thread-safe, but is only called from the UI thread.
//
// A socket thread is used to create sockets but posts all callbacks on the UI
// thread.
class DEVICE_BLUETOOTH_EXPORT BluetoothDeviceChromeOS
: public device::BluetoothDevice,
public bluez::BluetoothGattServiceClient::Observer {
public:
// BluetoothDevice override
uint32 GetBluetoothClass() const override;
std::string GetAddress() const override;
VendorIDSource GetVendorIDSource() const override;
uint16 GetVendorID() const override;
uint16 GetProductID() const override;
uint16 GetDeviceID() const override;
bool IsPaired() const override;
bool IsConnected() const override;
bool IsGattConnected() const override;
bool IsConnectable() const override;
bool IsConnecting() const override;
UUIDList GetUUIDs() const override;
int16 GetInquiryRSSI() const override;
int16 GetInquiryTxPower() const override;
bool ExpectingPinCode() const override;
bool ExpectingPasskey() const override;
bool ExpectingConfirmation() const override;
void GetConnectionInfo(
const ConnectionInfoCallback& callback) override;
void Connect(device::BluetoothDevice::PairingDelegate* pairing_delegate,
const base::Closure& callback,
const ConnectErrorCallback& error_callback) override;
void SetPinCode(const std::string& pincode) override;
void SetPasskey(uint32 passkey) override;
void ConfirmPairing() override;
void RejectPairing() override;
void CancelPairing() override;
void Disconnect(const base::Closure& callback,
const ErrorCallback& error_callback) override;
void Forget(const ErrorCallback& error_callback) override;
void ConnectToService(
const device::BluetoothUUID& uuid,
const ConnectToServiceCallback& callback,
const ConnectToServiceErrorCallback& error_callback) override;
void ConnectToServiceInsecurely(
const device::BluetoothUUID& uuid,
const ConnectToServiceCallback& callback,
const ConnectToServiceErrorCallback& error_callback) override;
void CreateGattConnection(
const GattConnectionCallback& callback,
const ConnectErrorCallback& error_callback) override;
void Pair(device::BluetoothDevice::PairingDelegate* pairing_delegate,
const base::Closure& callback,
const ConnectErrorCallback& error_callback) override;
// Creates a pairing object with the given delegate |pairing_delegate| and
// establishes it as the pairing context for this device. All pairing-related
// method calls will be forwarded to this object until it is released.
BluetoothPairingChromeOS* BeginPairing(
BluetoothDevice::PairingDelegate* pairing_delegate);
// Releases the current pairing object, any pairing-related method calls will
// be ignored.
void EndPairing();
// Returns the current pairing object or NULL if no pairing is in progress.
BluetoothPairingChromeOS* GetPairing() const;
// Returns the object path of the device.
const dbus::ObjectPath& object_path() const { return object_path_; }
// Returns the adapter which owns this device instance.
BluetoothAdapterChromeOS* adapter() const;
protected:
// BluetoothDevice override
std::string GetDeviceName() const override;
void CreateGattConnectionImpl() override;
void DisconnectGatt() override;
private:
friend class BluetoothAdapterChromeOS;
BluetoothDeviceChromeOS(
BluetoothAdapterChromeOS* adapter,
const dbus::ObjectPath& object_path,
scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
scoped_refptr<device::BluetoothSocketThread> socket_thread);
~BluetoothDeviceChromeOS() override;
// bluez::BluetoothGattServiceClient::Observer overrides.
void GattServiceAdded(const dbus::ObjectPath& object_path) override;
void GattServiceRemoved(const dbus::ObjectPath& object_path) override;
// Called by dbus:: on completion of the D-Bus method call to get the
// connection attributes of the current connection to the device.
void OnGetConnInfo(const ConnectionInfoCallback& callback,
int16 rssi,
int16 transmit_power,
int16 max_transmit_power);
void OnGetConnInfoError(const ConnectionInfoCallback& callback,
const std::string& error_name,
const std::string& error_message);
// Internal method to initiate a connection to this device, and methods called
// by dbus:: on completion of the D-Bus method call.
void ConnectInternal(bool after_pairing,
const base::Closure& callback,
const ConnectErrorCallback& error_callback);
void OnConnect(bool after_pairing,
const base::Closure& callback);
void OnCreateGattConnection(const GattConnectionCallback& callback);
void OnConnectError(bool after_pairing,
const ConnectErrorCallback& error_callback,
const std::string& error_name,
const std::string& error_message);
// Called by dbus:: on completion of the D-Bus method call to pair the device,
// made inside |Connect()|.
void OnPairDuringConnect(const base::Closure& callback,
const ConnectErrorCallback& error_callback);
void OnPairDuringConnectError(const ConnectErrorCallback& error_callback,
const std::string& error_name,
const std::string& error_message);
// Called by dbus: on completion of the D-Bus method call to pair the device,
// made inside |Pair()|.
void OnPair(const base::Closure& callback);
void OnPairError(const ConnectErrorCallback& error_callback,
const std::string& error_name,
const std::string& error_message);
// Called by dbus:: on failure of the D-Bus method call to cancel pairing,
// there is no matching completion call since we don't do anything special
// in that case.
void OnCancelPairingError(const std::string& error_name,
const std::string& error_message);
// Internal method to set the device as trusted. Trusted devices can connect
// to us automatically, and we can connect to them after rebooting; it also
// causes the device to be remembered by the stack even if not paired.
// |success| to the callback indicates whether or not the request succeeded.
void SetTrusted();
void OnSetTrusted(bool success);
// Called by dbus:: on completion of the D-Bus method call to disconnect the
// device.
void OnDisconnect(const base::Closure& callback);
void OnDisconnectError(const ErrorCallback& error_callback,
const std::string& error_name,
const std::string& error_message);
// Called by dbus:: on failure of the D-Bus method call to unpair the device;
// there is no matching completion call since this object is deleted in the
// process of unpairing.
void OnForgetError(const ErrorCallback& error_callback,
const std::string& error_name,
const std::string& error_message);
// The dbus object path of the device object.
dbus::ObjectPath object_path_;
// Number of ongoing calls to Connect().
int num_connecting_calls_;
// True if the connection monitor has been started, tracking the connection
// RSSI and TX power.
bool connection_monitor_started_;
// UI thread task runner and socket thread object used to create sockets.
scoped_refptr<base::SequencedTaskRunner> ui_task_runner_;
scoped_refptr<device::BluetoothSocketThread> socket_thread_;
// During pairing this is set to an object that we don't own, but on which
// we can make method calls to request, display or confirm PIN Codes and
// Passkeys. Generally it is the object that owns this one.
scoped_ptr<BluetoothPairingChromeOS> pairing_;
// 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<BluetoothDeviceChromeOS> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(BluetoothDeviceChromeOS);
};
} // namespace chromeos
#endif // DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_CHROMEOS_H
|
