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
|
// 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 CHROMEOS_DBUS_BLUETOOTH_ADAPTER_CLIENT_H_
#define CHROMEOS_DBUS_BLUETOOTH_ADAPTER_CLIENT_H_
#include <string>
#include <vector>
#include "base/callback.h"
#include "base/observer_list.h"
#include "base/values.h"
#include "chromeos/chromeos_export.h"
#include "chromeos/dbus/dbus_client.h"
#include "dbus/object_path.h"
#include "dbus/property.h"
namespace chromeos {
// BluetoothAdapterClient is used to communicate with objects representing
// local Bluetooth Adapters.
class CHROMEOS_EXPORT BluetoothAdapterClient : public DBusClient {
public:
// A DiscoveryFilter represents a filter passed to the SetDiscoveryFilter
// method.
struct DiscoveryFilter {
DiscoveryFilter();
~DiscoveryFilter();
// Copy content of |filter| into this filter
void CopyFrom(const DiscoveryFilter& filter);
scoped_ptr<std::vector<std::string>> uuids;
scoped_ptr<int16_t> rssi;
scoped_ptr<uint16_t> pathloss;
scoped_ptr<std::string> transport;
DISALLOW_COPY_AND_ASSIGN(DiscoveryFilter);
};
// Structure of properties associated with bluetooth adapters.
struct Properties : public dbus::PropertySet {
// The Bluetooth device address of the adapter. Read-only.
dbus::Property<std::string> address;
// The Bluetooth system name, generally derived from the hostname.
dbus::Property<std::string> name;
// The Bluetooth friendly name of the adapter, unlike remote devices,
// this property can be changed to change the presentation for when
// the adapter is discoverable.
dbus::Property<std::string> alias;
// The Bluetooth class of the adapter device. Read-only.
dbus::Property<uint32> bluetooth_class;
// Whether the adapter radio is powered.
dbus::Property<bool> powered;
// Whether the adapter is discoverable by other Bluetooth devices.
// |discovering_timeout| is used to automatically disable after a time
// period.
dbus::Property<bool> discoverable;
// Whether the adapter accepts incoming pairing requests from other
// Bluetooth devices. |pairable_timeout| is used to automatically disable
// after a time period.
dbus::Property<bool> pairable;
// The timeout in seconds to cease accepting incoming pairing requests
// after |pairable| is set to true. Zero means adapter remains pairable
// forever.
dbus::Property<uint32> pairable_timeout;
// The timeout in seconds to cease the adapter being discoverable by
// other Bluetooth devices after |discoverable| is set to true. Zero
// means adapter remains discoverable forever.
dbus::Property<uint32> discoverable_timeout;
// Indicates that the adapter is discovering other Bluetooth Devices.
// Read-only. Use StartDiscovery() to begin discovery.
dbus::Property<bool> discovering;
// List of 128-bit UUIDs that represent the available local services.
// Read-only.
dbus::Property<std::vector<std::string>> uuids;
// Local Device ID information in Linux kernel modalias format. Read-only.
dbus::Property<std::string> modalias;
Properties(dbus::ObjectProxy* object_proxy,
const std::string& interface_name,
const PropertyChangedCallback& callback);
~Properties() override;
};
// Interface for observing changes from a local bluetooth adapter.
class Observer {
public:
virtual ~Observer() {}
// Called when the adapter with object path |object_path| is added to the
// system.
virtual void AdapterAdded(const dbus::ObjectPath& object_path) {}
// Called when the adapter with object path |object_path| is removed from
// the system.
virtual void AdapterRemoved(const dbus::ObjectPath& object_path) {}
// Called when the adapter with object path |object_path| has a
// change in value of the property named |property_name|.
virtual void AdapterPropertyChanged(const dbus::ObjectPath& object_path,
const std::string& property_name) {}
};
~BluetoothAdapterClient() override;
// Adds and removes observers for events on all local bluetooth
// adapters. Check the |object_path| parameter of observer methods to
// determine which adapter is issuing the event.
virtual void AddObserver(Observer* observer) = 0;
virtual void RemoveObserver(Observer* observer) = 0;
// Returns the list of adapter object paths known to the system.
virtual std::vector<dbus::ObjectPath> GetAdapters() = 0;
// Obtain the properties for the adapter with object path |object_path|,
// any values should be copied if needed.
virtual Properties* GetProperties(const dbus::ObjectPath& object_path) = 0;
// The ErrorCallback is used by adapter methods to indicate failure.
// It receives two arguments: the name of the error in |error_name| and
// an optional message in |error_message|.
typedef base::Callback<void(const std::string& error_name,
const std::string& error_message)> ErrorCallback;
// Starts a device discovery on the adapter with object path |object_path|.
virtual void StartDiscovery(const dbus::ObjectPath& object_path,
const base::Closure& callback,
const ErrorCallback& error_callback) = 0;
// Cancels any previous device discovery on the adapter with object path
// |object_path|.
virtual void StopDiscovery(const dbus::ObjectPath& object_path,
const base::Closure& callback,
const ErrorCallback& error_callback) = 0;
// Removes from the adapter with object path |object_path| the remote
// device with object path |object_path| from the list of known devices
// and discards any pairing information.
virtual void RemoveDevice(const dbus::ObjectPath& object_path,
const dbus::ObjectPath& device_path,
const base::Closure& callback,
const ErrorCallback& error_callback) = 0;
// Sets the device discovery filter on the adapter with object path
// |object_path|. When this method is called with no filter parameter, filter
// is removed.
// SetDiscoveryFilter can be called before StartDiscovery. It is useful when
// client will create first discovery session, to ensure that proper scan
// will be started right after call to StartDiscovery.
virtual void SetDiscoveryFilter(const dbus::ObjectPath& object_path,
const DiscoveryFilter& discovery_filter,
const base::Closure& callback,
const ErrorCallback& error_callback) = 0;
// Creates the instance.
static BluetoothAdapterClient* Create();
// Constants used to indicate exceptional error conditions.
static const char kNoResponseError[];
static const char kUnknownAdapterError[];
protected:
BluetoothAdapterClient();
private:
DISALLOW_COPY_AND_ASSIGN(BluetoothAdapterClient);
};
} // namespace chromeos
#endif // CHROMEOS_DBUS_BLUETOOTH_ADAPTER_CLIENT_H_
|
