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
|
// Copyright (c) 2012 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_DBUS_BLUEZ_DBUS_MANAGER_H_
#define DEVICE_BLUETOOTH_DBUS_BLUEZ_DBUS_MANAGER_H_
#include <string>
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "device/bluetooth/bluetooth_export.h"
#include "device/bluetooth/dbus/bluetooth_dbus_client_bundle.h"
namespace dbus {
class Bus;
class ObjectPath;
class Response;
class ErrorResponse;
} // namespace dbus
namespace bluez {
// Style Note: Clients are sorted by names.
class BluetoothAdapterClient;
class BluetoothAgentManagerClient;
class BluetoothDeviceClient;
class BluetoothGattCharacteristicClient;
class BluetoothGattDescriptorClient;
class BluetoothGattManagerClient;
class BluetoothGattServiceClient;
class BluetoothInputClient;
class BluetoothLEAdvertisingManagerClient;
class BluetoothMediaClient;
class BluetoothMediaTransportClient;
class BluetoothProfileManagerClient;
class BluezDBusManagerSetter;
// BluezDBusManager manages manages D-Bus connections and D-Bus clients, which
// depend on the D-Bus thread to ensure the right order of shutdowns for
// the D-Bus thread, the D-Bus connections, and the D-Bus clients.
//
// CALLBACKS IN D-BUS CLIENTS:
//
// D-Bus clients managed by BluezDBusManagerSetter are guaranteed to be deleted
// after the D-Bus thread so the clients don't need to worry if new
// incoming messages arrive from the D-Bus thread during shutdown of the
// clients. The UI message loop is not running during the shutdown hence
// the UI message loop won't post tasks to D-BUS clients during the
// shutdown. However, to be extra cautious, clients should use
// WeakPtrFactory when creating callbacks that run on UI thread. See
// session_manager_client.cc for examples.
//
class DEVICE_BLUETOOTH_EXPORT BluezDBusManager {
public:
// Sets the global instance. Must be called before any calls to Get().
// We explicitly initialize and shut down the global object, rather than
// making it a Singleton, to ensure clean startup and shutdown.
// This will initialize real, stub, or fake DBusClients depending on
// command-line arguments, whether Object Manager is supported and
// whether this process runs in a real or test environment.
static void Initialize(dbus::Bus* bus, bool use_dbus_fakes);
// Returns a BluezDBusManagerSetter instance that allows tests to
// replace individual D-Bus clients with their own implementations.
// Also initializes the main BluezDBusManager for testing if necessary.
static scoped_ptr<BluezDBusManagerSetter> GetSetterForTesting();
// Returns true if BluezDBusManager has been initialized. Call this to
// avoid initializing + shutting down BluezDBusManager more than once.
static bool IsInitialized();
// Destroys the global instance.
static void Shutdown();
// Gets the global instance. Initialize() must be called first.
static BluezDBusManager* Get();
// Returns various D-Bus bus instances, owned by BluezDBusManager.
dbus::Bus* GetSystemBus();
// Returns true once we know whether Object Manager is supported or not.
// Until this method returns true, no classes should try to use the
// DBus Clients.
bool IsObjectManagerSupportKnown() { return object_manager_support_known_; }
// Calls |callback| once we know whether Object Manager is supported or not.
void CallWhenObjectManagerSupportIsKnown(base::Closure callback);
// Returns true if Object Manager is supported.
bool IsObjectManagerSupported() { return object_manager_supported_; }
// Returns true if |client| is fake.
bool IsUsingFakes() { return client_bundle_->IsUsingFakes(); }
// All returned objects are owned by BluezDBusManager. Do not use these
// pointers after BluezDBusManager has been shut down.
BluetoothAdapterClient* GetBluetoothAdapterClient();
BluetoothLEAdvertisingManagerClient* GetBluetoothLEAdvertisingManagerClient();
BluetoothAgentManagerClient* GetBluetoothAgentManagerClient();
BluetoothDeviceClient* GetBluetoothDeviceClient();
BluetoothGattCharacteristicClient* GetBluetoothGattCharacteristicClient();
BluetoothGattDescriptorClient* GetBluetoothGattDescriptorClient();
BluetoothGattManagerClient* GetBluetoothGattManagerClient();
BluetoothGattServiceClient* GetBluetoothGattServiceClient();
BluetoothInputClient* GetBluetoothInputClient();
BluetoothMediaClient* GetBluetoothMediaClient();
BluetoothMediaTransportClient* GetBluetoothMediaTransportClient();
BluetoothProfileManagerClient* GetBluetoothProfileManagerClient();
private:
friend class BluezDBusManagerSetter;
// Creates a new BluezDBusManager using the DBusClients set in
// |client_bundle|.
explicit BluezDBusManager(dbus::Bus* bus, bool use_stubs);
~BluezDBusManager();
// Creates a global instance of BluezDBusManager. Cannot be called more than
// once.
static void CreateGlobalInstance(dbus::Bus* bus, bool use_stubs);
void OnObjectManagerSupported(dbus::Response* response);
void OnObjectManagerNotSupported(dbus::ErrorResponse* response);
// Initializes all currently stored DBusClients with the system bus and
// performs additional setup.
void InitializeClients();
dbus::Bus* bus_;
scoped_ptr<BluetoothDBusClientBundle> client_bundle_;
base::Closure object_manager_support_known_callback_;
bool object_manager_support_known_;
bool object_manager_supported_;
// 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<BluezDBusManager> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(BluezDBusManager);
};
class DEVICE_BLUETOOTH_EXPORT BluezDBusManagerSetter {
public:
~BluezDBusManagerSetter();
void SetBluetoothAdapterClient(scoped_ptr<BluetoothAdapterClient> client);
void SetBluetoothLEAdvertisingManagerClient(
scoped_ptr<BluetoothLEAdvertisingManagerClient> client);
void SetBluetoothAgentManagerClient(
scoped_ptr<BluetoothAgentManagerClient> client);
void SetBluetoothDeviceClient(scoped_ptr<BluetoothDeviceClient> client);
void SetBluetoothGattCharacteristicClient(
scoped_ptr<BluetoothGattCharacteristicClient> client);
void SetBluetoothGattDescriptorClient(
scoped_ptr<BluetoothGattDescriptorClient> client);
void SetBluetoothGattManagerClient(
scoped_ptr<BluetoothGattManagerClient> client);
void SetBluetoothGattServiceClient(
scoped_ptr<BluetoothGattServiceClient> client);
void SetBluetoothInputClient(scoped_ptr<BluetoothInputClient> client);
void SetBluetoothMediaClient(scoped_ptr<BluetoothMediaClient> client);
void SetBluetoothMediaTransportClient(
scoped_ptr<BluetoothMediaTransportClient> client);
void SetBluetoothProfileManagerClient(
scoped_ptr<BluetoothProfileManagerClient> client);
private:
friend class BluezDBusManager;
BluezDBusManagerSetter();
DISALLOW_COPY_AND_ASSIGN(BluezDBusManagerSetter);
};
} // namespace bluez
#endif // DEVICE_BLUETOOTH_DBUS_BLUEZ_DBUS_MANAGER_H_
|
