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
|
// 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 CHROME_BROWSER_EXTENSIONS_API_BLUETOOTH_BLUETOOTH_EVENT_ROUTER_H_
#define CHROME_BROWSER_EXTENSIONS_API_BLUETOOTH_BLUETOOTH_EVENT_ROUTER_H_
#include <map>
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_vector.h"
#include "base/memory/weak_ptr.h"
#include "chrome/common/extensions/api/bluetooth.h"
#include "device/bluetooth/bluetooth_adapter.h"
#include "device/bluetooth/bluetooth_adapter_factory.h"
#include "device/bluetooth/bluetooth_socket.h"
class Profile;
namespace device {
class BluetoothDevice;
class BluetoothProfile;
} // namespace device
namespace extensions {
class ExtensionBluetoothEventRouter
: public device::BluetoothAdapter::Observer {
public:
explicit ExtensionBluetoothEventRouter(Profile* profile);
virtual ~ExtensionBluetoothEventRouter();
// Returns true if adapter_ has been initialized for testing or bluetooth
// adapter is available for the current platform.
bool IsBluetoothSupported() const;
void GetAdapter(
const device::BluetoothAdapterFactory::AdapterCallback& callback);
// Called when a bluetooth event listener is added.
void OnListenerAdded();
// Called when a bluetooth event listener is removed.
void OnListenerRemoved();
// Register the BluetoothSocket |socket| for use by the extensions system.
// This class will hold onto the socket for its lifetime, or until
// ReleaseSocket is called for the socket. Returns an id for the socket.
int RegisterSocket(scoped_refptr<device::BluetoothSocket> socket);
// Release the BluetoothSocket corresponding to |id|. Returns true if
// the socket was found and released, false otherwise.
bool ReleaseSocket(int id);
// Add the BluetoothProfile |bluetooth_profile| for use by the extension
// system. This class will hold onto the profile for its lifetime, or until
// RemoveProfile is called for the profile.
void AddProfile(const std::string& uuid,
device::BluetoothProfile* bluetooth_profile);
// Unregister the BluetoothProfile corersponding to |uuid| and release the
// object from this class.
void RemoveProfile(const std::string& uuid);
// Returns true if the BluetoothProfile corresponding to |uuid| is already
// registered.
bool HasProfile(const std::string& uuid) const;
// Returns the BluetoothProfile that corresponds to |uuid|. It returns NULL
// if the BluetoothProfile with |uuid| does not exist.
device::BluetoothProfile* GetProfile(const std::string& uuid) const;
// Get the BluetoothSocket corresponding to |id|.
scoped_refptr<device::BluetoothSocket> GetSocket(int id);
// Sets whether this Profile is responsible for the discovering state of the
// adapter.
void SetResponsibleForDiscovery(bool responsible);
bool IsResponsibleForDiscovery() const;
// Sets whether or not DeviceAdded events will be dispatched to extensions.
void SetSendDiscoveryEvents(bool should_send);
// Dispatch an event that takes a device as a parameter to all renderers.
void DispatchDeviceEvent(
const char* event_name,
const extensions::api::bluetooth::Device& device);
// Dispatch an event that takes a connection socket as a parameter to the
// extension that registered the profile that the socket has connected to.
void DispatchConnectionEvent(const std::string& extension_id,
const std::string& uuid,
const device::BluetoothDevice* device,
scoped_refptr<device::BluetoothSocket> socket);
// Override from device::BluetoothAdapter::Observer
virtual void AdapterPresentChanged(device::BluetoothAdapter* adapter,
bool present) OVERRIDE;
virtual void AdapterPoweredChanged(device::BluetoothAdapter* adapter,
bool has_power) OVERRIDE;
virtual void AdapterDiscoveringChanged(device::BluetoothAdapter* adapter,
bool discovering) OVERRIDE;
virtual void DeviceAdded(device::BluetoothAdapter* adapter,
device::BluetoothDevice* device) OVERRIDE;
// Exposed for testing.
void SetAdapterForTest(device::BluetoothAdapter* adapter) {
adapter_ = adapter;
}
private:
void InitializeAdapterIfNeeded();
void InitializeAdapter(scoped_refptr<device::BluetoothAdapter> adapter);
void MaybeReleaseAdapter();
void DispatchAdapterStateEvent();
bool send_discovery_events_;
bool responsible_for_discovery_;
Profile* profile_;
scoped_refptr<device::BluetoothAdapter> adapter_;
int num_event_listeners_;
// The next id to use for referring to a BluetoothSocket. We avoid using
// the fd of the socket because we don't want to leak that information to
// the extension javascript.
int next_socket_id_;
typedef std::map<int, scoped_refptr<device::BluetoothSocket> > SocketMap;
SocketMap socket_map_;
typedef ScopedVector<extensions::api::bluetooth::Device>
DeviceList;
DeviceList discovered_devices_;
// A map that maps uuids to the BluetoothProfile objects.
typedef std::map<std::string, device::BluetoothProfile*> BluetoothProfileMap;
BluetoothProfileMap bluetooth_profile_map_;
base::WeakPtrFactory<ExtensionBluetoothEventRouter> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(ExtensionBluetoothEventRouter);
};
} // namespace extensions
#endif // CHROME_BROWSER_EXTENSIONS_API_BLUETOOTH_BLUETOOTH_EVENT_ROUTER_H_
|
