1 //
2 // Copyright 2015 Google, Inc.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at:
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include "service/low_energy_advertiser.h"
18
19 #include "service/adapter.h"
20 #include "service/logging_helpers.h"
21 #include "stack/include/bt_types.h"
22 #include "stack/include/hcidefs.h"
23
24 #include <base/bind.h>
25 #include <base/bind_helpers.h>
26 #include <base/callback.h>
27 #include <base/logging.h>
28
29 using std::lock_guard;
30 using std::mutex;
31
32 namespace bluetooth {
33
34 namespace {
35
GetBLEStatus(int status)36 BLEStatus GetBLEStatus(int status) {
37 if (status == BT_STATUS_FAIL) return BLE_STATUS_FAILURE;
38
39 return static_cast<BLEStatus>(status);
40 }
41
42 // The Bluetooth Core Specification defines time interval (e.g. Page Scan
43 // Interval, Advertising Interval, etc) units as 0.625 milliseconds (or 1
44 // Baseband slot). The HAL advertising functions expect the interval in this
45 // unit. This function maps an AdvertiseSettings::Mode value to the
46 // corresponding time unit.
GetAdvertisingIntervalUnit(AdvertiseSettings::Mode mode)47 int GetAdvertisingIntervalUnit(AdvertiseSettings::Mode mode) {
48 int ms;
49
50 switch (mode) {
51 case AdvertiseSettings::MODE_BALANCED:
52 ms = kAdvertisingIntervalMediumMs;
53 break;
54 case AdvertiseSettings::MODE_LOW_LATENCY:
55 ms = kAdvertisingIntervalLowMs;
56 break;
57 case AdvertiseSettings::MODE_LOW_POWER:
58 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
59 default:
60 ms = kAdvertisingIntervalHighMs;
61 break;
62 }
63
64 // Convert milliseconds to Bluetooth units.
65 return (ms * 1000) / 625;
66 }
67
GetAdvertisingTxPower(AdvertiseSettings::TxPowerLevel tx_power)68 int8_t GetAdvertisingTxPower(AdvertiseSettings::TxPowerLevel tx_power) {
69 int8_t power;
70
71 switch (tx_power) {
72 case AdvertiseSettings::TX_POWER_LEVEL_ULTRA_LOW:
73 power = -21;
74 break;
75 case AdvertiseSettings::TX_POWER_LEVEL_LOW:
76 power = -15;
77 break;
78 case AdvertiseSettings::TX_POWER_LEVEL_MEDIUM:
79 power = -7;
80 break;
81 case AdvertiseSettings::TX_POWER_LEVEL_HIGH:
82 FALLTHROUGH_INTENDED; /* FALLTHROUGH */
83 default:
84 power = 1;
85 break;
86 }
87
88 return power;
89 }
90
GetAdvertiseParams(const AdvertiseSettings & settings,bool has_scan_rsp,AdvertiseParameters * out_params)91 void GetAdvertiseParams(const AdvertiseSettings& settings, bool has_scan_rsp,
92 AdvertiseParameters* out_params) {
93 CHECK(out_params);
94
95 out_params->min_interval = GetAdvertisingIntervalUnit(settings.mode());
96 out_params->max_interval =
97 out_params->min_interval + kAdvertisingIntervalDeltaUnit;
98
99 if (settings.connectable())
100 out_params->advertising_event_properties =
101 kAdvertisingEventTypeLegacyConnectable;
102 else if (has_scan_rsp)
103 out_params->advertising_event_properties =
104 kAdvertisingEventTypeLegacyScannable;
105 else
106 out_params->advertising_event_properties =
107 kAdvertisingEventTypeLegacyNonConnectable;
108
109 out_params->channel_map = kAdvertisingChannelAll;
110 out_params->tx_power = GetAdvertisingTxPower(settings.tx_power_level());
111
112 // TODO: expose those new setting through AdvertiseSettings
113 out_params->primary_advertising_phy = 0x01;
114 out_params->secondary_advertising_phy = 0x01;
115 out_params->scan_request_notification_enable = 0;
116 }
117
118 } // namespace
119
120 // LowEnergyAdvertiser implementation
121 // ========================================================
122
LowEnergyAdvertiser(const Uuid & uuid,int advertiser_id)123 LowEnergyAdvertiser::LowEnergyAdvertiser(const Uuid& uuid, int advertiser_id)
124 : app_identifier_(uuid),
125 advertiser_id_(advertiser_id),
126 adv_started_(false),
127 adv_start_callback_(nullptr),
128 adv_stop_callback_(nullptr) {}
129
~LowEnergyAdvertiser()130 LowEnergyAdvertiser::~LowEnergyAdvertiser() {
131 // Automatically unregister the advertiser.
132 VLOG(1) << "LowEnergyAdvertiser unregistering advertiser: " << advertiser_id_;
133
134 // Stop advertising and ignore the result.
135 hal::BluetoothGattInterface::Get()->GetAdvertiserHALInterface()->Enable(
136 advertiser_id_, false, base::DoNothing(), 0, 0, base::DoNothing());
137 hal::BluetoothGattInterface::Get()->GetAdvertiserHALInterface()->Unregister(
138 advertiser_id_);
139 }
140
StartAdvertising(const AdvertiseSettings & settings,const AdvertiseData & advertise_data,const AdvertiseData & scan_response,const StatusCallback & callback)141 bool LowEnergyAdvertiser::StartAdvertising(const AdvertiseSettings& settings,
142 const AdvertiseData& advertise_data,
143 const AdvertiseData& scan_response,
144 const StatusCallback& callback) {
145 VLOG(2) << __func__;
146 lock_guard<mutex> lock(adv_fields_lock_);
147
148 if (IsAdvertisingStarted()) {
149 LOG(WARNING) << "Already advertising";
150 return false;
151 }
152
153 if (IsStartingAdvertising()) {
154 LOG(WARNING) << "StartAdvertising already pending";
155 return false;
156 }
157
158 if (!advertise_data.IsValid()) {
159 LOG(ERROR) << "Invalid advertising data";
160 return false;
161 }
162
163 if (!scan_response.IsValid()) {
164 LOG(ERROR) << "Invalid scan response data";
165 return false;
166 }
167
168 advertise_settings_ = settings;
169
170 AdvertiseParameters params;
171 GetAdvertiseParams(settings, !scan_response.data().empty(), ¶ms);
172
173 hal::BluetoothGattInterface::Get()
174 ->GetAdvertiserHALInterface()
175 ->StartAdvertising(
176 advertiser_id_,
177 base::Bind(&LowEnergyAdvertiser::EnableCallback,
178 base::Unretained(this), true, advertiser_id_),
179 params, advertise_data.data(), scan_response.data(),
180 settings.timeout().InSeconds(),
181 base::Bind(&LowEnergyAdvertiser::EnableCallback,
182 base::Unretained(this), false, advertiser_id_));
183 ;
184
185 adv_start_callback_.reset(new StatusCallback(callback));
186 return true;
187 }
188
StopAdvertising(const StatusCallback & callback)189 bool LowEnergyAdvertiser::StopAdvertising(const StatusCallback& callback) {
190 VLOG(2) << __func__;
191 lock_guard<mutex> lock(adv_fields_lock_);
192
193 if (!IsAdvertisingStarted()) {
194 LOG(ERROR) << "Not advertising";
195 return false;
196 }
197
198 if (IsStoppingAdvertising()) {
199 LOG(ERROR) << "StopAdvertising already pending";
200 return false;
201 }
202
203 hal::BluetoothGattInterface::Get()->GetAdvertiserHALInterface()->Enable(
204 advertiser_id_, false,
205 base::Bind(&LowEnergyAdvertiser::EnableCallback, base::Unretained(this),
206 false, advertiser_id_),
207 0, 0, base::Bind(&LowEnergyAdvertiser::EnableCallback,
208 base::Unretained(this), false, advertiser_id_));
209
210 // OK to set this at the end since we're still holding |adv_fields_lock_|.
211 adv_stop_callback_.reset(new StatusCallback(callback));
212
213 return true;
214 }
215
IsAdvertisingStarted() const216 bool LowEnergyAdvertiser::IsAdvertisingStarted() const {
217 return adv_started_.load();
218 }
219
IsStartingAdvertising() const220 bool LowEnergyAdvertiser::IsStartingAdvertising() const {
221 return !IsAdvertisingStarted() && adv_start_callback_;
222 }
223
IsStoppingAdvertising() const224 bool LowEnergyAdvertiser::IsStoppingAdvertising() const {
225 return IsAdvertisingStarted() && adv_stop_callback_;
226 }
227
GetAppIdentifier() const228 const Uuid& LowEnergyAdvertiser::GetAppIdentifier() const {
229 return app_identifier_;
230 }
231
GetInstanceId() const232 int LowEnergyAdvertiser::GetInstanceId() const { return advertiser_id_; }
233
EnableCallback(bool enable,uint8_t advertiser_id,uint8_t status)234 void LowEnergyAdvertiser::EnableCallback(bool enable, uint8_t advertiser_id,
235 uint8_t status) {
236 if (advertiser_id != advertiser_id_) return;
237
238 lock_guard<mutex> lock(adv_fields_lock_);
239
240 VLOG(1) << __func__ << "advertiser_id: " << advertiser_id
241 << " status: " << status << " enable: " << enable;
242
243 if (enable) {
244 CHECK(adv_start_callback_);
245 CHECK(!adv_stop_callback_);
246
247 // Terminate operation in case of error.
248 if (status != BT_STATUS_SUCCESS) {
249 LOG(ERROR) << "Failed to enable multi-advertising";
250 InvokeAndClearStartCallback(GetBLEStatus(status));
251 return;
252 }
253
254 // All pending tasks are complete. Report success.
255 adv_started_ = true;
256 InvokeAndClearStartCallback(BLE_STATUS_SUCCESS);
257
258 } else {
259 CHECK(!adv_start_callback_);
260 CHECK(adv_stop_callback_);
261
262 if (status == BT_STATUS_SUCCESS) {
263 VLOG(1) << "Multi-advertising stopped for advertiser_id: "
264 << advertiser_id;
265 adv_started_ = false;
266 } else {
267 LOG(ERROR) << "Failed to stop multi-advertising";
268 }
269
270 InvokeAndClearStopCallback(GetBLEStatus(status));
271 }
272 }
273
InvokeAndClearStartCallback(BLEStatus status)274 void LowEnergyAdvertiser::InvokeAndClearStartCallback(BLEStatus status) {
275 // We allow NULL callbacks.
276 if (*adv_start_callback_) (*adv_start_callback_)(status);
277
278 adv_start_callback_ = nullptr;
279 }
280
InvokeAndClearStopCallback(BLEStatus status)281 void LowEnergyAdvertiser::InvokeAndClearStopCallback(BLEStatus status) {
282 // We allow NULL callbacks.
283 if (*adv_stop_callback_) (*adv_stop_callback_)(status);
284
285 adv_stop_callback_ = nullptr;
286 }
287
288 // LowEnergyAdvertiserFactory implementation
289 // ========================================================
290
LowEnergyAdvertiserFactory()291 LowEnergyAdvertiserFactory::LowEnergyAdvertiserFactory() {}
292
~LowEnergyAdvertiserFactory()293 LowEnergyAdvertiserFactory::~LowEnergyAdvertiserFactory() {}
294
RegisterInstance(const Uuid & app_uuid,const RegisterCallback & callback)295 bool LowEnergyAdvertiserFactory::RegisterInstance(
296 const Uuid& app_uuid, const RegisterCallback& callback) {
297 VLOG(1) << __func__;
298 lock_guard<mutex> lock(pending_calls_lock_);
299
300 if (pending_calls_.find(app_uuid) != pending_calls_.end()) {
301 LOG(ERROR) << "Low-Energy advertiser with given Uuid already registered - "
302 << "Uuid: " << app_uuid.ToString();
303 return false;
304 }
305
306 BleAdvertiserInterface* hal_iface =
307 hal::BluetoothGattInterface::Get()->GetAdvertiserHALInterface();
308
309 VLOG(1) << __func__ << " calling register!";
310 hal_iface->RegisterAdvertiser(
311 base::Bind(&LowEnergyAdvertiserFactory::RegisterAdvertiserCallback,
312 base::Unretained(this), callback, app_uuid));
313 VLOG(1) << __func__ << " call finished!";
314
315 pending_calls_.insert(app_uuid);
316
317 return true;
318 }
319
RegisterAdvertiserCallback(const RegisterCallback & callback,const Uuid & app_uuid,uint8_t advertiser_id,uint8_t status)320 void LowEnergyAdvertiserFactory::RegisterAdvertiserCallback(
321 const RegisterCallback& callback, const Uuid& app_uuid,
322 uint8_t advertiser_id, uint8_t status) {
323 VLOG(1) << __func__;
324 lock_guard<mutex> lock(pending_calls_lock_);
325
326 auto iter = pending_calls_.find(app_uuid);
327 if (iter == pending_calls_.end()) {
328 VLOG(1) << "Ignoring callback for unknown app_id: " << app_uuid.ToString();
329 return;
330 }
331
332 // No need to construct a advertiser if the call wasn't successful.
333 std::unique_ptr<LowEnergyAdvertiser> advertiser;
334 BLEStatus result = BLE_STATUS_FAILURE;
335 if (status == BT_STATUS_SUCCESS) {
336 advertiser.reset(new LowEnergyAdvertiser(app_uuid, advertiser_id));
337
338 result = BLE_STATUS_SUCCESS;
339 }
340
341 // Notify the result via the result callback.
342 callback(result, app_uuid, std::move(advertiser));
343
344 pending_calls_.erase(iter);
345 }
346
347 } // namespace bluetooth
348