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
|
// 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:
// 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);
virtual ~Properties();
};
// 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) {}
};
virtual ~BluetoothAdapterClient();
// 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;
// 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_
|
