1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ble_advertiser_impl.h"
17
18 #include <algorithm>
19
20 #include "ble_adapter.h"
21 #include "ble_defs.h"
22 #include "ble_feature.h"
23 #include "ble_properties.h"
24 #include "ble_utils.h"
25 #include "securec.h"
26
27 namespace OHOS {
28 namespace bluetooth {
29 struct BleAdvertiserImpl::impl {
30 std::map<uint8_t, BleAdvertiserImplWrapData> advHandleSettingDatas_ {};
31 std::recursive_mutex mutex_ {};
32 /// For RPA 15 minitues change bluetooth address
33 std::mutex rpamutex_ {};
34 std::condition_variable cvfull_ {};
35 std::vector<uint8_t> advCreateHandles_ {};
36 bool operationLast_ = false;
37 /// Gap callback pointer
38 /// Advertising parameters
39 BleAdvParams advParams_ {};
40 std::queue<BleAdvertiserImplOp> advHandleQue_ {};
41 };
42
BleAdvertiserImpl( IBleAdvertiserCallback &callback, IAdapterBle &bleAdapter, utility::Dispatcher &dispatch)43 BleAdvertiserImpl::BleAdvertiserImpl(
44 IBleAdvertiserCallback &callback, IAdapterBle &bleAdapter, utility::Dispatcher &dispatch)
45 : callback_(&callback),
46 bleAdapter_(&bleAdapter),
47 dispatcher_(&dispatch),
48 pimpl(std::make_unique<BleAdvertiserImpl::impl>())
49 {
50 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
51
52 pimpl->advParams_.advMinInterval = BLE_ADV_MIN_INTERVAL;
53 pimpl->advParams_.advMaxInterval = BLE_ADV_MAX_INTERVAL;
54 pimpl->advParams_.advType = ADV_TYPE_IND;
55 pimpl->advParams_.channelMap = ADV_CHNL_ALL;
56 pimpl->advParams_.advFilterPolicy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
57 pimpl->advParams_.peerAddrType = BLE_ADDR_TYPE_PUBLIC;
58 }
59
~BleAdvertiserImpl()60 BleAdvertiserImpl::~BleAdvertiserImpl()
61 {
62 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
63
64 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); iter++) {
65 if (iter->second.timer_ != nullptr) {
66 iter->second.timer_->Stop();
67 iter->second.timer_ = nullptr;
68 }
69 }
70 pimpl->advHandleSettingDatas_.clear();
71 while (!pimpl->advHandleQue_.empty()) {
72 pimpl->advHandleQue_.pop();
73 }
74 }
75
AdvSetParamResult(uint8_t status, void *context)76 void BleAdvertiserImpl::AdvSetParamResult(uint8_t status, void *context)
77 {
78 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
79
80 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
81 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
82 bleAdvertiser->dispatcher_->PostTask(std::bind(
83 &BleAdvertiserImpl::HandleGapEvent, bleAdvertiser, BLE_GAP_ADV_PARAM_SET_COMPLETE_EVT, status, 0));
84 }
85 }
86
AdvReadTxPower(uint8_t status, int8_t txPower, void *context)87 void BleAdvertiserImpl::AdvReadTxPower(uint8_t status, int8_t txPower, void *context)
88 {
89 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
90
91 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
92 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
93 bleAdvertiser->dispatcher_->PostTask(std::bind(
94 &BleAdvertiserImpl::HandleGapEvent, bleAdvertiser, BLE_GAP_ADV_READ_TXPOWER_EVT, status, txPower));
95 }
96 }
97
AdvSetDataResult(uint8_t status, void *context)98 void BleAdvertiserImpl::AdvSetDataResult(uint8_t status, void *context)
99 {
100 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
101
102 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
103 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
104 bleAdvertiser->dispatcher_->PostTask(
105 std::bind(&BleAdvertiserImpl::HandleGapEvent, bleAdvertiser, BLE_GAP_ADV_DATA_SET_COMPLETE_EVT, status, 0));
106 }
107 }
108
AdvSetScanRspDataResult(uint8_t status, void *context)109 void BleAdvertiserImpl::AdvSetScanRspDataResult(uint8_t status, void *context)
110 {
111 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
112
113 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
114 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
115 bleAdvertiser->dispatcher_->PostTask(std::bind(
116 &BleAdvertiserImpl::HandleGapEvent, bleAdvertiser, BLE_GAP_ADV_SCAN_RSP_DATA_SET_COMPLETE_EVT, status, 0));
117 }
118 }
119
AdvSetEnableResult(uint8_t status, void *context)120 void BleAdvertiserImpl::AdvSetEnableResult(uint8_t status, void *context)
121 {
122 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
123
124 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
125 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
126 bleAdvertiser->dispatcher_->PostTask(
127 std::bind(&BleAdvertiserImpl::AdvSetEnableResultTask, bleAdvertiser, status));
128 (static_cast<BleAdapter *>(bleAdvertiser->bleAdapter_))->NotifyAllWaitContinue();
129 }
130 }
131
AdvSetEnableResultTask(uint8_t status)132 void BleAdvertiserImpl::AdvSetEnableResultTask(uint8_t status)
133 {
134 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
135
136 uint8_t tempAdvStatus = ADV_STATUS_DEFAULT;
137 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
138 if (pimpl->advHandleQue_.empty()) {
139 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,error", __func__);
140 return;
141 }
142 auto iter = pimpl->advHandleSettingDatas_.find(pimpl->advHandleQue_.front().advHandle);
143 if (iter != pimpl->advHandleSettingDatas_.end()) {
144 tempAdvStatus = pimpl->advHandleQue_.front().advOpStatus;
145 } else {
146 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,error", __func__);
147 pimpl->advHandleQue_.pop();
148 return;
149 }
150 switch (tempAdvStatus) {
151 case ADV_STATUS_STARTING:
152 HandleGapEvent(BLE_GAP_ADV_START_COMPLETE_EVT, status, 0);
153 break;
154 case ADV_STATUS_STOPING:
155 HandleGapEvent(BLE_GAP_ADV_STOP_COMPLETE_EVT, status, 0);
156 break;
157 default:
158 pimpl->advHandleQue_.pop();
159 break;
160 }
161 }
162
GetAdvertisingStatus() const163 int BleAdvertiserImpl::GetAdvertisingStatus() const
164 {
165 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
166
167 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
168 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); iter++) {
169 if (iter->second.advStatus_ == ADVERTISE_FAILED_ALREADY_STARTED) {
170 return ADVERTISE_FAILED_ALREADY_STARTED;
171 }
172 }
173 return ADVERTISE_NOT_STARTED;
174 }
175
ReStartLegacyAdvertising() const176 void BleAdvertiserImpl::ReStartLegacyAdvertising() const
177 {
178 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
179
180 int status = AdapterManager::GetInstance()->GetState(BTTransport::ADAPTER_BLE);
181 if (status != BTStateID::STATE_TURN_ON) {
182 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Bluetooth adapter is invalid.", __func__);
183 return;
184 }
185
186 int advHandle = BLE_LEGACY_ADVERTISING_HANDLE;
187 auto iter = pimpl->advHandleSettingDatas_.find(advHandle);
188 if (iter == pimpl->advHandleSettingDatas_.end()) {
189 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advHandle);
190 return;
191 }
192
193 if (iter->second.advStatus_ != ADVERTISE_FAILED_ALREADY_STARTED) {
194 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Advertising has not started.", __func__);
195 return;
196 }
197
198 iter->second.advStatus_ = ADVERTISE_FAILED_ALREADY_STARTED;
199
200 /// Start adv
201 int ret = SetAdvEnableToGap(true);
202 if (ret != BT_SUCCESS) {
203 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
204 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop advertising failed! handle = %u.", __func__, iter->first);
205 } else {
206 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STARTING));
207 }
208 }
209
CheckAdvertiserPara(const BleAdvertiserSettingsImpl &settings, const BleAdvertiserDataImpl &advData, const BleAdvertiserDataImpl &scanResponse) const210 int BleAdvertiserImpl::CheckAdvertiserPara(const BleAdvertiserSettingsImpl &settings,
211 const BleAdvertiserDataImpl &advData, const BleAdvertiserDataImpl &scanResponse) const
212 {
213 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
214
215 int status = AdapterManager::GetInstance()->GetState(BTTransport::ADAPTER_BLE);
216 if (status != BTStateID::STATE_TURN_ON) {
217 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Bluetooth adapter is invalid.", __func__);
218 return BT_BAD_STATUS;
219 }
220
221 bool isLegacyMode = settings.IsLegacyMode();
222 if (isLegacyMode) {
223 if (advData.GetPayload().length() > BLE_LEGACY_ADV_DATA_LEN_MAX) {
224 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Legacy advertising data too big.", __func__);
225 return BT_BAD_PARAM;
226 }
227 if (scanResponse.GetPayload().length() > BLE_LEGACY_ADV_DATA_LEN_MAX) {
228 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Legacy scan response data too big.", __func__);
229 return BT_BAD_PARAM;
230 }
231 } else {
232 bool isCodedPhySupported = BleFeature::GetInstance().IsLeCodedPhySupported();
233 bool is2MPhySupported = BleFeature::GetInstance().IsLe2MPhySupported();
234 int primaryPhy = settings.GetPrimaryPhy();
235 int secondaryPhy = settings.GetSecondaryPhy();
236
237 if ((!isCodedPhySupported) && (primaryPhy == PHY_LE_CODED)) {
238 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Unsupported primary coded PHY selected.", __func__);
239 return BT_BAD_PARAM;
240 }
241
242 if ((!is2MPhySupported) && (secondaryPhy == PHY_LE_CODED)) {
243 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Unsupported primary 2M PHY selected.", __func__);
244 return BT_BAD_PARAM;
245 }
246
247 size_t maxData = GetMaxAdvertisingDataLength(settings);
248 if (advData.GetPayload().length() > maxData) {
249 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Advertising data too big.", __func__);
250 return BT_BAD_PARAM;
251 }
252
253 if (scanResponse.GetPayload().length() > maxData) {
254 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Scan response data too big.", __func__);
255 return BT_BAD_PARAM;
256 }
257 }
258 return BT_SUCCESS;
259 }
260
StartAdvertising(const BleAdvertiserSettingsImpl &settings, const BleAdvertiserDataImpl &advData, const BleAdvertiserDataImpl &scanResponse, uint8_t advHandle)261 void BleAdvertiserImpl::StartAdvertising(const BleAdvertiserSettingsImpl &settings,
262 const BleAdvertiserDataImpl &advData, const BleAdvertiserDataImpl &scanResponse, uint8_t advHandle)
263 {
264 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
265
266 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
267 int advStatus = ADVERTISE_NOT_STARTED;
268 auto iter = pimpl->advHandleSettingDatas_.find(advHandle);
269 if (iter != pimpl->advHandleSettingDatas_.end()) {
270 advStatus = iter->second.advStatus_;
271 }
272
273 if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
274 if (advStatus == ADVERTISE_FAILED_ALREADY_STARTED) {
275 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Extend Advertising has started already.", __func__);
276 callback_->OnStartResultEvent(ADVERTISE_FAILED_ALREADY_STARTED, advHandle);
277 return;
278 }
279 } else {
280 if (advStatus == ADVERTISE_FAILED_ALREADY_STARTED) {
281 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Advertising has started already.", __func__);
282 callback_->OnStartResultEvent(ADVERTISE_FAILED_ALREADY_STARTED, advHandle);
283 return;
284 }
285 }
286
287 int ret = CheckAdvertiserPara(settings, advData, scanResponse);
288 if (ret != BT_SUCCESS) {
289 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Check adv parameter failed!.", __func__);
290 callback_->OnStartResultEvent(
291 ret == BT_BAD_PARAM ? ADVERTISE_FAILED_DATA_TOO_LARGE : ADVERTISE_FAILED_INTERNAL_ERROR,
292 advHandle,
293 BLE_ADV_START_FAILED_OP_CODE);
294 return;
295 }
296
297 advStatus = ADVERTISE_FAILED_ALREADY_STARTED;
298 if (iter != pimpl->advHandleSettingDatas_.end()) {
299 if (iter->second.timer_ != nullptr) {
300 iter->second.timer_->Stop();
301 iter->second.timer_ = nullptr;
302 }
303 pimpl->advHandleSettingDatas_.erase(iter);
304 }
305 pimpl->advHandleSettingDatas_.insert(
306 std::make_pair(advHandle, BleAdvertiserImplWrapData(settings, advData, scanResponse, advStatus)));
307 StartLegacyAdvOrExAdv(advHandle);
308 }
309
StartLegacyAdvOrExAdv(uint8_t advHandle)310 void BleAdvertiserImpl::StartLegacyAdvOrExAdv(uint8_t advHandle)
311 {
312 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
313 if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
314 ExtentAdvertising(advHandle);
315 } else {
316 LegacyAdvertising(advHandle);
317 }
318 }
319
LegacyAdvertising(uint8_t advHandle)320 void BleAdvertiserImpl::LegacyAdvertising(uint8_t advHandle)
321 {
322 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
323
324 auto iter = pimpl->advHandleSettingDatas_.find(advHandle);
325 int ret = RegisterCallbackToGap();
326 if (ret != BT_SUCCESS) {
327 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
328 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set ble roles failed!.", __func__);
329 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advHandle);
330 return;
331 }
332
333 ret = SetAdvParamToGap(iter->second.settings_);
334 if (ret != BT_SUCCESS) {
335 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
336 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv parameter to gap failed!.", __func__);
337 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advHandle);
338 } else {
339 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_SET_PARA));
340 }
341 }
342
ExtentAdvertising(uint8_t advHandle)343 void BleAdvertiserImpl::ExtentAdvertising(uint8_t advHandle)
344 {
345 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
346
347 auto iter = pimpl->advHandleSettingDatas_.find(advHandle);
348 int ret = RegisterExAdvCallbackToGap();
349 if (ret != BT_SUCCESS) {
350 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
351 LOG_ERROR("Register ex adv gap callback failed!");
352 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advHandle, BLE_ADV_START_FAILED_OP_CODE);
353 RemoveAdvHandle(advHandle);
354 return;
355 }
356
357 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_SET_PARA));
358 ret = SetExAdvParamToGap(advHandle, iter->second.settings_);
359 if (ret != BT_SUCCESS) {
360 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
361 LOG_ERROR("Set adv parameter to gap failed!");
362 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advHandle, BLE_ADV_START_FAILED_OP_CODE);
363 RemoveAdvHandle(advHandle);
364 }
365 }
366
StopAdvertising(uint8_t advHandle) const367 void BleAdvertiserImpl::StopAdvertising(uint8_t advHandle) const
368 {
369 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
370
371 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
372 auto iter = pimpl->advHandleSettingDatas_.find(advHandle);
373 if (iter == pimpl->advHandleSettingDatas_.end()) {
374 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invlalid handle! %u.", __func__, advHandle);
375 return;
376 }
377
378 if (iter->second.advStatus_ == ADVERTISE_NOT_STARTED) {
379 LOG_ERROR("[BleAdvertiserImpl] %{public}s:StopAdvertising failed! %u.", __func__, advHandle);
380 return;
381 }
382
383 int ret;
384
385 iter->second.stopAllAdvType_ = STOP_ADV_TYPE_SINGLE;
386 if (iter->second.timer_ != nullptr) {
387 iter->second.timer_->Stop();
388 iter->second.timer_ = nullptr;
389 }
390 if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
391 ret = SetExAdvEnableToGap(advHandle, false);
392 } else {
393 ret = SetAdvEnableToGap(false);
394 }
395 if (ret != BT_SUCCESS) {
396 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
397 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop advertising failed!.", __func__);
398 } else {
399 iter->second.advStatus_ = ADVERTISE_NOT_STARTED;
400 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STOPING));
401 LOG_DEBUG("[BleAdvertiserImpl] %{public}s:Stop advertising success!.", __func__);
402 }
403 }
404
StartOrStopAllAdvertising(const STOP_ALL_ADV_TYPE &stopAllAdvType, bool isStartAdv) const405 void BleAdvertiserImpl::StartOrStopAllAdvertising(const STOP_ALL_ADV_TYPE &stopAllAdvType, bool isStartAdv) const
406 {
407 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
408 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
409 if (isStartAdv) {
410 StartAllAdvertising(stopAllAdvType, isStartAdv);
411 } else {
412 StopAllAdvertising(stopAllAdvType, isStartAdv);
413 }
414 }
415
StartAllAdvertising(const STOP_ALL_ADV_TYPE &stopAllAdvType, bool isStartAdv) const416 void BleAdvertiserImpl::StartAllAdvertising(const STOP_ALL_ADV_TYPE &stopAllAdvType, bool isStartAdv) const
417 {
418 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
419 if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
420 int ret = SetExAdvBatchEnableToGap(isStartAdv);
421 if (ret != BT_SUCCESS) {
422 UpdateAllAdvertisingStatus(ADVERTISE_FAILED_INTERNAL_ERROR);
423 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start extend advertising failed!.", __func__);
424 } else {
425 UpdateAllAdvertisingStatus(ADVERTISE_FAILED_ALREADY_STARTED);
426 auto iter = pimpl->advHandleSettingDatas_.begin();
427 pimpl->advHandleQue_.push(BleAdvertiserImplOp(iter->first,
428 isStartAdv?ADV_STATUS_STARTING:ADV_STATUS_STOPING));
429 for (; iter != pimpl->advHandleSettingDatas_.end(); ++iter) {
430 iter->second.stopAllAdvType_ = stopAllAdvType;
431 }
432 LOG_DEBUG("[BleAdvertiserImpl] %{public}s:Start extend advertising success!.", __func__);
433 }
434 } else {
435 auto iter = pimpl->advHandleSettingDatas_.begin();
436 if (iter == pimpl->advHandleSettingDatas_.end()) {
437 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start legacy advertising failed!.", __func__);
438 return;
439 }
440
441 int ret = SetAdvEnableToGap(isStartAdv);
442 if (ret != BT_SUCCESS) {
443 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
444 LOG_ERROR("[BleAdvertiserImpl] %{public}s:start advertising failed! handle = %u.", __func__, iter->first);
445 } else {
446 iter->second.stopAllAdvType_ = stopAllAdvType;
447 iter->second.advStatus_ = ADVERTISE_FAILED_ALREADY_STARTED;
448 pimpl->advHandleQue_.push(BleAdvertiserImplOp(iter->first,
449 isStartAdv?ADV_STATUS_STARTING:ADV_STATUS_STOPING));
450 LOG_DEBUG("[BleAdvertiserImpl] %{public}s:start advertising success!.", __func__);
451 }
452 }
453 }
454
StopAllAdvertising(const STOP_ALL_ADV_TYPE &stopAllAdvType, bool isStartAdv) const455 void BleAdvertiserImpl::StopAllAdvertising(const STOP_ALL_ADV_TYPE &stopAllAdvType, bool isStartAdv) const
456 {
457 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
458 if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
459 int ret = SetExAdvBatchEnableToGap(isStartAdv);
460 if (ret != BT_SUCCESS) {
461 UpdateAllAdvertisingStatus(ADVERTISE_FAILED_INTERNAL_ERROR);
462 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop extend advertising failed!.", __func__);
463 } else {
464 if (stopAllAdvType != STOP_ADV_TYPE_RESOLVING_LIST) {
465 UpdateAllAdvertisingStatus(ADVERTISE_NOT_STARTED);
466 }
467 auto iter = pimpl->advHandleSettingDatas_.begin();
468 pimpl->advHandleQue_.push(BleAdvertiserImplOp(iter->first,
469 isStartAdv?ADV_STATUS_STARTING:ADV_STATUS_STOPING));
470 for (; iter != pimpl->advHandleSettingDatas_.end(); ++iter) {
471 iter->second.stopAllAdvType_ = stopAllAdvType;
472 }
473 LOG_DEBUG("[BleAdvertiserImpl] %{public}s:Stop extend advertising success!.", __func__);
474 }
475 } else {
476 auto iter = pimpl->advHandleSettingDatas_.begin();
477 if (iter == pimpl->advHandleSettingDatas_.end()) {
478 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop legacy advertising failed!.", __func__);
479 return;
480 }
481
482 int ret = SetAdvEnableToGap(isStartAdv);
483 if (ret != BT_SUCCESS) {
484 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
485 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop advertising failed! handle = %u.", __func__, iter->first);
486 } else {
487 iter->second.stopAllAdvType_ = stopAllAdvType;
488 pimpl->advHandleQue_.push(BleAdvertiserImplOp(iter->first,
489 isStartAdv?ADV_STATUS_STARTING:ADV_STATUS_STOPING));
490 if (stopAllAdvType != STOP_ADV_TYPE_RESOLVING_LIST) {
491 iter->second.advStatus_ = ADVERTISE_NOT_STARTED;
492 }
493 LOG_DEBUG("[BleAdvertiserImpl] %{public}s:Stop advertising success!.", __func__);
494 }
495 }
496 }
497
UpdateAllAdvertisingStatus(const ADVERTISE_STATUS &advStatus) const498 void BleAdvertiserImpl::UpdateAllAdvertisingStatus(const ADVERTISE_STATUS &advStatus) const
499 {
500 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
501 auto iter = pimpl->advHandleSettingDatas_.begin();
502 for (; iter != pimpl->advHandleSettingDatas_.end(); ++iter) {
503 iter->second.advStatus_ = advStatus;
504 }
505 }
506
Close(uint8_t advHandle) const507 void BleAdvertiserImpl::Close(uint8_t advHandle) const
508 {
509 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
510
511 auto iter = pimpl->advHandleSettingDatas_.find(advHandle);
512 if (iter == pimpl->advHandleSettingDatas_.end()) {
513 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invlalid handle! %u.", __func__, advHandle);
514 return;
515 }
516
517 StopAdvertising(advHandle);
518 iter->second.advStatus_ = ADVERTISE_NOT_STARTED;
519 }
520
RegisterCallbackToGap()521 int BleAdvertiserImpl::RegisterCallbackToGap()
522 {
523 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
524 GapAdvCallback advCallbacks_ {};
525 advCallbacks_.advReadTxPower = &BleAdvertiserImpl::AdvReadTxPower;
526 advCallbacks_.advSetDataResult = &BleAdvertiserImpl::AdvSetDataResult;
527 advCallbacks_.advSetEnableResult = &BleAdvertiserImpl::AdvSetEnableResult;
528 advCallbacks_.advSetParamResult = &BleAdvertiserImpl::AdvSetParamResult;
529 advCallbacks_.advSetScanRspDataResult = &BleAdvertiserImpl::AdvSetScanRspDataResult;
530
531 return GAPIF_RegisterAdvCallback(&advCallbacks_, this);
532 }
533
ExAdvSetRandAddrResult(uint8_t status, void *context)534 void BleAdvertiserImpl::ExAdvSetRandAddrResult(uint8_t status, void *context)
535 {
536 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
537
538 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
539 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
540 bleAdvertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::HandleGapExAdvEvent,
541 bleAdvertiser,
542 BLE_GAP_EX_ADV_SET_RAND_ADDR_RESULT_EVT,
543 status,
544 0,
545 0));
546 }
547 }
548
ExAdvSetParamResult(uint8_t status, uint8_t selectTxPower, void *context)549 void BleAdvertiserImpl::ExAdvSetParamResult(uint8_t status, uint8_t selectTxPower, void *context)
550 {
551 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
552
553 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
554 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
555 bleAdvertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::HandleGapExAdvEvent,
556 bleAdvertiser,
557 BLE_GAP_EX_ADV_PARAM_SET_COMPLETE_EVT,
558 status,
559 selectTxPower,
560 0));
561 }
562 }
563
ExAdvSetDataResult(uint8_t status, void *context)564 void BleAdvertiserImpl::ExAdvSetDataResult(uint8_t status, void *context)
565 {
566 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
567
568 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
569 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
570 bleAdvertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::HandleGapExAdvEvent,
571 bleAdvertiser,
572 BLE_GAP_EX_ADV_DATA_SET_COMPLETE_EVT,
573 status,
574 0,
575 0));
576 }
577 }
578
ExAdvSetScanRspDataResult(uint8_t status, void *context)579 void BleAdvertiserImpl::ExAdvSetScanRspDataResult(uint8_t status, void *context)
580 {
581 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
582
583 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
584 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
585 bleAdvertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::HandleGapExAdvEvent,
586 bleAdvertiser,
587 BLE_GAP_EX_ADV_SCAN_RSP_DATA_SET_COMPLETE_EVT,
588 status,
589 0,
590 0));
591 }
592 }
593
ExAdvSetEnableResult(uint8_t status, void *context)594 void BleAdvertiserImpl::ExAdvSetEnableResult(uint8_t status, void *context)
595 {
596 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
597
598 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
599 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
600 bleAdvertiser->dispatcher_->PostTask(
601 std::bind(&BleAdvertiserImpl::ExAdvSetEnableResultTask, bleAdvertiser, status));
602 (static_cast<BleAdapter *>(bleAdvertiser->bleAdapter_))->NotifyAllWaitContinue();
603 }
604 }
605
ExAdvSetEnableResultTask(uint8_t status)606 void BleAdvertiserImpl::ExAdvSetEnableResultTask(uint8_t status)
607 {
608 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
609
610 uint8_t tempAdvStatus = ADV_STATUS_DEFAULT;
611 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
612 if (pimpl->advHandleQue_.empty()) {
613 LOG_ERROR("[BleAdvertiserImpl] %{public}s,error", __func__);
614 return;
615 }
616 auto iter = pimpl->advHandleSettingDatas_.find(pimpl->advHandleQue_.front().advHandle);
617 if (iter != pimpl->advHandleSettingDatas_.end()) {
618 tempAdvStatus = pimpl->advHandleQue_.front().advOpStatus;
619 } else {
620 LOG_ERROR("[BleAdvertiserImpl] %{public}s,error", __func__);
621 pimpl->advHandleQue_.pop();
622 return;
623 }
624 if (tempAdvStatus == ADV_STATUS_STOPING) {
625 switch (iter->second.stopAllAdvType_) {
626 case STOP_ADV_TYPE_ALL:
627 HandleGapExAdvEvent(BLE_GAP_EX_ALL_ADV_STOP_COMPLETE_EVT, status);
628 break;
629 case STOP_ADV_TYPE_SINGLE:
630 HandleGapExAdvEvent(BLE_GAP_EX_ADV_STOP_COMPLETE_EVT, status);
631 break;
632 case STOP_ADV_TYPE_RESOLVING_LIST:
633 HandleGapExAdvEvent(BLE_GAP_EX_RESOLVING_LIST_ADV_STOP_COMPLETE_EVT, status);
634 break;
635 default:
636 pimpl->advHandleQue_.pop();
637 break;
638 }
639 } else if (tempAdvStatus == ADV_STATUS_STARTING) {
640 switch (iter->second.stopAllAdvType_) {
641 case STOP_ADV_TYPE_ALL:
642 case STOP_ADV_TYPE_SINGLE:
643 HandleGapExAdvEvent(BLE_GAP_EX_ADV_START_COMPLETE_EVT, status);
644 break;
645 case STOP_ADV_TYPE_RESOLVING_LIST:
646 HandleGapExAdvEvent(BLE_GAP_EX_RESOLVING_LIST_ADV_START_COMPLETE_EVT, status);
647 break;
648 default:
649 pimpl->advHandleQue_.pop();
650 break;
651 }
652 }
653 }
654
ExAdvRemoveHandleResult(uint8_t status, void *context)655 void BleAdvertiserImpl::ExAdvRemoveHandleResult(uint8_t status, void *context)
656 {
657 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
658
659 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
660 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
661 bleAdvertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::HandleGapExAdvEvent,
662 bleAdvertiser,
663 BLE_GAP_EX_ADV_REMOVE_HANDLE_RESULT_EVT,
664 status,
665 0,
666 0));
667 (static_cast<BleAdapter *>(bleAdvertiser->bleAdapter_))->NotifyAllWaitContinue();
668 }
669 }
670
ExAdvClearHandleResult(uint8_t status, void *context)671 void BleAdvertiserImpl::ExAdvClearHandleResult(uint8_t status, void *context)
672 {
673 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
674
675 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
676 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
677 bleAdvertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::HandleGapExAdvEvent,
678 bleAdvertiser,
679 BLE_GAP_EX_ADV_CLEAR_HANDLE_RESULT_EVT,
680 status,
681 0,
682 0));
683 (static_cast<BleAdapter *>(bleAdvertiser->bleAdapter_))->NotifyAllWaitContinue();
684 }
685 }
686
ExAdvScanRequestReceived(uint8_t advHandle, const BtAddr *scannerAddr, void *context)687 void BleAdvertiserImpl::ExAdvScanRequestReceived(uint8_t advHandle, const BtAddr *scannerAddr, void *context)
688 {
689 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
690
691 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
692 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
693 bleAdvertiser->dispatcher_->PostTask(std::bind(
694 &BleAdvertiserImpl::HandleGapExAdvEvent, bleAdvertiser, BLE_GAP_EX_ADV_SCAN_REQUEST_RECEIVED_EVT, 0, 0, 0));
695 }
696 }
697
ExAdvTerminatedAdvSet( uint8_t status, uint8_t advHandle, uint16_t connectionHandle, uint8_t completedNumber, void *context)698 void BleAdvertiserImpl::ExAdvTerminatedAdvSet(
699 uint8_t status, uint8_t advHandle, uint16_t connectionHandle, uint8_t completedNumber, void *context)
700 {
701 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
702
703 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
704 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr) && (status == BT_SUCCESS)) {
705 bleAdvertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::HandleGapExAdvEvent,
706 bleAdvertiser,
707 BLE_GAP_EX_ADC_TERMINATED_ADV_SET_EVT,
708 status,
709 0,
710 advHandle));
711 }
712 }
713
RegisterExAdvCallbackToGap()714 int BleAdvertiserImpl::RegisterExAdvCallbackToGap()
715 {
716 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
717 exAdvCallback_.exAdvClearHandleResult = &BleAdvertiserImpl::ExAdvClearHandleResult;
718 exAdvCallback_.exAdvRemoveHandleResult = &BleAdvertiserImpl::ExAdvRemoveHandleResult;
719 exAdvCallback_.exAdvScanRequestReceived = &BleAdvertiserImpl::ExAdvScanRequestReceived;
720 exAdvCallback_.exAdvSetDataResult = &BleAdvertiserImpl::ExAdvSetDataResult;
721 exAdvCallback_.exAdvSetEnableResult = &BleAdvertiserImpl::ExAdvSetEnableResult;
722 exAdvCallback_.exAdvSetParamResult = &BleAdvertiserImpl::ExAdvSetParamResult;
723 exAdvCallback_.exAdvSetRandAddrResult = &BleAdvertiserImpl::ExAdvSetRandAddrResult;
724 exAdvCallback_.exAdvSetScanRspDataResult = &BleAdvertiserImpl::ExAdvSetScanRspDataResult;
725 exAdvCallback_.exAdvTerminatedAdvSet = &BleAdvertiserImpl::ExAdvTerminatedAdvSet;
726 return GAPIF_RegisterExAdvCallback(&exAdvCallback_, this);
727 }
728
DeregisterCallbackToGap()729 int BleAdvertiserImpl::DeregisterCallbackToGap()
730 {
731 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
732
733 int ret;
734 if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
735 ret = GAPIF_DeregisterExAdvCallback();
736 exAdvCallback_ = {};
737 } else {
738 ret = GAPIF_DeregisterAdvCallback();
739 }
740 return ret;
741 }
742
SetAdvParam(const BleAdvertiserSettingsImpl &settings) const743 void BleAdvertiserImpl::SetAdvParam(const BleAdvertiserSettingsImpl &settings) const
744 {
745 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
746
747 SetMaxInterval(settings.GetInterval());
748 SetMinInterval(settings.GetInterval());
749 SetFilter(false, false);
750 SetChannelMap(ADV_CHNL_ALL);
751 }
752
SetAdvParamToGap(const BleAdvertiserSettingsImpl &settings) const753 int BleAdvertiserImpl::SetAdvParamToGap(const BleAdvertiserSettingsImpl &settings) const
754 {
755 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
756
757 SetAdvParam(settings);
758 GapLeAdvParam para;
759 BtAddr addr;
760 (void)memset_s(&addr, sizeof(addr), 0x00, sizeof(addr));
761 para.advIntervalMin = pimpl->advParams_.advMinInterval;
762 para.advIntervalMax = pimpl->advParams_.advMaxInterval;
763 para.advFilterPolicy = pimpl->advParams_.advFilterPolicy;
764 para.advChannelMap = pimpl->advParams_.channelMap;
765 para.peerAddr = &addr;
766
767 uint8_t advType = GAP_ADV_TYPE_CONN_UNDIR;
768 if (!settings.IsConnectable()) {
769 advType = GAP_ADV_TYPE_SCAN_UNDIR;
770 }
771 return GAPIF_LeAdvSetParam(advType, para);
772 }
773
SetExAdvParamToGap(uint8_t advHandle, const BleAdvertiserSettingsImpl &settings) const774 int BleAdvertiserImpl::SetExAdvParamToGap(uint8_t advHandle, const BleAdvertiserSettingsImpl &settings) const
775 {
776 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
777
778 SetAdvParam(settings);
779 GapLeExAdvParam para;
780 BtAddr addr;
781 (void)memset_s(&addr, sizeof(addr), 0x00, sizeof(addr));
782 para.advIntervalMin = pimpl->advParams_.advMinInterval;
783 para.advIntervalMax = pimpl->advParams_.advMaxInterval;
784 para.advFilterPolicy = pimpl->advParams_.advFilterPolicy;
785 para.advChannelMap = pimpl->advParams_.channelMap;
786 para.peerAddr = &addr;
787 para.advSid = 0x01;
788 para.primaryAdvPhy = settings.GetPrimaryPhy();
789 para.secondaryAdvPhy = settings.GetSecondaryPhy();
790 para.scanRequestNotifyEnable = 0x01;
791 para.secondaryAdvMaxSkip = 0x00;
792
793 uint8_t advType = 0;
794 if (settings.IsLegacyMode()) {
795 if (settings.IsConnectable()) {
796 advType |= BLE_LEGACY_ADV_IND_WITH_EX_ADV;
797 } else {
798 advType |= BLE_LEGACY_ADV_NONCONN_IND_WITH_EX_ADV;
799 }
800 } else {
801 if (settings.IsConnectable()) {
802 advType |= GAP_ADVERTISING_PROPERTY_CONNECTABLE | GAP_ADVERTISING_PROPERTY_INCLUDE_TXPOWER;
803 } else {
804 advType |= GAP_ADVERTISING_PROPERTY_SCANABLE | GAP_ADVERTISING_PROPERTY_INCLUDE_TXPOWER;
805 }
806 }
807 return GAPIF_LeExAdvSetParam(advHandle, advType, settings.GetTxPower(), para);
808 }
809
CheckAdvertiserLen(uint8_t payload, uint8_t advType)810 int BleAdvertiserImpl::CheckAdvertiserLen(uint8_t payload, uint8_t advType)
811 {
812 switch (advType) {
813 case BLE_AD_TYPE_FLAG: { /// Data Type: 0x01
814 if (payload > BLE_LEGACY_ADV_DATA_LEN_MAX) {
815 return BT_NOT_SUPPORT;
816 } else {
817 return BT_SUCCESS;
818 }
819 break;
820 }
821 default:
822 break;
823 }
824 return BT_OPERATION_FAILED;
825 }
826
CheckAdvertiserFlag(const std::string &payload) const827 int BleAdvertiserImpl::CheckAdvertiserFlag(const std::string &payload) const
828 {
829 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
830
831 size_t sizeConsumed = 0;
832 bool finished = false;
833 size_t totalLen = payload.size();
834 auto iter = payload.begin();
835
836 while ((!finished) && (iter != payload.end())) {
837 size_t length = *iter;
838 sizeConsumed += 1 + length;
839 if (sizeConsumed > totalLen) {
840 break;
841 }
842 iter++;
843
844 if (length != 0) {
845 uint8_t advType = *iter;
846 iter++;
847 length--;
848
849 int ret = CheckAdvertiserLen(*iter, advType);
850 if (ret != BT_OPERATION_FAILED) {
851 return ret;
852 }
853
854 iter += length;
855 }
856 if (sizeConsumed >= totalLen) {
857 finished = true;
858 }
859 }
860 return BT_SUCCESS;
861 }
862
SetAdvDataToGap( const BleAdvertiserDataImpl &advData, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const863 int BleAdvertiserImpl::SetAdvDataToGap(
864 const BleAdvertiserDataImpl &advData, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const
865 {
866 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
867
868 BleAdvertiserDataImpl data = static_cast<BleAdvertiserDataImpl>(advData);
869
870 int ret = CheckAdvertiserFlag(data.GetPayload());
871 if (ret != BT_SUCCESS) {
872 return ret;
873 }
874
875 // bluetooth localname
876 std::string name = BleProperties::GetInstance().GetLocalName();
877 size_t maxDataLen = GetMaxAdvertisingDataLength(settings);
878 if ((!data.GetPayload().empty()) && (!name.empty()) &&
879 (data.GetPayload().size() + name.size() + BLE_ADV_DATA_FIELD_TYPE_AND_LEN <= maxDataLen)) {
880 data.SetDeviceName(name);
881 }
882 // adv txpower
883 if ((!data.GetPayload().empty()) && (data.GetPayload().size() + BLE_ADV_DATA_BYTE_FIELD_LEN <= maxDataLen)) {
884 data.SetTxPowerLevel(txPowerLevel);
885 }
886
887 if (!data.GetPayload().empty()) {
888 std::vector<uint8_t> legacyDatas;
889 for (size_t i = 0; i < data.GetPayload().size(); i++) {
890 legacyDatas.push_back(data.GetPayload()[i]);
891 }
892 LOG_INFO("[BleAdvertiserImpl] %{public}s: Advertising Data Data=%{public}s %{public}zu",
893 __func__,
894 BleUtils::ConvertIntToHexString(legacyDatas).c_str(),
895 data.GetPayload().size());
896 }
897 return GAPIF_LeAdvSetData(data.GetPayload().size(), (uint8_t *)data.GetPayload().c_str());
898 }
899
ExAdvDataFragment(const BleAdvertiserDataImpl &data) const900 int BleAdvertiserImpl::ExAdvDataFragment(const BleAdvertiserDataImpl &data) const
901 {
902 pimpl->operationLast_ = false;
903 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
904 size_t payloadLen = data.GetPayload().size();
905 std::string payload = data.GetPayload();
906 uint8_t maxlen = BLE_EX_ADV_PAYLOAD_DATA_LEN;
907 uint8_t fragment = GAP_CONTROLLER_SHOULD_NOT_FRAGMENT;
908 int ret = BT_SUCCESS;
909 if ((payloadLen / maxlen == 0) || ((payloadLen / maxlen == 1) && (payloadLen % maxlen == 0))) {
910 uint8_t operation = GAP_ADVERTISING_DATA_OPERATION_COMPLETE;
911 pimpl->operationLast_ = true;
912 ret = GAPIF_LeExAdvSetData(advStartHandle, operation, fragment, payloadLen,
913 reinterpret_cast<uint8_t *>(const_cast<char *>(payload.c_str())));
914 } else if (((payloadLen / maxlen == 1) && (payloadLen % maxlen > 0)) ||
915 ((payloadLen / maxlen == BLE_DIV_RESULT_TWO) && (payloadLen % maxlen == 0))) {
916 std::string advData = payload.substr(0, maxlen);
917 uint8_t operation = GAP_ADVERTISING_DATA_OPERATION_FIRST;
918 ret = GAPIF_LeExAdvSetData(advStartHandle, operation, fragment, maxlen,
919 reinterpret_cast<uint8_t *>(const_cast<char *>(advData.c_str())));
920 pimpl->operationLast_ = true;
921 operation = GAP_ADVERTISING_DATA_OPERATION_LAST;
922 uint8_t length = payloadLen - maxlen;
923 advData = payload.substr(maxlen, payloadLen - maxlen);
924 ret &= GAPIF_LeExAdvSetData(advStartHandle, operation, fragment, length,
925 reinterpret_cast<uint8_t *>(const_cast<char *>(advData.c_str())));
926 } else if (((payloadLen / maxlen == BLE_DIV_RESULT_TWO) && (payloadLen % maxlen > 0)) ||
927 payloadLen / maxlen > BLE_DIV_RESULT_TWO) {
928 uint8_t operation = GAP_ADVERTISING_DATA_OPERATION_FIRST;
929 std::string advData = payload.substr(0, maxlen);
930 ret = GAPIF_LeExAdvSetData(advStartHandle, operation, fragment, maxlen,
931 reinterpret_cast<uint8_t *>(const_cast<char *>(advData.c_str())));
932 operation = GAP_ADVERTISING_DATA_OPERATION_INTERMEDIATE;
933 for (size_t i = 0; i < (payloadLen / maxlen - 1); i++) {
934 if ((i == (payloadLen / maxlen - 1) - 1) && (payloadLen - maxlen * (payloadLen / maxlen) == 0)) {
935 operation = GAP_ADVERTISING_DATA_OPERATION_LAST;
936 }
937 uint8_t length = maxlen * (i + 1);
938 advData = payload.substr(maxlen * (i + 1), maxlen);
939 ret &= GAPIF_LeExAdvSetData(advStartHandle, operation, fragment, length,
940 reinterpret_cast<uint8_t *>(const_cast<char *>(advData.c_str())));
941 }
942 pimpl->operationLast_ = true;
943 if (payloadLen - maxlen * (payloadLen / maxlen) > 0) {
944 ret &= GAPIF_LeExAdvSetData(advStartHandle, GAP_ADVERTISING_DATA_OPERATION_LAST, fragment,
945 payloadLen - maxlen * (payloadLen / maxlen),
946 (uint8_t *)payload.substr(maxlen * (payloadLen / maxlen), payloadLen - maxlen * (payloadLen / maxlen))
947 .c_str());
948 }
949 }
950 return ret;
951 }
952
ExResDataFragment(const BleAdvertiserDataImpl &data) const953 int BleAdvertiserImpl::ExResDataFragment(const BleAdvertiserDataImpl &data) const
954 {
955 pimpl->operationLast_ = false;
956 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
957 size_t payloadLen = data.GetPayload().size();
958 std::string payload = data.GetPayload();
959 uint8_t fragmentPreference = GAP_CONTROLLER_SHOULD_NOT_FRAGMENT;
960 int ret = BT_SUCCESS;
961 int maxlen = BLE_EX_ADV_PAYLOAD_DATA_LEN;
962 if ((payloadLen / maxlen == 0) || ((payloadLen / maxlen == 1) && (payloadLen % maxlen == 0))) {
963 uint8_t operation = GAP_ADVERTISING_DATA_OPERATION_COMPLETE;
964 pimpl->operationLast_ = true;
965
966 ret = GAPIF_LeExAdvSetScanRspData(
967 advStartHandle, operation, fragmentPreference, payloadLen, (uint8_t *)payload.c_str());
968 } else if (((payloadLen / maxlen == 1) && (payloadLen % maxlen > 0)) ||
969 ((payloadLen / maxlen == BLE_DIV_RESULT_TWO) && (payloadLen % maxlen == 0))) {
970 uint8_t operation = GAP_ADVERTISING_DATA_OPERATION_FIRST;
971 ret = GAPIF_LeExAdvSetScanRspData(
972 advStartHandle, operation, fragmentPreference, maxlen, (uint8_t *)payload.substr(maxlen).c_str());
973
974 pimpl->operationLast_ = true;
975 operation = GAP_ADVERTISING_DATA_OPERATION_LAST;
976 ret &= GAPIF_LeExAdvSetScanRspData(advStartHandle,
977 operation, fragmentPreference, payloadLen - maxlen,
978 (uint8_t *)payload.substr(maxlen, payloadLen - maxlen).c_str());
979 } else if (payloadLen / maxlen > 1) {
980 uint8_t operation = GAP_ADVERTISING_DATA_OPERATION_FIRST;
981 ret = GAPIF_LeExAdvSetScanRspData(
982 advStartHandle, operation, fragmentPreference, maxlen, (uint8_t *)payload.substr(maxlen).c_str());
983
984 operation = GAP_ADVERTISING_DATA_OPERATION_INTERMEDIATE;
985 for (size_t i = 0; i < (payloadLen / maxlen - 1); i++) {
986 ret &= GAPIF_LeExAdvSetScanRspData(advStartHandle,
987 operation, fragmentPreference, maxlen * (i + 1),
988 (uint8_t *)payload.substr(maxlen * (i + 1), maxlen).c_str());
989 }
990 pimpl->operationLast_ = true;
991 operation = GAP_ADVERTISING_DATA_OPERATION_LAST;
992 ret &= GAPIF_LeExAdvSetScanRspData(advStartHandle,
993 operation, fragmentPreference,
994 data.GetPayload().size() - maxlen * (payloadLen / maxlen),
995 (uint8_t *)payload.substr(maxlen * (payloadLen / maxlen), payloadLen - maxlen * (payloadLen / maxlen))
996 .c_str());
997 }
998 if (ret == BT_SUCCESS) {
999 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_SCAN_DATA));
1000 }
1001 return ret;
1002 }
1003
SetExAdvDataToGap( const BleAdvertiserDataImpl &advData, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const1004 int BleAdvertiserImpl::SetExAdvDataToGap(
1005 const BleAdvertiserDataImpl &advData, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const
1006 {
1007 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1008
1009 BleAdvertiserDataImpl data = static_cast<BleAdvertiserDataImpl>(advData);
1010 // bluetooth localname
1011 std::string name = BleProperties::GetInstance().GetLocalName();
1012 size_t maxData = GetMaxAdvertisingDataLength(settings);
1013 if ((!data.GetPayload().empty()) && (!name.empty()) && (data.GetPayload().size() + name.size() <= maxData)) {
1014 data.SetDeviceName(name);
1015 }
1016 // adv txpower
1017 if ((!data.GetPayload().empty()) && (data.GetPayload().size() + BLE_ADV_DATA_BYTE_FIELD_LEN <= maxData)) {
1018 data.SetTxPowerLevel(txPowerLevel);
1019 }
1020
1021 if (!data.GetPayload().empty()) {
1022 std::vector<uint8_t> exAdvDatas;
1023 for (size_t i = 0; i < data.GetPayload().size(); i++) {
1024 exAdvDatas.push_back(data.GetPayload()[i]);
1025 }
1026 LOG_INFO("[BleAdvertiserImpl] %{public}s: Advertising Data Data=%{public}s %{public}zu",
1027 __func__,
1028 BleUtils::ConvertIntToHexString(exAdvDatas).c_str(),
1029 data.GetPayload().size());
1030 }
1031 // fragment data
1032 return ExAdvDataFragment(data);
1033 }
1034
SetAdvScanRspDataToGap( const BleAdvertiserDataImpl &scanResponse, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const1035 int BleAdvertiserImpl::SetAdvScanRspDataToGap(
1036 const BleAdvertiserDataImpl &scanResponse, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const
1037 {
1038 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1039
1040 BleAdvertiserDataImpl legacyScandata = static_cast<BleAdvertiserDataImpl>(scanResponse);
1041 // bluetooth localname
1042 std::string name = BleProperties::GetInstance().GetLocalName();
1043 size_t maxDataLen = GetMaxAdvertisingDataLength(settings);
1044 if ((!name.empty()) &&
1045 (legacyScandata.GetPayload().size() + name.size() + BLE_ADV_DATA_FIELD_TYPE_AND_LEN <= maxDataLen)) {
1046 legacyScandata.SetDeviceName(name);
1047 }
1048
1049 if (!legacyScandata.GetPayload().empty()) {
1050 std::vector<uint8_t> legacyDatas;
1051 for (size_t i = 0; i < legacyScandata.GetPayload().size(); i++) {
1052 legacyDatas.push_back(legacyScandata.GetPayload()[i]);
1053 }
1054 LOG_INFO("[BleAdvertiserImpl] %{public}s: Advertising Data Data=%{public}s %{public}zu",
1055 __func__,
1056 BleUtils::ConvertIntToHexString(legacyDatas).c_str(),
1057 legacyScandata.GetPayload().size());
1058 }
1059 return GAPIF_LeAdvSetScanRspData(
1060 legacyScandata.GetPayload().size(), (uint8_t *)legacyScandata.GetPayload().c_str());
1061 }
1062
SetExAdvScanRspDataToGap( const BleAdvertiserDataImpl &scanResponse, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const1063 int BleAdvertiserImpl::SetExAdvScanRspDataToGap(
1064 const BleAdvertiserDataImpl &scanResponse, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const
1065 {
1066 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1067 if (pimpl->advHandleQue_.empty()) {
1068 return BT_BAD_PARAM;
1069 }
1070 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1071 BleAdvertiserDataImpl exAdvScandata = static_cast<BleAdvertiserDataImpl>(scanResponse);
1072 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1073 if (iter == pimpl->advHandleSettingDatas_.end()) {
1074 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1075 return BT_BAD_PARAM;
1076 }
1077 // bluetooth localname
1078 std::string name = BleProperties::GetInstance().GetLocalName();
1079 size_t maxData = GetMaxAdvertisingDataLength(settings);
1080 if ((!iter->second.settings_.IsConnectable()) && (!name.empty()) &&
1081 (exAdvScandata.GetPayload().size() + name.size() + BLE_ADV_DATA_FIELD_TYPE_AND_LEN <= maxData)) {
1082 exAdvScandata.SetDeviceName(name);
1083 }
1084
1085 if (!exAdvScandata.GetPayload().empty()) {
1086 std::vector<uint8_t> exAdvDatas;
1087 for (size_t i = 0; i < exAdvScandata.GetPayload().size(); i++) {
1088 exAdvDatas.push_back(exAdvScandata.GetPayload()[i]);
1089 }
1090 LOG_INFO("[BleAdvertiserImpl] %{public}s: Advertising Data Data=%{public}s %{public}zu",
1091 __func__,
1092 BleUtils::ConvertIntToHexString(exAdvDatas).c_str(),
1093 exAdvScandata.GetPayload().size());
1094 }
1095 // fragment data
1096 return ExResDataFragment(exAdvScandata);
1097 }
1098
SetAdvEnableToGap(bool isEnable) const1099 int BleAdvertiserImpl::SetAdvEnableToGap(bool isEnable) const
1100 {
1101 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1102
1103 return GAPIF_LeAdvSetEnable(isEnable);
1104 }
1105
SetExAdvEnableToGap(uint8_t advHandle, bool isEnable) const1106 int BleAdvertiserImpl::SetExAdvEnableToGap(uint8_t advHandle, bool isEnable) const
1107 {
1108 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1109
1110 GapExAdvSet exAdvSet;
1111 exAdvSet.advHandle = advHandle;
1112 exAdvSet.duration = 0;
1113 exAdvSet.maxExAdvEvt = 0;
1114 return GAPIF_LeExAdvSetEnable(isEnable, 0x01, &exAdvSet);
1115 }
1116
SetExAdvBatchEnableToGap(bool isEnable) const1117 int BleAdvertiserImpl::SetExAdvBatchEnableToGap(bool isEnable) const
1118 {
1119 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1120 std::vector<GapExAdvSet> advSets;
1121 auto iter = pimpl->advHandleSettingDatas_.begin();
1122 for (; iter != pimpl->advHandleSettingDatas_.end(); iter++) {
1123 if (iter->second.timer_ != nullptr) {
1124 iter->second.timer_->Stop();
1125 }
1126
1127 GapExAdvSet exAdvSets;
1128 exAdvSets.advHandle = iter->first;
1129 exAdvSets.duration = 0;
1130 exAdvSets.maxExAdvEvt = 0;
1131 advSets.push_back(exAdvSets);
1132 }
1133 return GAPIF_LeExAdvSetEnable(isEnable, advSets.size(), &advSets[0]);
1134 }
1135
SetMinInterval(uint16_t mininterval) const1136 void BleAdvertiserImpl::SetMinInterval(uint16_t mininterval) const
1137 {
1138 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1139
1140 pimpl->advParams_.advMinInterval = mininterval;
1141 }
1142
SetMaxInterval(uint16_t maxinterval) const1143 void BleAdvertiserImpl::SetMaxInterval(uint16_t maxinterval) const
1144 {
1145 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1146
1147 pimpl->advParams_.advMaxInterval = maxinterval;
1148 }
1149
SetFilter(bool scanReqWhitelistOnly, bool connectWhitelistOnly) const1150 void BleAdvertiserImpl::SetFilter(bool scanReqWhitelistOnly, bool connectWhitelistOnly) const
1151 {
1152 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1153
1154 if ((!scanReqWhitelistOnly) && (!connectWhitelistOnly)) {
1155 pimpl->advParams_.advFilterPolicy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
1156 return;
1157 }
1158 if ((scanReqWhitelistOnly) && (!connectWhitelistOnly)) {
1159 pimpl->advParams_.advFilterPolicy = ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY;
1160 return;
1161 }
1162 if ((!scanReqWhitelistOnly) && (connectWhitelistOnly)) {
1163 pimpl->advParams_.advFilterPolicy = ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST;
1164 return;
1165 }
1166 if ((scanReqWhitelistOnly) && (connectWhitelistOnly)) {
1167 pimpl->advParams_.advFilterPolicy = ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST;
1168 return;
1169 }
1170 }
1171
SetChannelMap(const BLE_ADV_CHANNEL &channelMap) const1172 void BleAdvertiserImpl::SetChannelMap(const BLE_ADV_CHANNEL &channelMap) const
1173 {
1174 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1175
1176 pimpl->advParams_.channelMap = channelMap;
1177 }
1178
CreateAdvertiserSetHandle() const1179 uint8_t BleAdvertiserImpl::CreateAdvertiserSetHandle() const
1180 {
1181 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1182
1183 uint8_t handle = BLE_INVALID_ADVERTISING_HANDLE;
1184 if (!BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
1185 handle = BLE_LEGACY_ADVERTISING_HANDLE;
1186 std::vector<uint8_t>::iterator ret =
1187 std::find(pimpl->advCreateHandles_.begin(), pimpl->advCreateHandles_.end(), handle);
1188 if (ret == pimpl->advCreateHandles_.end()) {
1189 pimpl->advCreateHandles_.push_back(handle);
1190 }
1191 return handle;
1192 }
1193
1194 uint8_t newHandle = BLE_LEGACY_ADVERTISING_HANDLE;
1195 uint8_t end = BleFeature::GetInstance().GetBleExAdvGetMaxHandleNum();
1196 for (; newHandle < end; ++newHandle) {
1197 std::vector<uint8_t>::iterator ret =
1198 std::find(pimpl->advCreateHandles_.begin(), pimpl->advCreateHandles_.end(), newHandle);
1199 if (ret == pimpl->advCreateHandles_.end()) {
1200 pimpl->advCreateHandles_.push_back(newHandle);
1201 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}d", __func__, newHandle);
1202 return newHandle;
1203 }
1204 }
1205 return handle;
1206 }
1207
RemoveAdvHandle(uint8_t handle) const1208 void BleAdvertiserImpl::RemoveAdvHandle(uint8_t handle) const
1209 {
1210 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1211
1212 if (!pimpl->advCreateHandles_.empty()) {
1213 pimpl->advCreateHandles_.erase(remove(pimpl->advCreateHandles_.begin(), pimpl->advCreateHandles_.end(), handle),
1214 pimpl->advCreateHandles_.end());
1215 }
1216
1217 auto iter = pimpl->advHandleSettingDatas_.begin();
1218 while (iter != pimpl->advHandleSettingDatas_.end()) {
1219 if (iter->first == handle) {
1220 if (iter->second.timer_ != nullptr) {
1221 iter->second.timer_->Stop();
1222 iter->second.timer_ = nullptr;
1223 }
1224 pimpl->advHandleSettingDatas_.erase(iter++);
1225 } else {
1226 ++iter;
1227 }
1228 }
1229 }
1230
RemoveAllAdvHandle(int status) const1231 void BleAdvertiserImpl::RemoveAllAdvHandle(int status) const
1232 {
1233 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1234 pimpl->advCreateHandles_.clear();
1235 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); iter++) {
1236 if (iter->second.timer_ != nullptr) {
1237 iter->second.timer_->Stop();
1238 iter->second.timer_ = nullptr;
1239 }
1240 }
1241 pimpl->advHandleSettingDatas_.clear();
1242 }
1243
AddCharacteristicValue(uint8_t adtype, const std::string &data) const1244 void BleAdvertiserImpl::AddCharacteristicValue(uint8_t adtype, const std::string &data) const
1245 {
1246 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1247 if (pimpl->advHandleQue_.empty()) {
1248 return;
1249 }
1250 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1251 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1252 if (iter == pimpl->advHandleSettingDatas_.end()) {
1253 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1254 return;
1255 }
1256 iter->second.advData_.AddCharacteristicValue(adtype, data);
1257 }
1258
GapAdvParamSetCompleteEvt(int status) const1259 void BleAdvertiserImpl::GapAdvParamSetCompleteEvt(int status) const
1260 {
1261 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1262 if (pimpl->advHandleQue_.empty()) {
1263 return;
1264 }
1265 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1266 pimpl->advHandleQue_.pop();
1267 auto paraIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1268 if (paraIter == pimpl->advHandleSettingDatas_.end()) {
1269 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1270 return;
1271 }
1272
1273 if (status != BT_SUCCESS) {
1274 paraIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1275 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1276 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv param failed! %{public}d.", __func__, status);
1277 return;
1278 }
1279 int ret = GAPIF_LeAdvReadTxPower();
1280 if (ret != BT_SUCCESS) {
1281 paraIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1282 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Read adv tx power from gap failed! %{public}d.", __func__, ret);
1283 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1284 } else {
1285 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_READ_TX_POWER));
1286 }
1287 }
1288
GapAdvReadTxPowerEvt(int status, int8_t txPower) const1289 void BleAdvertiserImpl::GapAdvReadTxPowerEvt(int status, int8_t txPower) const
1290 {
1291 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1292
1293 if (pimpl->advHandleQue_.empty()) {
1294 return;
1295 }
1296 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1297 pimpl->advHandleQue_.pop();
1298 auto txPowerIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1299 if (txPowerIter == pimpl->advHandleSettingDatas_.end()) {
1300 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1301 return;
1302 }
1303
1304 if (status != BT_SUCCESS) {
1305 txPowerIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1306 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1307 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Read tx power failed! %{public}d.", __func__, status);
1308 return;
1309 }
1310 int ret = SetAdvDataToGap(txPowerIter->second.advData_, txPowerIter->second.settings_, txPower);
1311 if (ret != BT_SUCCESS) {
1312 txPowerIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1313 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv data to gap failed! %{public}d.", __func__, ret);
1314 callback_->OnStartResultEvent(ADVERTISE_FAILED_DATA_TOO_LARGE, advStartHandle);
1315 } else {
1316 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_ADV_DATA));
1317 }
1318 }
1319
GapAdvDataSetCompleteEvt(int status, int8_t txPower) const1320 void BleAdvertiserImpl::GapAdvDataSetCompleteEvt(int status, int8_t txPower) const
1321 {
1322 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1323
1324 if (pimpl->advHandleQue_.empty()) {
1325 return;
1326 }
1327 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1328 pimpl->advHandleQue_.pop();
1329 auto dataIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1330 if (dataIter == pimpl->advHandleSettingDatas_.end()) {
1331 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1332 return;
1333 }
1334
1335 if (status != BT_SUCCESS) {
1336 dataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1337 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1338 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv data failed! %{public}d.", __func__, status);
1339 return;
1340 }
1341 int ret = SetAdvScanRspDataToGap(dataIter->second.rspData_, dataIter->second.settings_, txPower);
1342 if (ret != BT_SUCCESS) {
1343 dataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1344 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv response data to gap failed! %{public}d.", __func__, ret);
1345 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1346 } else {
1347 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_SCAN_DATA));
1348 }
1349 }
1350
GapAdvScanRspDataSetCompleteEvt(int status) const1351 void BleAdvertiserImpl::GapAdvScanRspDataSetCompleteEvt(int status) const
1352 {
1353 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1354
1355 if (pimpl->advHandleQue_.empty()) {
1356 return;
1357 }
1358 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1359 pimpl->advHandleQue_.pop();
1360 auto scanResIter = pimpl->advHandleSettingDatas_.find(pimpl->advHandleQue_.front().advHandle);
1361 if (scanResIter == pimpl->advHandleSettingDatas_.end()) {
1362 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1363 return;
1364 }
1365
1366 if (status != BT_SUCCESS) {
1367 scanResIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1368 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1369 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set scan response data failed! %{public}d.", __func__, status);
1370 return;
1371 }
1372 int ret = SetAdvEnableToGap(true);
1373 if (ret != BT_SUCCESS) {
1374 scanResIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1375 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed! %{public}d.", __func__, ret);
1376 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1377 } else {
1378 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1379 }
1380 }
1381
GapAdvStartCompleteEvt(int status)1382 void BleAdvertiserImpl::GapAdvStartCompleteEvt(int status)
1383 {
1384 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1385
1386 if (pimpl->advHandleQue_.empty()) {
1387 return;
1388 }
1389 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1390 auto startIter = pimpl->advHandleSettingDatas_.find(pimpl->advHandleQue_.front().advHandle);
1391 pimpl->advHandleQue_.pop();
1392 if (startIter == pimpl->advHandleSettingDatas_.end()) {
1393 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1394 return;
1395 }
1396
1397 if (startIter->second.stopAllAdvType_ == STOP_ADV_TYPE_RESOLVING_LIST) {
1398 if (status != BT_SUCCESS) {
1399 startIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1400 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed! %{public}d.", __func__, status);
1401 } else {
1402 if (startIter->second.timer_ != nullptr) {
1403 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1404 startIter->second.timer_->Start(inerval, true);
1405 }
1406 }
1407 return;
1408 }
1409
1410 if (status != BT_SUCCESS) {
1411 startIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1412 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed! %{public}d.", __func__, status);
1413 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1414 return;
1415 }
1416 callback_->OnStartResultEvent(status, advStartHandle);
1417 if (BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) {
1418 if (startIter->second.timer_ == nullptr) {
1419 startIter->second.timer_ =
1420 std::make_unique<utility::Timer>(std::bind(&TimerCallback, this, advStartHandle));
1421 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1422 startIter->second.timer_->Start(inerval, true);
1423 }
1424 }
1425 (static_cast<BleAdapter *>(bleAdapter_))->OnStartAdvertisingEvt();
1426 }
1427
GapAdvStopCompleteEvt(int status) const1428 void BleAdvertiserImpl::GapAdvStopCompleteEvt(int status) const
1429 {
1430 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1431
1432 if (pimpl->advHandleQue_.empty()) {
1433 return;
1434 }
1435 uint8_t advStopHandle = pimpl->advHandleQue_.front().advHandle;
1436 pimpl->advHandleQue_.pop();
1437 auto stopIter = pimpl->advHandleSettingDatas_.find(advStopHandle);
1438 if (stopIter == pimpl->advHandleSettingDatas_.end()) {
1439 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStopHandle);
1440 return;
1441 }
1442
1443 switch (stopIter->second.stopAllAdvType_) {
1444 case STOP_ADV_TYPE_SINGLE:
1445 break;
1446 case STOP_ADV_TYPE_ALL:
1447 callback_->OnAutoStopAdvEvent(advStopHandle);
1448 break;
1449 case STOP_ADV_TYPE_RESOLVING_LIST:
1450 if (status != BT_SUCCESS) {
1451 stopIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1452 if (stopIter->second.timer_ != nullptr) {
1453 int interval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1454 stopIter->second.timer_->Start(interval, true);
1455 }
1456 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop advertising failed! %{public}d.", __func__, status);
1457 }
1458 return;
1459 default:
1460 break;
1461 }
1462
1463 if (status != BT_SUCCESS) {
1464 stopIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1465 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop advertising failed! %{public}d.", __func__, status);
1466 return;
1467 }
1468 RemoveAdvHandle(advStopHandle);
1469 (static_cast<BleAdapter *>(bleAdapter_))->OnStopAdvertisingEvt();
1470 }
1471
HandleGapEvent(const BLE_GAP_CB_EVENT &event, int status, int8_t txPower)1472 void BleAdvertiserImpl::HandleGapEvent(const BLE_GAP_CB_EVENT &event, int status, int8_t txPower)
1473 {
1474 LOG_DEBUG("[BleAdvertiserImpl] %{public}s:[event no: %{public}d]", __func__, static_cast<int>(event));
1475 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1476 switch (event) {
1477 case BLE_GAP_ADV_PARAM_SET_COMPLETE_EVT:
1478 GapAdvParamSetCompleteEvt(status);
1479 break;
1480 case BLE_GAP_ADV_READ_TXPOWER_EVT:
1481 GapAdvReadTxPowerEvt(status, txPower);
1482 break;
1483 case BLE_GAP_ADV_DATA_SET_COMPLETE_EVT:
1484 GapAdvDataSetCompleteEvt(status, txPower);
1485 break;
1486 case BLE_GAP_ADV_SCAN_RSP_DATA_SET_COMPLETE_EVT:
1487 GapAdvScanRspDataSetCompleteEvt(status);
1488 break;
1489 case BLE_GAP_ADV_START_COMPLETE_EVT:
1490 GapAdvStartCompleteEvt(status);
1491 break;
1492 case BLE_GAP_ADV_STOP_COMPLETE_EVT:
1493 GapAdvStopCompleteEvt(status);
1494 break;
1495 default:
1496 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Invalid event! %{public}d.", __func__, event);
1497 break;
1498 }
1499 }
1500
GapExAdvSetRandAddrResultEvt(int status) const1501 void BleAdvertiserImpl::GapExAdvSetRandAddrResultEvt(int status) const
1502 {
1503 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1504
1505 if (pimpl->advHandleQue_.empty()) {
1506 return;
1507 }
1508 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1509 pimpl->advHandleQue_.pop();
1510 pimpl->cvfull_.notify_all();
1511 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1512 if (iter == pimpl->advHandleSettingDatas_.end()) {
1513 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1514 return;
1515 }
1516
1517 if (status != BT_SUCCESS) {
1518 LOG_ERROR("Set rand addr failed! %{public}d", status);
1519 callback_->OnStartResultEvent(
1520 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1521 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1522 RemoveAdvHandle(advStartHandle);
1523 return;
1524 }
1525 int ret = SetExAdvEnableToGap(advStartHandle, true);
1526 if (ret != BT_SUCCESS) {
1527 LOG_ERROR("Start ex advertising failed!");
1528 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1529 callback_->OnStartResultEvent(
1530 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1531 RemoveAdvHandle(advStartHandle);
1532 } else {
1533 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1534 }
1535 }
1536
GapExAdvParamSetCompleteEvt(int status, int8_t txPower) const1537 void BleAdvertiserImpl::GapExAdvParamSetCompleteEvt(int status, int8_t txPower) const
1538 {
1539 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1540
1541 if (pimpl->advHandleQue_.empty()) {
1542 return;
1543 }
1544 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1545 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1546 if (iter == pimpl->advHandleSettingDatas_.end()) {
1547 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1548 return;
1549 }
1550
1551 if (status != BT_SUCCESS) {
1552 LOG_ERROR("Set ex adv parameter failed! %{public}d", status);
1553 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1554 callback_->OnStartResultEvent(
1555 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1556 RemoveAdvHandle(advStartHandle);
1557 return;
1558 }
1559 if ((iter->second.settings_.IsConnectable()) || (iter->second.settings_.IsLegacyMode())) {
1560 int ret = SetExAdvDataToGap(iter->second.advData_, iter->second.settings_, txPower);
1561 pimpl->advHandleQue_.pop();
1562 if (ret != BT_SUCCESS) {
1563 LOG_ERROR("Set ex adv data to gap failed!");
1564 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1565 callback_->OnStartResultEvent(
1566 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1567 RemoveAdvHandle(advStartHandle);
1568 return;
1569 }
1570 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_ADV_DATA));
1571 } else {
1572 int ret = SetExAdvScanRspDataToGap(iter->second.rspData_, iter->second.settings_, txPower);
1573 pimpl->advHandleQue_.pop();
1574 if (ret != BT_SUCCESS) {
1575 LOG_ERROR("Set ex adv response data to gap failed!");
1576 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1577 callback_->OnStartResultEvent(
1578 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1579 RemoveAdvHandle(advStartHandle);
1580 return;
1581 }
1582 }
1583 }
1584
GapExAdvDataSetCompleteEvt(int status, int8_t txPower)1585 void BleAdvertiserImpl::GapExAdvDataSetCompleteEvt(int status, int8_t txPower)
1586 {
1587 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1588
1589 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1590 auto exAdvDataIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1591 if (exAdvDataIter == pimpl->advHandleSettingDatas_.end()) {
1592 pimpl->advHandleQue_.pop();
1593 return;
1594 }
1595
1596 if (status != BT_SUCCESS) {
1597 LOG_ERROR("Set ex adv data failed! %{public}d", status);
1598 callback_->OnStartResultEvent(
1599 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1600 exAdvDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1601 RemoveAdvHandle(advStartHandle);
1602 pimpl->advHandleQue_.pop();
1603 return;
1604 }
1605
1606 if (exAdvDataIter->second.settings_.IsLegacyMode()) {
1607 int ret = SetExAdvScanRspDataToGap(exAdvDataIter->second.rspData_, exAdvDataIter->second.settings_, txPower);
1608 pimpl->advHandleQue_.pop();
1609 if (ret != BT_SUCCESS) {
1610 LOG_ERROR("Set ex adv response data to gap failed!");
1611 exAdvDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1612 callback_->OnStartResultEvent(
1613 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1614 RemoveAdvHandle(advStartHandle);
1615 }
1616 } else {
1617 /// Generate rpa address
1618 if ((BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) && (pimpl->operationLast_)) {
1619 std::unique_lock<std::mutex> exAdvDataLock(pimpl->rpamutex_);
1620 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, this);
1621 if (ret != BT_SUCCESS) {
1622 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1623 }
1624 } else if (pimpl->operationLast_) {
1625 pimpl->advHandleQue_.pop();
1626 int ret = SetExAdvEnableToGap(advStartHandle, true);
1627 if (ret != BT_SUCCESS) {
1628 LOG_ERROR("Start ex advertising failed!");
1629 exAdvDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1630 callback_->OnStartResultEvent(
1631 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1632 RemoveAdvHandle(advStartHandle);
1633 } else {
1634 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1635 }
1636 }
1637 }
1638 }
1639
GapExAdvScanRspDataSetCompleteEvt(int status)1640 void BleAdvertiserImpl::GapExAdvScanRspDataSetCompleteEvt(int status)
1641 {
1642 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1643
1644 if (pimpl->advHandleQue_.empty()) {
1645 return;
1646 }
1647 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1648 auto exAdvScanDataIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1649 if (exAdvScanDataIter == pimpl->advHandleSettingDatas_.end()) {
1650 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1651 pimpl->advHandleQue_.pop();
1652 return;
1653 }
1654
1655 if (status != BT_SUCCESS) {
1656 LOG_ERROR("Set ex scan response data failed! %{public}d", status);
1657 callback_->OnStartResultEvent(
1658 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1659 exAdvScanDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1660 RemoveAdvHandle(advStartHandle);
1661 pimpl->advHandleQue_.pop();
1662 return;
1663 }
1664 if ((BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) && (pimpl->operationLast_)) {
1665 /// Generate rpa address
1666 std::unique_lock<std::mutex> exAdvScanResLock(pimpl->rpamutex_);
1667 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, this);
1668 if (ret != BT_SUCCESS) {
1669 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1670 }
1671 } else if (pimpl->operationLast_) {
1672 pimpl->advHandleQue_.pop();
1673 int ret = SetExAdvEnableToGap(advStartHandle, true);
1674 if (ret != BT_SUCCESS) {
1675 LOG_ERROR("Start ex advertising failed!");
1676 exAdvScanDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1677 callback_->OnStartResultEvent(
1678 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1679 RemoveAdvHandle(advStartHandle);
1680 } else {
1681 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1682 }
1683 }
1684 }
1685
GapExAdvStartCompleteEvt(int status)1686 void BleAdvertiserImpl::GapExAdvStartCompleteEvt(int status)
1687 {
1688 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1689
1690 if (pimpl->advHandleQue_.empty()) {
1691 return;
1692 }
1693 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1694 pimpl->advHandleQue_.pop();
1695 auto exAdvStartIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1696 if (exAdvStartIter == pimpl->advHandleSettingDatas_.end()) {
1697 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1698 return;
1699 }
1700
1701 if (status != BT_SUCCESS) {
1702 LOG_ERROR("Start ex advertising failed! %{public}d", status);
1703 callback_->OnStartResultEvent(
1704 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1705 exAdvStartIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1706 RemoveAdvHandle(advStartHandle);
1707 return;
1708 }
1709
1710 callback_->OnStartResultEvent(status, advStartHandle);
1711 if (BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) {
1712 if (exAdvStartIter->second.timer_ == nullptr) {
1713 exAdvStartIter->second.timer_ =
1714 std::make_unique<utility::Timer>(std::bind(&TimerCallbackEx, this, advStartHandle));
1715 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1716 exAdvStartIter->second.timer_->Start(inerval, true);
1717 }
1718 }
1719
1720 if (bleAdapter_ != nullptr) {
1721 (static_cast<BleAdapter *>(bleAdapter_))->OnStartAdvertisingEvt();
1722 }
1723 }
1724
GAPExAdvClearHandle()1725 void BleAdvertiserImpl::GAPExAdvClearHandle()
1726 {
1727 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1728
1729 if (exAdvCallback_.exAdvClearHandleResult == nullptr) {
1730 RegisterExAdvCallbackToGap();
1731 }
1732
1733 int ret = GAPIF_LeExAdvClearHandle();
1734 if (ret != BT_SUCCESS) {
1735 LOG_ERROR("GAPIF_LeExAdvClearHandle failed! %{public}d", ret);
1736 }
1737 }
1738
GapExAdvStopAllCompleteEvt(int status) const1739 void BleAdvertiserImpl::GapExAdvStopAllCompleteEvt(int status) const
1740 {
1741 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1742 pimpl->advHandleQue_.pop();
1743 if (status != BT_SUCCESS) {
1744 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); iter++) {
1745 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1746 LOG_ERROR("Stop ex advertising failed! %{public}d", status);
1747 }
1748 return;
1749 }
1750 RemoveAllAdvHandle(status);
1751 }
1752
GapExAdvResolvingListStartCompleteEvt(int status) const1753 void BleAdvertiserImpl::GapExAdvResolvingListStartCompleteEvt(int status) const
1754 {
1755 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1756 pimpl->advHandleQue_.pop();
1757 if (status != BT_SUCCESS) {
1758 UpdateAllAdvertisingStatus(ADVERTISE_FAILED_INTERNAL_ERROR);
1759 LOG_ERROR("Stop or start resolving list ex advertising failed! %{public}d", status);
1760 return;
1761 }
1762
1763 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); ++iter) {
1764 if (iter->second.timer_ != nullptr) {
1765 int interval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1766 iter->second.timer_->Start(interval, true);
1767 }
1768 }
1769 }
1770
GapExAdvResolvingListStopCompleteEvt(int status) const1771 void BleAdvertiserImpl::GapExAdvResolvingListStopCompleteEvt(int status) const
1772 {
1773 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1774 pimpl->advHandleQue_.pop();
1775 if (status != BT_SUCCESS) {
1776 UpdateAllAdvertisingStatus(ADVERTISE_FAILED_INTERNAL_ERROR);
1777 LOG_ERROR("Stop or start resolving list ex advertising failed! %{public}d", status);
1778 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); ++iter) {
1779 if (iter->second.timer_ != nullptr) {
1780 int interval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1781 iter->second.timer_->Start(interval, true);
1782 }
1783 }
1784 }
1785 }
1786
GapExAdvStopCompleteEvt(int status) const1787 void BleAdvertiserImpl::GapExAdvStopCompleteEvt(int status) const
1788 {
1789 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1790 if (pimpl->advHandleQue_.empty()) {
1791 LOG_ERROR("[BleAdvertiserImpl] %{public}s advHandleQue_ empty .", __func__);
1792 return;
1793 }
1794 uint8_t tempHandle = pimpl->advHandleQue_.front().advHandle;
1795 pimpl->advHandleQue_.pop();
1796 auto exAdvStopIter = pimpl->advHandleSettingDatas_.find(tempHandle);
1797 if (exAdvStopIter == pimpl->advHandleSettingDatas_.end()) {
1798 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, tempHandle);
1799 return;
1800 }
1801
1802 if (status != BT_SUCCESS) {
1803 exAdvStopIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1804 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop ex advertising failed! %{public}d", __func__, status);
1805 return;
1806 }
1807 RemoveAdvHandle(tempHandle);
1808 }
1809
GapExAdvRemoveHandleResultEvt(int status) const1810 void BleAdvertiserImpl::GapExAdvRemoveHandleResultEvt(int status) const
1811 {
1812 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1813 if (pimpl->advHandleQue_.empty()) {
1814 LOG_ERROR("[BleAdvertiserImpl] %{public}s advHandleQue_ empty .", __func__);
1815 return;
1816 }
1817 uint8_t tempHandle = pimpl->advHandleQue_.front().advHandle;
1818 pimpl->advHandleQue_.pop();
1819 auto exAdvRemoveIter = pimpl->advHandleSettingDatas_.find(tempHandle);
1820 if (exAdvRemoveIter == pimpl->advHandleSettingDatas_.end()) {
1821 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, tempHandle);
1822 return;
1823 }
1824
1825 if (status != BT_SUCCESS) {
1826 exAdvRemoveIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1827 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Remove handle failed! %{public}d", __func__, status);
1828 return;
1829 }
1830 RemoveAdvHandle(tempHandle);
1831 }
1832
GapExAdvTerminatedAdvSetEvt(int status, uint8_t handle) const1833 void BleAdvertiserImpl::GapExAdvTerminatedAdvSetEvt(int status, uint8_t handle) const
1834 {
1835 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1836
1837 auto exAdvTermIter = pimpl->advHandleSettingDatas_.find(handle);
1838 if (exAdvTermIter == pimpl->advHandleSettingDatas_.end()) {
1839 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, handle);
1840 return;
1841 }
1842
1843 if (exAdvTermIter->second.advStatus_ == ADVERTISE_NOT_STARTED) {
1844 LOG_ERROR("[BleAdvertiserImpl] %{public}s:user stop adv handle! %u.", __func__, handle);
1845 return;
1846 }
1847 if (exAdvTermIter->second.timer_ != nullptr) {
1848 exAdvTermIter->second.timer_->Stop();
1849 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1850 exAdvTermIter->second.timer_->Start(inerval, true);
1851 }
1852 exAdvTermIter->second.advStatus_ = ADVERTISE_FAILED_ALREADY_STARTED;
1853
1854 /// Start adv
1855 int ret = SetExAdvEnableToGap(handle, true);
1856 if (ret != BT_SUCCESS) {
1857 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed!.", __func__);
1858 exAdvTermIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1859 RemoveAdvHandle(handle);
1860 } else {
1861 pimpl->advHandleQue_.push(BleAdvertiserImplOp(handle, ADV_STATUS_STARTING));
1862 }
1863 }
1864
HandleGapExAdvEvent(const BLE_GAP_CB_EVENT &event, int status, int8_t txPower, uint8_t handle)1865 void BleAdvertiserImpl::HandleGapExAdvEvent(const BLE_GAP_CB_EVENT &event, int status, int8_t txPower, uint8_t handle)
1866 {
1867 HILOGI("event no: %{public}d.", static_cast<int>(event));
1868 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1869 switch (event) {
1870 case BLE_GAP_EX_ADV_SET_RAND_ADDR_RESULT_EVT:
1871 GapExAdvSetRandAddrResultEvt(status);
1872 break;
1873 case BLE_GAP_EX_ADV_PARAM_SET_COMPLETE_EVT:
1874 GapExAdvParamSetCompleteEvt(status, txPower);
1875 break;
1876 case BLE_GAP_EX_ADV_DATA_SET_COMPLETE_EVT:
1877 GapExAdvDataSetCompleteEvt(status, txPower);
1878 break;
1879 case BLE_GAP_EX_ADV_SCAN_RSP_DATA_SET_COMPLETE_EVT:
1880 GapExAdvScanRspDataSetCompleteEvt(status);
1881 break;
1882 case BLE_GAP_EX_ADV_START_COMPLETE_EVT:
1883 GapExAdvStartCompleteEvt(status);
1884 break;
1885 case BLE_GAP_EX_RESOLVING_LIST_ADV_START_COMPLETE_EVT:
1886 GapExAdvResolvingListStartCompleteEvt(status);
1887 break;
1888 case BLE_GAP_EX_ADV_STOP_COMPLETE_EVT:
1889 GapExAdvStopCompleteEvt(status);
1890 break;
1891 case BLE_GAP_EX_ALL_ADV_STOP_COMPLETE_EVT:
1892 GapExAdvStopAllCompleteEvt(status);
1893 break;
1894 case BLE_GAP_EX_RESOLVING_LIST_ADV_STOP_COMPLETE_EVT:
1895 GapExAdvResolvingListStopCompleteEvt(status);
1896 break;
1897 case BLE_GAP_EX_ADV_REMOVE_HANDLE_RESULT_EVT:
1898 GapExAdvRemoveHandleResultEvt(status);
1899 break;
1900 case BLE_GAP_EX_ADV_CLEAR_HANDLE_RESULT_EVT:
1901 LOG_ERROR("[BleAdvertiserImpl] %{public}s:clrear event! %{public}d.", __func__, event);
1902 break;
1903 case BLE_GAP_EX_ADV_SCAN_REQUEST_RECEIVED_EVT:
1904 LOG_ERROR(
1905 "[BleAdvertiserImpl] %{public}s:scan request! %{public}d status %{public}d.", __func__, event, status);
1906 break;
1907 case BLE_GAP_EX_ADC_TERMINATED_ADV_SET_EVT:
1908 GapExAdvTerminatedAdvSetEvt(status, handle);
1909 break;
1910 default:
1911 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Invalid event! %{public}d.", __func__, event);
1912 break;
1913 }
1914 }
1915
TimerCallback(void *context, uint8_t advHandle)1916 void BleAdvertiserImpl::TimerCallback(void *context, uint8_t advHandle)
1917 {
1918 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
1919
1920 auto *advertiser = static_cast<BleAdvertiserImpl *>(context);
1921 if ((advertiser != nullptr) && (advertiser->dispatcher_ != nullptr)) {
1922 /// Stop adv
1923 auto iter = advertiser->pimpl->advHandleSettingDatas_.find(advHandle);
1924 if (iter == advertiser->pimpl->advHandleSettingDatas_.end()) {
1925 LOG_ERROR("[BleAdvertiserImpl] %{public}s:AdvHandleSettingDatas is empty!", __func__);
1926 return;
1927 }
1928 advertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::SetAdvEnableToGap, advertiser, false));
1929 advertiser->pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STOPING));
1930
1931 std::unique_lock<std::mutex> legacyLock(advertiser->pimpl->rpamutex_);
1932 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, advertiser);
1933 if (ret != BT_SUCCESS) {
1934 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1935 }
1936 if (advertiser->pimpl->cvfull_.wait_for(legacyLock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) ==
1937 std::cv_status::timeout) {
1938 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync timeout!", __func__);
1939 }
1940 /// Start adv
1941 advertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::SetAdvEnableToGap, advertiser, true));
1942 advertiser->pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STARTING));
1943 }
1944 }
1945
TimerCallbackEx(void *context, uint8_t advHandle)1946 void BleAdvertiserImpl::TimerCallbackEx(void *context, uint8_t advHandle)
1947 {
1948 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
1949
1950 auto *advertiser = static_cast<BleAdvertiserImpl *>(context);
1951 if ((advertiser != nullptr) && (advertiser->dispatcher_ != nullptr)) {
1952 /// Stop adv
1953 auto iter = advertiser->pimpl->advHandleSettingDatas_.find(advHandle);
1954 if (iter == advertiser->pimpl->advHandleSettingDatas_.end()) {
1955 LOG_ERROR("[BleAdvertiserImpl] %{public}s:AdvHandleSettingDatas is empty!", __func__);
1956 return;
1957 }
1958 advertiser->dispatcher_->PostTask(
1959 std::bind(&BleAdvertiserImpl::SetExAdvEnableToGap, advertiser, advHandle, false));
1960 advertiser->pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STOPING));
1961
1962 std::unique_lock<std::mutex> exAdvLock(advertiser->pimpl->rpamutex_);
1963 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, advertiser);
1964 if (ret != BT_SUCCESS) {
1965 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1966 }
1967 if (advertiser->pimpl->cvfull_.wait_for(exAdvLock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) ==
1968 std::cv_status::timeout) {
1969 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync timeout!", __func__);
1970 }
1971 /// Start adv in GenResPriAddrResult->GenResPriAddrResultTask
1972 }
1973 }
1974
GenResPriAddrResultTask(uint8_t result, BtAddr btAddr) const1975 void BleAdvertiserImpl::GenResPriAddrResultTask(uint8_t result, BtAddr btAddr) const
1976 {
1977 HILOGI("ResPriAddr = %{public}s", GetEncryptAddr(RawAddress::ConvertToString(btAddr.addr).GetAddress()).c_str());
1978
1979 if (pimpl->advHandleQue_.empty()) {
1980 return;
1981 }
1982 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1983 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1984 if (iter == pimpl->advHandleSettingDatas_.end()) {
1985 LOG_ERROR("[BleAdvertiserImpl] %{public}s:AdvHandleSettingDatas is empty!", __func__);
1986 } else {
1987 if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
1988 pimpl->advHandleQue_.pop();
1989 int ret = GAPIF_LeExAdvSetRandAddr(advStartHandle, &btAddr.addr[0]);
1990 if (ret != BT_SUCCESS) {
1991 LOG_ERROR("Set ex adv rand addr gap failed!");
1992 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1993 callback_->OnStartResultEvent(
1994 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1995 RemoveAdvHandle(advStartHandle);
1996 } else {
1997 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_RAN_ADDR));
1998 }
1999 } else {
2000 int ret = BTM_SetLeRandomAddress(&btAddr);
2001 if (ret != BT_SUCCESS) {
2002 LOG_ERROR("[BleAdapter] %{public}s:GenResPriAddrResult failed!", __func__);
2003 }
2004 pimpl->cvfull_.notify_all();
2005 }
2006 }
2007 }
2008
GenResPriAddrResult(uint8_t result, const uint8_t addr[BT_ADDRESS_SIZE], void *context)2009 void BleAdvertiserImpl::GenResPriAddrResult(uint8_t result, const uint8_t addr[BT_ADDRESS_SIZE], void *context)
2010 {
2011 HILOGI("ResPriAddr = %{public}s", GetEncryptAddr(RawAddress::ConvertToString(addr).GetAddress()).c_str());
2012
2013 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
2014
2015 BtAddr btAddr;
2016 (void)memcpy_s(&btAddr.addr, BT_ADDRESS_SIZE, addr, BT_ADDRESS_SIZE);
2017 btAddr.type = BLE_ADDR_TYPE_RANDOM;
2018
2019 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
2020 bleAdvertiser->dispatcher_->PostTask(
2021 std::bind(&BleAdvertiserImpl::GenResPriAddrResultTask, bleAdvertiser, result, btAddr));
2022 }
2023 }
2024
GetMaxAdvertisingDataLength(const BleAdvertiserSettingsImpl &settings)2025 int BleAdvertiserImpl::GetMaxAdvertisingDataLength(const BleAdvertiserSettingsImpl &settings)
2026 {
2027 if (settings.IsLegacyMode()) {
2028 return BLE_LEGACY_ADV_DATA_LEN_MAX;
2029 } else {
2030 return BleFeature::GetInstance().GetBleMaximumAdvertisingDataLength();
2031 }
2032 }
2033 } // namespace bluetooth
2034 } // namespace OHOS
2035