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
|
//
// Copyright 2015 Google, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#pragma once
#include <atomic>
#include <functional>
#include <map>
#include <mutex>
#include <base/macros.h>
#include <bluetooth/uuid.h>
#include "service/bluetooth_instance.h"
#include "service/common/bluetooth/low_energy_constants.h"
#include "service/common/bluetooth/scan_filter.h"
#include "service/common/bluetooth/scan_result.h"
#include "service/common/bluetooth/scan_settings.h"
#include "service/hal/bluetooth_gatt_interface.h"
namespace bluetooth {
struct ConnComparator {
bool operator()(const RawAddress& a, const RawAddress& b) const {
return memcmp(a.address, b.address, RawAddress::kLength) < 0;
}
};
class Adapter;
// A LowEnergyClient represents an application's handle to perform various
// Bluetooth Low Energy GAP operations. Instances cannot be created directly and
// should be obtained through the factory.
class LowEnergyClient : private hal::BluetoothGattInterface::ClientObserver,
public BluetoothInstance {
public:
// The Delegate interface is used to notify asynchronous events related to BLE
// GAP operations.
class Delegate {
public:
Delegate() = default;
virtual ~Delegate() = default;
// Called asynchronously to notify the delegate of connection state change
virtual void OnConnectionState(LowEnergyClient* client, int status,
const char* address, bool connected) = 0;
// Called asynchronously to notify the delegate of mtu change
virtual void OnMtuChanged(LowEnergyClient* client, int status,
const char* address, int mtu) = 0;
private:
DISALLOW_COPY_AND_ASSIGN(Delegate);
};
// The destructor automatically unregisters this client instance from the
// stack.
~LowEnergyClient() override;
// Assigns a delegate to this instance. |delegate| must out-live this
// LowEnergyClient instance.
void SetDelegate(Delegate* delegate);
// Callback type used to return the result of asynchronous operations below.
using StatusCallback = std::function<void(BLEStatus)>;
// Initiates a BLE connection do device with address |address|. If
// |is_direct| is set, use direct connect procedure. Return true on success
//, false otherwise.
bool Connect(const std::string& address, bool is_direct);
// Disconnect from previously connected BLE device with address |address|.
// Return true on success, false otherwise.
bool Disconnect(const std::string& address);
// Sends request to set MTU to |mtu| for device with address |address|.
// Return true on success, false otherwise.
bool SetMtu(const std::string& address, int mtu);
// BluetoothClientInstace overrides:
const Uuid& GetAppIdentifier() const override;
int GetInstanceId() const override;
private:
friend class LowEnergyClientFactory;
// Constructor shouldn't be called directly as instances are meant to be
// obtained from the factory.
LowEnergyClient(Adapter& adapter, const Uuid& uuid, int client_id);
// BluetoothGattInterface::ClientObserver overrides:
void ConnectCallback(hal::BluetoothGattInterface* gatt_iface, int conn_id,
int status, int client_id,
const RawAddress& bda) override;
void DisconnectCallback(hal::BluetoothGattInterface* gatt_iface, int conn_id,
int status, int client_id,
const RawAddress& bda) override;
void MtuChangedCallback(hal::BluetoothGattInterface* gatt_iface, int conn_id,
int status, int mtu) override;
// Calls and clears the pending callbacks.
void InvokeAndClearStartCallback(BLEStatus status);
void InvokeAndClearStopCallback(BLEStatus status);
// Raw pointer to the Bluetooth Adapter.
Adapter& adapter_;
// See getters above for documentation.
Uuid app_identifier_;
int client_id_;
// Raw handle to the Delegate, which must outlive this LowEnergyClient
// instance.
std::mutex delegate_mutex_;
Delegate* delegate_;
// Protects device connection related members below.
std::mutex connection_fields_lock_;
// Maps bluetooth address to connection id
// TODO(jpawlowski): change type to bimap
std::map<const RawAddress, int, ConnComparator> connection_ids_;
DISALLOW_COPY_AND_ASSIGN(LowEnergyClient);
};
// LowEnergyClientFactory is used to register and obtain a per-application
// LowEnergyClient instance. Users should call RegisterInstance to obtain their
// own unique LowEnergyClient instance that has been registered with the
// Bluetooth stack.
class LowEnergyClientFactory
: private hal::BluetoothGattInterface::ClientObserver,
public BluetoothInstanceFactory {
public:
// Don't construct/destruct directly except in tests. Instead, obtain a handle
// from an Adapter instance.
explicit LowEnergyClientFactory(Adapter& adapter);
~LowEnergyClientFactory() override;
// BluetoothInstanceFactory override:
bool RegisterInstance(const Uuid& uuid,
const RegisterCallback& callback) override;
private:
friend class LowEnergyClient;
// BluetoothGattInterface::ClientObserver overrides:
void RegisterClientCallback(hal::BluetoothGattInterface* gatt_iface,
int status, int client_id,
const bluetooth::Uuid& app_uuid) override;
// Map of pending calls to register.
std::mutex pending_calls_lock_;
std::map<Uuid, RegisterCallback> pending_calls_;
// Raw pointer to the Adapter that owns this factory.
Adapter& adapter_;
DISALLOW_COPY_AND_ASSIGN(LowEnergyClientFactory);
};
} // namespace bluetooth
|
