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 ret = GAPIF_LeExAdvSetScanRspData(advStartHandle, operation, fragmentPreference, payloadLen,
966 reinterpret_cast<uint8_t *>(const_cast<char *>(payload.c_str())));
967 } else if (((payloadLen / maxlen == 1) && (payloadLen % maxlen > 0)) ||
968 ((payloadLen / maxlen == BLE_DIV_RESULT_TWO) && (payloadLen % maxlen == 0))) {
969 uint8_t operation = GAP_ADVERTISING_DATA_OPERATION_FIRST;
970 ret = GAPIF_LeExAdvSetScanRspData(advStartHandle, operation, fragmentPreference, maxlen,
971 reinterpret_cast<uint8_t *>(const_cast<char *>(payload.substr(maxlen).c_str())));
972 pimpl->operationLast_ = true;
973 operation = GAP_ADVERTISING_DATA_OPERATION_LAST;
974 ret &= GAPIF_LeExAdvSetScanRspData(advStartHandle, operation, fragmentPreference, payloadLen - maxlen,
975 reinterpret_cast<uint8_t *>(const_cast<char *>(payload.substr(maxlen, payloadLen - maxlen).c_str())));
976 } else if (payloadLen / maxlen > 1) {
977 uint8_t operation = GAP_ADVERTISING_DATA_OPERATION_FIRST;
978 ret = GAPIF_LeExAdvSetScanRspData(advStartHandle, operation, fragmentPreference, maxlen,
979 reinterpret_cast<uint8_t *>(const_cast<char *>(payload.substr(maxlen).c_str())));
980 operation = static_cast<uint8_t>(GAP_ADVERTISING_DATA_OPERATION_INTERMEDIATE);
981 for (size_t i = 0; i < (payloadLen / maxlen - 1); i++) {
982 ret &= GAPIF_LeExAdvSetScanRspData(advStartHandle, operation, fragmentPreference, maxlen * (i + 1),
983 reinterpret_cast<uint8_t *>(const_cast<char *>(payload.substr(maxlen * (i + 1), maxlen).c_str())));
984 }
985 pimpl->operationLast_ = true;
986 operation = GAP_ADVERTISING_DATA_OPERATION_LAST;
987 ret &= GAPIF_LeExAdvSetScanRspData(advStartHandle, operation, fragmentPreference,
988 data.GetPayload().size() - maxlen *(payloadLen / maxlen),
989 reinterpret_cast<uint8_t *>(const_cast<char *>(payload.substr(maxlen * (payloadLen / maxlen),
990 payloadLen - maxlen * (payloadLen / maxlen)).c_str())));
991 }
992 if (ret == BT_SUCCESS) {
993 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_SCAN_DATA));
994 }
995 return ret;
996 }
997
SetExAdvDataToGap(const BleAdvertiserDataImpl & advData,const BleAdvertiserSettingsImpl & settings,int8_t txPowerLevel) const998 int BleAdvertiserImpl::SetExAdvDataToGap(
999 const BleAdvertiserDataImpl &advData, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const
1000 {
1001 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1002
1003 BleAdvertiserDataImpl data = static_cast<BleAdvertiserDataImpl>(advData);
1004 // bluetooth localname
1005 std::string name = BleProperties::GetInstance().GetLocalName();
1006 size_t maxData = GetMaxAdvertisingDataLength(settings);
1007 if ((!data.GetPayload().empty()) && (!name.empty()) && (data.GetPayload().size() + name.size() <= maxData)) {
1008 data.SetDeviceName(name);
1009 }
1010 // adv txpower
1011 if ((!data.GetPayload().empty()) && (data.GetPayload().size() + BLE_ADV_DATA_BYTE_FIELD_LEN <= maxData)) {
1012 data.SetTxPowerLevel(txPowerLevel);
1013 }
1014
1015 if (!data.GetPayload().empty()) {
1016 std::vector<uint8_t> exAdvDatas;
1017 for (size_t i = 0; i < data.GetPayload().size(); i++) {
1018 exAdvDatas.push_back(data.GetPayload()[i]);
1019 }
1020 LOG_INFO("[BleAdvertiserImpl] %{public}s: Advertising Data Data=%{public}s %{public}zu",
1021 __func__,
1022 BleUtils::ConvertIntToHexString(exAdvDatas).c_str(),
1023 data.GetPayload().size());
1024 }
1025 // fragment data
1026 return ExAdvDataFragment(data);
1027 }
1028
SetAdvScanRspDataToGap(const BleAdvertiserDataImpl & scanResponse,const BleAdvertiserSettingsImpl & settings,int8_t txPowerLevel) const1029 int BleAdvertiserImpl::SetAdvScanRspDataToGap(
1030 const BleAdvertiserDataImpl &scanResponse, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const
1031 {
1032 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1033
1034 BleAdvertiserDataImpl legacyScandata = static_cast<BleAdvertiserDataImpl>(scanResponse);
1035 // bluetooth localname
1036 std::string name = BleProperties::GetInstance().GetLocalName();
1037 size_t maxDataLen = GetMaxAdvertisingDataLength(settings);
1038 if ((!name.empty()) &&
1039 (legacyScandata.GetPayload().size() + name.size() + BLE_ADV_DATA_FIELD_TYPE_AND_LEN <= maxDataLen)) {
1040 legacyScandata.SetDeviceName(name);
1041 }
1042
1043 if (!legacyScandata.GetPayload().empty()) {
1044 std::vector<uint8_t> legacyDatas;
1045 for (size_t i = 0; i < legacyScandata.GetPayload().size(); i++) {
1046 legacyDatas.push_back(legacyScandata.GetPayload()[i]);
1047 }
1048 LOG_INFO("[BleAdvertiserImpl] %{public}s: Advertising Data Data=%{public}s %{public}zu",
1049 __func__,
1050 BleUtils::ConvertIntToHexString(legacyDatas).c_str(),
1051 legacyScandata.GetPayload().size());
1052 }
1053 return GAPIF_LeAdvSetScanRspData(
1054 legacyScandata.GetPayload().size(), (uint8_t *)legacyScandata.GetPayload().c_str());
1055 }
1056
SetExAdvScanRspDataToGap(const BleAdvertiserDataImpl & scanResponse,const BleAdvertiserSettingsImpl & settings,int8_t txPowerLevel) const1057 int BleAdvertiserImpl::SetExAdvScanRspDataToGap(
1058 const BleAdvertiserDataImpl &scanResponse, const BleAdvertiserSettingsImpl &settings, int8_t txPowerLevel) const
1059 {
1060 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1061 if (pimpl->advHandleQue_.empty()) {
1062 return BT_BAD_PARAM;
1063 }
1064 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1065 BleAdvertiserDataImpl exAdvScandata = static_cast<BleAdvertiserDataImpl>(scanResponse);
1066 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1067 if (iter == pimpl->advHandleSettingDatas_.end()) {
1068 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1069 return BT_BAD_PARAM;
1070 }
1071 // bluetooth localname
1072 std::string name = BleProperties::GetInstance().GetLocalName();
1073 size_t maxData = GetMaxAdvertisingDataLength(settings);
1074 if ((!iter->second.settings_.IsConnectable()) && (!name.empty()) &&
1075 (exAdvScandata.GetPayload().size() + name.size() + BLE_ADV_DATA_FIELD_TYPE_AND_LEN <= maxData)) {
1076 exAdvScandata.SetDeviceName(name);
1077 }
1078
1079 if (!exAdvScandata.GetPayload().empty()) {
1080 std::vector<uint8_t> exAdvDatas;
1081 for (size_t i = 0; i < exAdvScandata.GetPayload().size(); i++) {
1082 exAdvDatas.push_back(exAdvScandata.GetPayload()[i]);
1083 }
1084 LOG_INFO("[BleAdvertiserImpl] %{public}s: Advertising Data Data=%{public}s %{public}zu",
1085 __func__,
1086 BleUtils::ConvertIntToHexString(exAdvDatas).c_str(),
1087 exAdvScandata.GetPayload().size());
1088 }
1089 // fragment data
1090 return ExResDataFragment(exAdvScandata);
1091 }
1092
SetAdvEnableToGap(bool isEnable) const1093 int BleAdvertiserImpl::SetAdvEnableToGap(bool isEnable) const
1094 {
1095 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1096
1097 return GAPIF_LeAdvSetEnable(isEnable);
1098 }
1099
SetExAdvEnableToGap(uint8_t advHandle,bool isEnable) const1100 int BleAdvertiserImpl::SetExAdvEnableToGap(uint8_t advHandle, bool isEnable) const
1101 {
1102 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1103
1104 GapExAdvSet exAdvSet;
1105 exAdvSet.advHandle = advHandle;
1106 exAdvSet.duration = 0;
1107 exAdvSet.maxExAdvEvt = 0;
1108 return GAPIF_LeExAdvSetEnable(isEnable, 0x01, &exAdvSet);
1109 }
1110
SetExAdvBatchEnableToGap(bool isEnable) const1111 int BleAdvertiserImpl::SetExAdvBatchEnableToGap(bool isEnable) const
1112 {
1113 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1114 std::vector<GapExAdvSet> advSets;
1115 auto iter = pimpl->advHandleSettingDatas_.begin();
1116 for (; iter != pimpl->advHandleSettingDatas_.end(); iter++) {
1117 if (iter->second.timer_ != nullptr) {
1118 iter->second.timer_->Stop();
1119 }
1120
1121 GapExAdvSet exAdvSets;
1122 exAdvSets.advHandle = iter->first;
1123 exAdvSets.duration = 0;
1124 exAdvSets.maxExAdvEvt = 0;
1125 advSets.push_back(exAdvSets);
1126 }
1127 return GAPIF_LeExAdvSetEnable(isEnable, advSets.size(), &advSets[0]);
1128 }
1129
SetMinInterval(uint16_t mininterval) const1130 void BleAdvertiserImpl::SetMinInterval(uint16_t mininterval) const
1131 {
1132 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1133
1134 pimpl->advParams_.advMinInterval = mininterval;
1135 }
1136
SetMaxInterval(uint16_t maxinterval) const1137 void BleAdvertiserImpl::SetMaxInterval(uint16_t maxinterval) const
1138 {
1139 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1140
1141 pimpl->advParams_.advMaxInterval = maxinterval;
1142 }
1143
SetFilter(bool scanReqWhitelistOnly,bool connectWhitelistOnly) const1144 void BleAdvertiserImpl::SetFilter(bool scanReqWhitelistOnly, bool connectWhitelistOnly) const
1145 {
1146 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1147
1148 if ((!scanReqWhitelistOnly) && (!connectWhitelistOnly)) {
1149 pimpl->advParams_.advFilterPolicy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
1150 return;
1151 }
1152 if ((scanReqWhitelistOnly) && (!connectWhitelistOnly)) {
1153 pimpl->advParams_.advFilterPolicy = ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY;
1154 return;
1155 }
1156 if ((!scanReqWhitelistOnly) && (connectWhitelistOnly)) {
1157 pimpl->advParams_.advFilterPolicy = ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST;
1158 return;
1159 }
1160 if ((scanReqWhitelistOnly) && (connectWhitelistOnly)) {
1161 pimpl->advParams_.advFilterPolicy = ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST;
1162 return;
1163 }
1164 }
1165
SetChannelMap(const BLE_ADV_CHANNEL & channelMap) const1166 void BleAdvertiserImpl::SetChannelMap(const BLE_ADV_CHANNEL &channelMap) const
1167 {
1168 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1169
1170 pimpl->advParams_.channelMap = channelMap;
1171 }
1172
CreateAdvertiserSetHandle() const1173 uint8_t BleAdvertiserImpl::CreateAdvertiserSetHandle() const
1174 {
1175 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1176
1177 uint8_t handle = BLE_INVALID_ADVERTISING_HANDLE;
1178 if (!BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
1179 handle = BLE_LEGACY_ADVERTISING_HANDLE;
1180 std::vector<uint8_t>::iterator ret =
1181 std::find(pimpl->advCreateHandles_.begin(), pimpl->advCreateHandles_.end(), handle);
1182 if (ret == pimpl->advCreateHandles_.end()) {
1183 pimpl->advCreateHandles_.push_back(handle);
1184 }
1185 return handle;
1186 }
1187
1188 uint8_t newHandle = BLE_LEGACY_ADVERTISING_HANDLE;
1189 uint8_t end = BleFeature::GetInstance().GetBleExAdvGetMaxHandleNum();
1190 for (; newHandle < end; ++newHandle) {
1191 std::vector<uint8_t>::iterator ret =
1192 std::find(pimpl->advCreateHandles_.begin(), pimpl->advCreateHandles_.end(), newHandle);
1193 if (ret == pimpl->advCreateHandles_.end()) {
1194 pimpl->advCreateHandles_.push_back(newHandle);
1195 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}d", __func__, newHandle);
1196 return newHandle;
1197 }
1198 }
1199 return handle;
1200 }
1201
RemoveAdvHandle(uint8_t handle) const1202 void BleAdvertiserImpl::RemoveAdvHandle(uint8_t handle) const
1203 {
1204 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1205
1206 if (!pimpl->advCreateHandles_.empty()) {
1207 pimpl->advCreateHandles_.erase(remove(pimpl->advCreateHandles_.begin(), pimpl->advCreateHandles_.end(), handle),
1208 pimpl->advCreateHandles_.end());
1209 }
1210
1211 auto iter = pimpl->advHandleSettingDatas_.begin();
1212 while (iter != pimpl->advHandleSettingDatas_.end()) {
1213 if (iter->first == handle) {
1214 if (iter->second.timer_ != nullptr) {
1215 iter->second.timer_->Stop();
1216 iter->second.timer_ = nullptr;
1217 }
1218 pimpl->advHandleSettingDatas_.erase(iter++);
1219 } else {
1220 ++iter;
1221 }
1222 }
1223 }
1224
RemoveAllAdvHandle(int status) const1225 void BleAdvertiserImpl::RemoveAllAdvHandle(int status) const
1226 {
1227 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1228 pimpl->advCreateHandles_.clear();
1229 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); iter++) {
1230 if (iter->second.timer_ != nullptr) {
1231 iter->second.timer_->Stop();
1232 iter->second.timer_ = nullptr;
1233 }
1234 }
1235 pimpl->advHandleSettingDatas_.clear();
1236 }
1237
AddCharacteristicValue(uint8_t adtype,const std::string & data) const1238 void BleAdvertiserImpl::AddCharacteristicValue(uint8_t adtype, const std::string &data) const
1239 {
1240 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1241 if (pimpl->advHandleQue_.empty()) {
1242 return;
1243 }
1244 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1245 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1246 if (iter == pimpl->advHandleSettingDatas_.end()) {
1247 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1248 return;
1249 }
1250 iter->second.advData_.AddCharacteristicValue(adtype, data);
1251 }
1252
GapAdvParamSetCompleteEvt(int status) const1253 void BleAdvertiserImpl::GapAdvParamSetCompleteEvt(int status) const
1254 {
1255 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1256 if (pimpl->advHandleQue_.empty()) {
1257 return;
1258 }
1259 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1260 pimpl->advHandleQue_.pop();
1261 auto paraIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1262 if (paraIter == pimpl->advHandleSettingDatas_.end()) {
1263 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1264 return;
1265 }
1266
1267 if (status != BT_SUCCESS) {
1268 paraIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1269 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1270 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv param failed! %{public}d.", __func__, status);
1271 return;
1272 }
1273 int ret = GAPIF_LeAdvReadTxPower();
1274 if (ret != BT_SUCCESS) {
1275 paraIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1276 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Read adv tx power from gap failed! %{public}d.", __func__, ret);
1277 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1278 } else {
1279 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_READ_TX_POWER));
1280 }
1281 }
1282
GapAdvReadTxPowerEvt(int status,int8_t txPower) const1283 void BleAdvertiserImpl::GapAdvReadTxPowerEvt(int status, int8_t txPower) const
1284 {
1285 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1286
1287 if (pimpl->advHandleQue_.empty()) {
1288 return;
1289 }
1290 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1291 pimpl->advHandleQue_.pop();
1292 auto txPowerIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1293 if (txPowerIter == pimpl->advHandleSettingDatas_.end()) {
1294 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1295 return;
1296 }
1297
1298 if (status != BT_SUCCESS) {
1299 txPowerIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1300 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1301 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Read tx power failed! %{public}d.", __func__, status);
1302 return;
1303 }
1304 int ret = SetAdvDataToGap(txPowerIter->second.advData_, txPowerIter->second.settings_, txPower);
1305 if (ret != BT_SUCCESS) {
1306 txPowerIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1307 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv data to gap failed! %{public}d.", __func__, ret);
1308 callback_->OnStartResultEvent(ADVERTISE_FAILED_DATA_TOO_LARGE, advStartHandle);
1309 } else {
1310 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_ADV_DATA));
1311 }
1312 }
1313
GapAdvDataSetCompleteEvt(int status,int8_t txPower) const1314 void BleAdvertiserImpl::GapAdvDataSetCompleteEvt(int status, int8_t txPower) const
1315 {
1316 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1317
1318 if (pimpl->advHandleQue_.empty()) {
1319 return;
1320 }
1321 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1322 pimpl->advHandleQue_.pop();
1323 auto dataIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1324 if (dataIter == pimpl->advHandleSettingDatas_.end()) {
1325 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1326 return;
1327 }
1328
1329 if (status != BT_SUCCESS) {
1330 dataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1331 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1332 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv data failed! %{public}d.", __func__, status);
1333 return;
1334 }
1335 int ret = SetAdvScanRspDataToGap(dataIter->second.rspData_, dataIter->second.settings_, txPower);
1336 if (ret != BT_SUCCESS) {
1337 dataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1338 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv response data to gap failed! %{public}d.", __func__, ret);
1339 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1340 } else {
1341 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_SCAN_DATA));
1342 }
1343 }
1344
GapAdvScanRspDataSetCompleteEvt(int status) const1345 void BleAdvertiserImpl::GapAdvScanRspDataSetCompleteEvt(int status) const
1346 {
1347 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1348
1349 if (pimpl->advHandleQue_.empty()) {
1350 return;
1351 }
1352 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1353 pimpl->advHandleQue_.pop();
1354 auto scanResIter = pimpl->advHandleSettingDatas_.find(pimpl->advHandleQue_.front().advHandle);
1355 if (scanResIter == pimpl->advHandleSettingDatas_.end()) {
1356 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1357 return;
1358 }
1359
1360 if (status != BT_SUCCESS) {
1361 scanResIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1362 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1363 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set scan response data failed! %{public}d.", __func__, status);
1364 return;
1365 }
1366 int ret = SetAdvEnableToGap(true);
1367 if (ret != BT_SUCCESS) {
1368 scanResIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1369 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed! %{public}d.", __func__, ret);
1370 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1371 } else {
1372 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1373 }
1374 }
1375
GapAdvStartCompleteEvt(int status)1376 void BleAdvertiserImpl::GapAdvStartCompleteEvt(int status)
1377 {
1378 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1379
1380 if (pimpl->advHandleQue_.empty()) {
1381 return;
1382 }
1383 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1384 auto startIter = pimpl->advHandleSettingDatas_.find(pimpl->advHandleQue_.front().advHandle);
1385 pimpl->advHandleQue_.pop();
1386 if (startIter == pimpl->advHandleSettingDatas_.end()) {
1387 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1388 return;
1389 }
1390
1391 if (startIter->second.stopAllAdvType_ == STOP_ADV_TYPE_RESOLVING_LIST) {
1392 if (status != BT_SUCCESS) {
1393 startIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1394 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed! %{public}d.", __func__, status);
1395 } else {
1396 if (startIter->second.timer_ != nullptr) {
1397 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1398 startIter->second.timer_->Start(inerval, true);
1399 }
1400 }
1401 return;
1402 }
1403
1404 if (status != BT_SUCCESS) {
1405 startIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1406 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed! %{public}d.", __func__, status);
1407 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1408 return;
1409 }
1410 callback_->OnStartResultEvent(status, advStartHandle);
1411 if (BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) {
1412 if (startIter->second.timer_ == nullptr) {
1413 startIter->second.timer_ =
1414 std::make_unique<utility::Timer>(std::bind(&TimerCallback, this, advStartHandle));
1415 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1416 startIter->second.timer_->Start(inerval, true);
1417 }
1418 }
1419 (static_cast<BleAdapter *>(bleAdapter_))->OnStartAdvertisingEvt();
1420 }
1421
GapAdvStopCompleteEvt(int status) const1422 void BleAdvertiserImpl::GapAdvStopCompleteEvt(int status) const
1423 {
1424 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1425
1426 if (pimpl->advHandleQue_.empty()) {
1427 return;
1428 }
1429 uint8_t advStopHandle = pimpl->advHandleQue_.front().advHandle;
1430 pimpl->advHandleQue_.pop();
1431 auto stopIter = pimpl->advHandleSettingDatas_.find(advStopHandle);
1432 if (stopIter == pimpl->advHandleSettingDatas_.end()) {
1433 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStopHandle);
1434 return;
1435 }
1436
1437 switch (stopIter->second.stopAllAdvType_) {
1438 case STOP_ADV_TYPE_SINGLE:
1439 break;
1440 case STOP_ADV_TYPE_ALL:
1441 callback_->OnAutoStopAdvEvent(advStopHandle);
1442 break;
1443 case STOP_ADV_TYPE_RESOLVING_LIST:
1444 if (status != BT_SUCCESS) {
1445 stopIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1446 if (stopIter->second.timer_ != nullptr) {
1447 int interval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1448 stopIter->second.timer_->Start(interval, true);
1449 }
1450 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop advertising failed! %{public}d.", __func__, status);
1451 }
1452 return;
1453 default:
1454 break;
1455 }
1456
1457 if (status != BT_SUCCESS) {
1458 stopIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1459 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop advertising failed! %{public}d.", __func__, status);
1460 return;
1461 }
1462 RemoveAdvHandle(advStopHandle);
1463 (static_cast<BleAdapter *>(bleAdapter_))->OnStopAdvertisingEvt();
1464 }
1465
HandleGapEvent(const BLE_GAP_CB_EVENT & event,int status,int8_t txPower)1466 void BleAdvertiserImpl::HandleGapEvent(const BLE_GAP_CB_EVENT &event, int status, int8_t txPower)
1467 {
1468 LOG_DEBUG("[BleAdvertiserImpl] %{public}s:[event no: %{public}d]", __func__, static_cast<int>(event));
1469 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1470 switch (event) {
1471 case BLE_GAP_ADV_PARAM_SET_COMPLETE_EVT:
1472 GapAdvParamSetCompleteEvt(status);
1473 break;
1474 case BLE_GAP_ADV_READ_TXPOWER_EVT:
1475 GapAdvReadTxPowerEvt(status, txPower);
1476 break;
1477 case BLE_GAP_ADV_DATA_SET_COMPLETE_EVT:
1478 GapAdvDataSetCompleteEvt(status, txPower);
1479 break;
1480 case BLE_GAP_ADV_SCAN_RSP_DATA_SET_COMPLETE_EVT:
1481 GapAdvScanRspDataSetCompleteEvt(status);
1482 break;
1483 case BLE_GAP_ADV_START_COMPLETE_EVT:
1484 GapAdvStartCompleteEvt(status);
1485 break;
1486 case BLE_GAP_ADV_STOP_COMPLETE_EVT:
1487 GapAdvStopCompleteEvt(status);
1488 break;
1489 default:
1490 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Invalid event! %{public}d.", __func__, event);
1491 break;
1492 }
1493 }
1494
GapExAdvSetRandAddrResultEvt(int status) const1495 void BleAdvertiserImpl::GapExAdvSetRandAddrResultEvt(int status) const
1496 {
1497 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1498
1499 if (pimpl->advHandleQue_.empty()) {
1500 return;
1501 }
1502 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1503 pimpl->advHandleQue_.pop();
1504 pimpl->cvfull_.notify_all();
1505 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1506 if (iter == pimpl->advHandleSettingDatas_.end()) {
1507 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1508 return;
1509 }
1510
1511 if (status != BT_SUCCESS) {
1512 LOG_ERROR("Set rand addr failed! %{public}d", status);
1513 callback_->OnStartResultEvent(
1514 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1515 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1516 RemoveAdvHandle(advStartHandle);
1517 return;
1518 }
1519 int ret = SetExAdvEnableToGap(advStartHandle, true);
1520 if (ret != BT_SUCCESS) {
1521 LOG_ERROR("Start ex advertising failed!");
1522 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1523 callback_->OnStartResultEvent(
1524 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1525 RemoveAdvHandle(advStartHandle);
1526 } else {
1527 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1528 }
1529 }
1530
GapExAdvParamSetCompleteEvt(int status,int8_t txPower) const1531 void BleAdvertiserImpl::GapExAdvParamSetCompleteEvt(int status, int8_t txPower) const
1532 {
1533 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1534
1535 if (pimpl->advHandleQue_.empty()) {
1536 return;
1537 }
1538 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1539 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1540 if (iter == pimpl->advHandleSettingDatas_.end()) {
1541 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1542 return;
1543 }
1544
1545 if (status != BT_SUCCESS) {
1546 LOG_ERROR("Set ex adv parameter failed! %{public}d", status);
1547 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1548 callback_->OnStartResultEvent(
1549 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1550 RemoveAdvHandle(advStartHandle);
1551 return;
1552 }
1553 if ((iter->second.settings_.IsConnectable()) || (iter->second.settings_.IsLegacyMode())) {
1554 int ret = SetExAdvDataToGap(iter->second.advData_, iter->second.settings_, txPower);
1555 pimpl->advHandleQue_.pop();
1556 if (ret != BT_SUCCESS) {
1557 LOG_ERROR("Set ex adv data to gap failed!");
1558 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1559 callback_->OnStartResultEvent(
1560 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1561 RemoveAdvHandle(advStartHandle);
1562 return;
1563 }
1564 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_ADV_DATA));
1565 } else {
1566 int ret = SetExAdvScanRspDataToGap(iter->second.rspData_, iter->second.settings_, txPower);
1567 pimpl->advHandleQue_.pop();
1568 if (ret != BT_SUCCESS) {
1569 LOG_ERROR("Set ex adv response data to gap failed!");
1570 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1571 callback_->OnStartResultEvent(
1572 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1573 RemoveAdvHandle(advStartHandle);
1574 return;
1575 }
1576 }
1577 }
1578
GapExAdvDataSetCompleteEvt(int status,int8_t txPower)1579 void BleAdvertiserImpl::GapExAdvDataSetCompleteEvt(int status, int8_t txPower)
1580 {
1581 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1582
1583 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1584 auto exAdvDataIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1585 if (exAdvDataIter == pimpl->advHandleSettingDatas_.end()) {
1586 pimpl->advHandleQue_.pop();
1587 return;
1588 }
1589
1590 if (status != BT_SUCCESS) {
1591 LOG_ERROR("Set ex adv data failed! %{public}d", status);
1592 callback_->OnStartResultEvent(
1593 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1594 exAdvDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1595 RemoveAdvHandle(advStartHandle);
1596 pimpl->advHandleQue_.pop();
1597 return;
1598 }
1599
1600 if (exAdvDataIter->second.settings_.IsLegacyMode()) {
1601 int ret = SetExAdvScanRspDataToGap(exAdvDataIter->second.rspData_, exAdvDataIter->second.settings_, txPower);
1602 pimpl->advHandleQue_.pop();
1603 if (ret != BT_SUCCESS) {
1604 LOG_ERROR("Set ex adv response data to gap failed!");
1605 exAdvDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1606 callback_->OnStartResultEvent(
1607 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1608 RemoveAdvHandle(advStartHandle);
1609 }
1610 } else {
1611 /// Generate rpa address
1612 if ((BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) && (pimpl->operationLast_)) {
1613 std::unique_lock<std::mutex> exAdvDataLock(pimpl->rpamutex_);
1614 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, this);
1615 if (ret != BT_SUCCESS) {
1616 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1617 }
1618 } else if (pimpl->operationLast_) {
1619 pimpl->advHandleQue_.pop();
1620 int ret = SetExAdvEnableToGap(advStartHandle, true);
1621 if (ret != BT_SUCCESS) {
1622 LOG_ERROR("Start ex advertising failed!");
1623 exAdvDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1624 callback_->OnStartResultEvent(
1625 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1626 RemoveAdvHandle(advStartHandle);
1627 } else {
1628 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1629 }
1630 }
1631 }
1632 }
1633
GapExAdvScanRspDataSetCompleteEvt(int status)1634 void BleAdvertiserImpl::GapExAdvScanRspDataSetCompleteEvt(int status)
1635 {
1636 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1637
1638 if (pimpl->advHandleQue_.empty()) {
1639 return;
1640 }
1641 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1642 auto exAdvScanDataIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1643 if (exAdvScanDataIter == pimpl->advHandleSettingDatas_.end()) {
1644 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1645 pimpl->advHandleQue_.pop();
1646 return;
1647 }
1648
1649 if (status != BT_SUCCESS) {
1650 LOG_ERROR("Set ex scan response data failed! %{public}d", status);
1651 callback_->OnStartResultEvent(
1652 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1653 exAdvScanDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1654 RemoveAdvHandle(advStartHandle);
1655 pimpl->advHandleQue_.pop();
1656 return;
1657 }
1658 if ((BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) && (pimpl->operationLast_)) {
1659 /// Generate rpa address
1660 std::unique_lock<std::mutex> exAdvScanResLock(pimpl->rpamutex_);
1661 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, this);
1662 if (ret != BT_SUCCESS) {
1663 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1664 }
1665 } else if (pimpl->operationLast_) {
1666 pimpl->advHandleQue_.pop();
1667 int ret = SetExAdvEnableToGap(advStartHandle, true);
1668 if (ret != BT_SUCCESS) {
1669 LOG_ERROR("Start ex advertising failed!");
1670 exAdvScanDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1671 callback_->OnStartResultEvent(
1672 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1673 RemoveAdvHandle(advStartHandle);
1674 } else {
1675 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1676 }
1677 }
1678 }
1679
GapExAdvStartCompleteEvt(int status)1680 void BleAdvertiserImpl::GapExAdvStartCompleteEvt(int status)
1681 {
1682 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1683
1684 if (pimpl->advHandleQue_.empty()) {
1685 return;
1686 }
1687 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1688 pimpl->advHandleQue_.pop();
1689 auto exAdvStartIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1690 if (exAdvStartIter == pimpl->advHandleSettingDatas_.end()) {
1691 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1692 return;
1693 }
1694
1695 if (status != BT_SUCCESS) {
1696 LOG_ERROR("Start ex advertising failed! %{public}d", status);
1697 callback_->OnStartResultEvent(
1698 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1699 exAdvStartIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1700 RemoveAdvHandle(advStartHandle);
1701 return;
1702 }
1703
1704 callback_->OnStartResultEvent(status, advStartHandle);
1705 if (BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) {
1706 if (exAdvStartIter->second.timer_ == nullptr) {
1707 exAdvStartIter->second.timer_ =
1708 std::make_unique<utility::Timer>(std::bind(&TimerCallbackEx, this, advStartHandle));
1709 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1710 exAdvStartIter->second.timer_->Start(inerval, true);
1711 }
1712 }
1713
1714 if (bleAdapter_ != nullptr) {
1715 (static_cast<BleAdapter *>(bleAdapter_))->OnStartAdvertisingEvt();
1716 }
1717 }
1718
GAPExAdvClearHandle()1719 void BleAdvertiserImpl::GAPExAdvClearHandle()
1720 {
1721 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1722
1723 if (exAdvCallback_.exAdvClearHandleResult == nullptr) {
1724 RegisterExAdvCallbackToGap();
1725 }
1726
1727 int ret = GAPIF_LeExAdvClearHandle();
1728 if (ret != BT_SUCCESS) {
1729 LOG_ERROR("GAPIF_LeExAdvClearHandle failed! %{public}d", ret);
1730 }
1731 }
1732
GapExAdvStopAllCompleteEvt(int status) const1733 void BleAdvertiserImpl::GapExAdvStopAllCompleteEvt(int status) const
1734 {
1735 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1736 pimpl->advHandleQue_.pop();
1737 if (status != BT_SUCCESS) {
1738 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); iter++) {
1739 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1740 LOG_ERROR("Stop ex advertising failed! %{public}d", status);
1741 }
1742 return;
1743 }
1744 RemoveAllAdvHandle(status);
1745 }
1746
GapExAdvResolvingListStartCompleteEvt(int status) const1747 void BleAdvertiserImpl::GapExAdvResolvingListStartCompleteEvt(int status) const
1748 {
1749 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1750 pimpl->advHandleQue_.pop();
1751 if (status != BT_SUCCESS) {
1752 UpdateAllAdvertisingStatus(ADVERTISE_FAILED_INTERNAL_ERROR);
1753 LOG_ERROR("Stop or start resolving list ex advertising failed! %{public}d", status);
1754 return;
1755 }
1756
1757 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); ++iter) {
1758 if (iter->second.timer_ != nullptr) {
1759 int interval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1760 iter->second.timer_->Start(interval, true);
1761 }
1762 }
1763 }
1764
GapExAdvResolvingListStopCompleteEvt(int status) const1765 void BleAdvertiserImpl::GapExAdvResolvingListStopCompleteEvt(int status) const
1766 {
1767 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1768 pimpl->advHandleQue_.pop();
1769 if (status != BT_SUCCESS) {
1770 UpdateAllAdvertisingStatus(ADVERTISE_FAILED_INTERNAL_ERROR);
1771 LOG_ERROR("Stop or start resolving list ex advertising failed! %{public}d", status);
1772 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); ++iter) {
1773 if (iter->second.timer_ != nullptr) {
1774 int interval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1775 iter->second.timer_->Start(interval, true);
1776 }
1777 }
1778 }
1779 }
1780
GapExAdvStopCompleteEvt(int status) const1781 void BleAdvertiserImpl::GapExAdvStopCompleteEvt(int status) const
1782 {
1783 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1784 if (pimpl->advHandleQue_.empty()) {
1785 LOG_ERROR("[BleAdvertiserImpl] %{public}s advHandleQue_ empty .", __func__);
1786 return;
1787 }
1788 uint8_t tempHandle = pimpl->advHandleQue_.front().advHandle;
1789 pimpl->advHandleQue_.pop();
1790 auto exAdvStopIter = pimpl->advHandleSettingDatas_.find(tempHandle);
1791 if (exAdvStopIter == pimpl->advHandleSettingDatas_.end()) {
1792 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, tempHandle);
1793 return;
1794 }
1795
1796 if (status != BT_SUCCESS) {
1797 exAdvStopIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1798 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop ex advertising failed! %{public}d", __func__, status);
1799 return;
1800 }
1801 RemoveAdvHandle(tempHandle);
1802 }
1803
GapExAdvRemoveHandleResultEvt(int status) const1804 void BleAdvertiserImpl::GapExAdvRemoveHandleResultEvt(int status) const
1805 {
1806 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1807 if (pimpl->advHandleQue_.empty()) {
1808 LOG_ERROR("[BleAdvertiserImpl] %{public}s advHandleQue_ empty .", __func__);
1809 return;
1810 }
1811 uint8_t tempHandle = pimpl->advHandleQue_.front().advHandle;
1812 pimpl->advHandleQue_.pop();
1813 auto exAdvRemoveIter = pimpl->advHandleSettingDatas_.find(tempHandle);
1814 if (exAdvRemoveIter == pimpl->advHandleSettingDatas_.end()) {
1815 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, tempHandle);
1816 return;
1817 }
1818
1819 if (status != BT_SUCCESS) {
1820 exAdvRemoveIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1821 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Remove handle failed! %{public}d", __func__, status);
1822 return;
1823 }
1824 RemoveAdvHandle(tempHandle);
1825 }
1826
GapExAdvTerminatedAdvSetEvt(int status,uint8_t handle) const1827 void BleAdvertiserImpl::GapExAdvTerminatedAdvSetEvt(int status, uint8_t handle) const
1828 {
1829 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1830
1831 auto exAdvTermIter = pimpl->advHandleSettingDatas_.find(handle);
1832 if (exAdvTermIter == pimpl->advHandleSettingDatas_.end()) {
1833 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, handle);
1834 return;
1835 }
1836
1837 if (exAdvTermIter->second.advStatus_ == ADVERTISE_NOT_STARTED) {
1838 LOG_ERROR("[BleAdvertiserImpl] %{public}s:user stop adv handle! %u.", __func__, handle);
1839 return;
1840 }
1841 if (exAdvTermIter->second.timer_ != nullptr) {
1842 exAdvTermIter->second.timer_->Stop();
1843 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1844 exAdvTermIter->second.timer_->Start(inerval, true);
1845 }
1846 exAdvTermIter->second.advStatus_ = ADVERTISE_FAILED_ALREADY_STARTED;
1847
1848 /// Start adv
1849 int ret = SetExAdvEnableToGap(handle, true);
1850 if (ret != BT_SUCCESS) {
1851 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed!.", __func__);
1852 exAdvTermIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1853 RemoveAdvHandle(handle);
1854 } else {
1855 pimpl->advHandleQue_.push(BleAdvertiserImplOp(handle, ADV_STATUS_STARTING));
1856 }
1857 }
1858
HandleGapExAdvEvent(const BLE_GAP_CB_EVENT & event,int status,int8_t txPower,uint8_t handle)1859 void BleAdvertiserImpl::HandleGapExAdvEvent(const BLE_GAP_CB_EVENT &event, int status, int8_t txPower, uint8_t handle)
1860 {
1861 HILOGI("event no: %{public}d.", static_cast<int>(event));
1862 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1863 switch (event) {
1864 case BLE_GAP_EX_ADV_SET_RAND_ADDR_RESULT_EVT:
1865 GapExAdvSetRandAddrResultEvt(status);
1866 break;
1867 case BLE_GAP_EX_ADV_PARAM_SET_COMPLETE_EVT:
1868 GapExAdvParamSetCompleteEvt(status, txPower);
1869 break;
1870 case BLE_GAP_EX_ADV_DATA_SET_COMPLETE_EVT:
1871 GapExAdvDataSetCompleteEvt(status, txPower);
1872 break;
1873 case BLE_GAP_EX_ADV_SCAN_RSP_DATA_SET_COMPLETE_EVT:
1874 GapExAdvScanRspDataSetCompleteEvt(status);
1875 break;
1876 case BLE_GAP_EX_ADV_START_COMPLETE_EVT:
1877 GapExAdvStartCompleteEvt(status);
1878 break;
1879 case BLE_GAP_EX_RESOLVING_LIST_ADV_START_COMPLETE_EVT:
1880 GapExAdvResolvingListStartCompleteEvt(status);
1881 break;
1882 case BLE_GAP_EX_ADV_STOP_COMPLETE_EVT:
1883 GapExAdvStopCompleteEvt(status);
1884 break;
1885 case BLE_GAP_EX_ALL_ADV_STOP_COMPLETE_EVT:
1886 GapExAdvStopAllCompleteEvt(status);
1887 break;
1888 case BLE_GAP_EX_RESOLVING_LIST_ADV_STOP_COMPLETE_EVT:
1889 GapExAdvResolvingListStopCompleteEvt(status);
1890 break;
1891 case BLE_GAP_EX_ADV_REMOVE_HANDLE_RESULT_EVT:
1892 GapExAdvRemoveHandleResultEvt(status);
1893 break;
1894 case BLE_GAP_EX_ADV_CLEAR_HANDLE_RESULT_EVT:
1895 LOG_ERROR("[BleAdvertiserImpl] %{public}s:clrear event! %{public}d.", __func__, event);
1896 break;
1897 case BLE_GAP_EX_ADV_SCAN_REQUEST_RECEIVED_EVT:
1898 LOG_ERROR(
1899 "[BleAdvertiserImpl] %{public}s:scan request! %{public}d status %{public}d.", __func__, event, status);
1900 break;
1901 case BLE_GAP_EX_ADC_TERMINATED_ADV_SET_EVT:
1902 GapExAdvTerminatedAdvSetEvt(status, handle);
1903 break;
1904 default:
1905 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Invalid event! %{public}d.", __func__, event);
1906 break;
1907 }
1908 }
1909
TimerCallback(void * context,uint8_t advHandle)1910 void BleAdvertiserImpl::TimerCallback(void *context, uint8_t advHandle)
1911 {
1912 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
1913
1914 auto *advertiser = static_cast<BleAdvertiserImpl *>(context);
1915 if ((advertiser != nullptr) && (advertiser->dispatcher_ != nullptr)) {
1916 /// Stop adv
1917 auto iter = advertiser->pimpl->advHandleSettingDatas_.find(advHandle);
1918 if (iter == advertiser->pimpl->advHandleSettingDatas_.end()) {
1919 LOG_ERROR("[BleAdvertiserImpl] %{public}s:AdvHandleSettingDatas is empty!", __func__);
1920 return;
1921 }
1922 advertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::SetAdvEnableToGap, advertiser, false));
1923 advertiser->pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STOPING));
1924
1925 std::unique_lock<std::mutex> legacyLock(advertiser->pimpl->rpamutex_);
1926 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, advertiser);
1927 if (ret != BT_SUCCESS) {
1928 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1929 }
1930 if (advertiser->pimpl->cvfull_.wait_for(legacyLock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) ==
1931 std::cv_status::timeout) {
1932 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync timeout!", __func__);
1933 }
1934 /// Start adv
1935 advertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::SetAdvEnableToGap, advertiser, true));
1936 advertiser->pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STARTING));
1937 }
1938 }
1939
TimerCallbackEx(void * context,uint8_t advHandle)1940 void BleAdvertiserImpl::TimerCallbackEx(void *context, uint8_t advHandle)
1941 {
1942 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
1943
1944 auto *advertiser = static_cast<BleAdvertiserImpl *>(context);
1945 if ((advertiser != nullptr) && (advertiser->dispatcher_ != nullptr)) {
1946 /// Stop adv
1947 auto iter = advertiser->pimpl->advHandleSettingDatas_.find(advHandle);
1948 if (iter == advertiser->pimpl->advHandleSettingDatas_.end()) {
1949 LOG_ERROR("[BleAdvertiserImpl] %{public}s:AdvHandleSettingDatas is empty!", __func__);
1950 return;
1951 }
1952 advertiser->dispatcher_->PostTask(
1953 std::bind(&BleAdvertiserImpl::SetExAdvEnableToGap, advertiser, advHandle, false));
1954 advertiser->pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STOPING));
1955
1956 std::unique_lock<std::mutex> exAdvLock(advertiser->pimpl->rpamutex_);
1957 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, advertiser);
1958 if (ret != BT_SUCCESS) {
1959 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1960 }
1961 if (advertiser->pimpl->cvfull_.wait_for(exAdvLock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) ==
1962 std::cv_status::timeout) {
1963 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync timeout!", __func__);
1964 }
1965 /// Start adv in GenResPriAddrResult->GenResPriAddrResultTask
1966 }
1967 }
1968
GenResPriAddrResultTask(uint8_t result,BtAddr btAddr) const1969 void BleAdvertiserImpl::GenResPriAddrResultTask(uint8_t result, BtAddr btAddr) const
1970 {
1971 HILOGI("ResPriAddr = %{public}s", GetEncryptAddr(RawAddress::ConvertToString(btAddr.addr).GetAddress()).c_str());
1972
1973 if (pimpl->advHandleQue_.empty()) {
1974 return;
1975 }
1976 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1977 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1978 if (iter == pimpl->advHandleSettingDatas_.end()) {
1979 LOG_ERROR("[BleAdvertiserImpl] %{public}s:AdvHandleSettingDatas is empty!", __func__);
1980 } else {
1981 if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
1982 pimpl->advHandleQue_.pop();
1983 int ret = GAPIF_LeExAdvSetRandAddr(advStartHandle, &btAddr.addr[0]);
1984 if (ret != BT_SUCCESS) {
1985 LOG_ERROR("Set ex adv rand addr gap failed!");
1986 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1987 callback_->OnStartResultEvent(
1988 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1989 RemoveAdvHandle(advStartHandle);
1990 } else {
1991 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_RAN_ADDR));
1992 }
1993 } else {
1994 int ret = BTM_SetLeRandomAddress(&btAddr);
1995 if (ret != BT_SUCCESS) {
1996 LOG_ERROR("[BleAdapter] %{public}s:GenResPriAddrResult failed!", __func__);
1997 }
1998 pimpl->cvfull_.notify_all();
1999 }
2000 }
2001 }
2002
GenResPriAddrResult(uint8_t result,const uint8_t addr[BT_ADDRESS_SIZE],void * context)2003 void BleAdvertiserImpl::GenResPriAddrResult(uint8_t result, const uint8_t addr[BT_ADDRESS_SIZE], void *context)
2004 {
2005 HILOGI("ResPriAddr = %{public}s", GetEncryptAddr(RawAddress::ConvertToString(addr).GetAddress()).c_str());
2006
2007 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
2008
2009 BtAddr btAddr;
2010 (void)memcpy_s(&btAddr.addr, BT_ADDRESS_SIZE, addr, BT_ADDRESS_SIZE);
2011 btAddr.type = BLE_ADDR_TYPE_RANDOM;
2012
2013 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
2014 bleAdvertiser->dispatcher_->PostTask(
2015 std::bind(&BleAdvertiserImpl::GenResPriAddrResultTask, bleAdvertiser, result, btAddr));
2016 }
2017 }
2018
GetMaxAdvertisingDataLength(const BleAdvertiserSettingsImpl & settings)2019 int BleAdvertiserImpl::GetMaxAdvertisingDataLength(const BleAdvertiserSettingsImpl &settings)
2020 {
2021 if (settings.IsLegacyMode()) {
2022 return BLE_LEGACY_ADV_DATA_LEN_MAX;
2023 } else {
2024 return BleFeature::GetInstance().GetBleMaximumAdvertisingDataLength();
2025 }
2026 }
2027 } // namespace bluetooth
2028 } // namespace OHOS
2029