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(int32_t & status) const1173 uint8_t BleAdvertiserImpl::CreateAdvertiserSetHandle(int32_t &status) 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 // reach max num of advertiser
1200 if (newHandle == end) {
1201 status = ADVERTISE_FAILED_TOO_MANY_ADVERTISERS;
1202 }
1203 return handle;
1204 }
1205
RemoveAdvHandle(uint8_t handle) const1206 void BleAdvertiserImpl::RemoveAdvHandle(uint8_t handle) const
1207 {
1208 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1209
1210 if (!pimpl->advCreateHandles_.empty()) {
1211 pimpl->advCreateHandles_.erase(remove(pimpl->advCreateHandles_.begin(), pimpl->advCreateHandles_.end(), handle),
1212 pimpl->advCreateHandles_.end());
1213 }
1214
1215 auto iter = pimpl->advHandleSettingDatas_.begin();
1216 while (iter != pimpl->advHandleSettingDatas_.end()) {
1217 if (iter->first == handle) {
1218 if (iter->second.timer_ != nullptr) {
1219 iter->second.timer_->Stop();
1220 iter->second.timer_ = nullptr;
1221 }
1222 pimpl->advHandleSettingDatas_.erase(iter++);
1223 } else {
1224 ++iter;
1225 }
1226 }
1227 }
1228
RemoveAllAdvHandle(int status) const1229 void BleAdvertiserImpl::RemoveAllAdvHandle(int status) const
1230 {
1231 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1232 pimpl->advCreateHandles_.clear();
1233 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); iter++) {
1234 if (iter->second.timer_ != nullptr) {
1235 iter->second.timer_->Stop();
1236 iter->second.timer_ = nullptr;
1237 }
1238 }
1239 pimpl->advHandleSettingDatas_.clear();
1240 }
1241
AddCharacteristicValue(uint8_t adtype,const std::string & data) const1242 void BleAdvertiserImpl::AddCharacteristicValue(uint8_t adtype, const std::string &data) const
1243 {
1244 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1245 if (pimpl->advHandleQue_.empty()) {
1246 return;
1247 }
1248 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1249 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1250 if (iter == pimpl->advHandleSettingDatas_.end()) {
1251 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1252 return;
1253 }
1254 iter->second.advData_.AddCharacteristicValue(adtype, data);
1255 }
1256
GapAdvParamSetCompleteEvt(int status) const1257 void BleAdvertiserImpl::GapAdvParamSetCompleteEvt(int status) const
1258 {
1259 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1260 if (pimpl->advHandleQue_.empty()) {
1261 return;
1262 }
1263 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1264 pimpl->advHandleQue_.pop();
1265 auto paraIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1266 if (paraIter == pimpl->advHandleSettingDatas_.end()) {
1267 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1268 return;
1269 }
1270
1271 if (status != BT_SUCCESS) {
1272 paraIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1273 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1274 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv param failed! %{public}d.", __func__, status);
1275 return;
1276 }
1277 int ret = GAPIF_LeAdvReadTxPower();
1278 if (ret != BT_SUCCESS) {
1279 paraIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1280 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Read adv tx power from gap failed! %{public}d.", __func__, ret);
1281 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1282 } else {
1283 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_READ_TX_POWER));
1284 }
1285 }
1286
GapAdvReadTxPowerEvt(int status,int8_t txPower) const1287 void BleAdvertiserImpl::GapAdvReadTxPowerEvt(int status, int8_t txPower) const
1288 {
1289 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1290
1291 if (pimpl->advHandleQue_.empty()) {
1292 return;
1293 }
1294 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1295 pimpl->advHandleQue_.pop();
1296 auto txPowerIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1297 if (txPowerIter == pimpl->advHandleSettingDatas_.end()) {
1298 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1299 return;
1300 }
1301
1302 if (status != BT_SUCCESS) {
1303 txPowerIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1304 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1305 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Read tx power failed! %{public}d.", __func__, status);
1306 return;
1307 }
1308 int ret = SetAdvDataToGap(txPowerIter->second.advData_, txPowerIter->second.settings_, txPower);
1309 if (ret != BT_SUCCESS) {
1310 txPowerIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1311 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv data to gap failed! %{public}d.", __func__, ret);
1312 callback_->OnStartResultEvent(ADVERTISE_FAILED_DATA_TOO_LARGE, advStartHandle);
1313 } else {
1314 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_ADV_DATA));
1315 }
1316 }
1317
GapAdvDataSetCompleteEvt(int status,int8_t txPower) const1318 void BleAdvertiserImpl::GapAdvDataSetCompleteEvt(int status, int8_t txPower) const
1319 {
1320 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1321
1322 if (pimpl->advHandleQue_.empty()) {
1323 return;
1324 }
1325 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1326 pimpl->advHandleQue_.pop();
1327 auto dataIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1328 if (dataIter == pimpl->advHandleSettingDatas_.end()) {
1329 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1330 return;
1331 }
1332
1333 if (status != BT_SUCCESS) {
1334 dataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1335 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1336 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv data failed! %{public}d.", __func__, status);
1337 return;
1338 }
1339 int ret = SetAdvScanRspDataToGap(dataIter->second.rspData_, dataIter->second.settings_, txPower);
1340 if (ret != BT_SUCCESS) {
1341 dataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1342 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set adv response data to gap failed! %{public}d.", __func__, ret);
1343 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1344 } else {
1345 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_SCAN_DATA));
1346 }
1347 }
1348
GapAdvScanRspDataSetCompleteEvt(int status) const1349 void BleAdvertiserImpl::GapAdvScanRspDataSetCompleteEvt(int status) const
1350 {
1351 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1352
1353 if (pimpl->advHandleQue_.empty()) {
1354 return;
1355 }
1356 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1357 pimpl->advHandleQue_.pop();
1358 auto scanResIter = pimpl->advHandleSettingDatas_.find(pimpl->advHandleQue_.front().advHandle);
1359 if (scanResIter == pimpl->advHandleSettingDatas_.end()) {
1360 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1361 return;
1362 }
1363
1364 if (status != BT_SUCCESS) {
1365 scanResIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1366 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1367 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Set scan response data failed! %{public}d.", __func__, status);
1368 return;
1369 }
1370 int ret = SetAdvEnableToGap(true);
1371 if (ret != BT_SUCCESS) {
1372 scanResIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1373 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed! %{public}d.", __func__, ret);
1374 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1375 } else {
1376 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1377 }
1378 }
1379
GapAdvStartCompleteEvt(int status)1380 void BleAdvertiserImpl::GapAdvStartCompleteEvt(int status)
1381 {
1382 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1383
1384 if (pimpl->advHandleQue_.empty()) {
1385 return;
1386 }
1387 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1388 auto startIter = pimpl->advHandleSettingDatas_.find(pimpl->advHandleQue_.front().advHandle);
1389 pimpl->advHandleQue_.pop();
1390 if (startIter == pimpl->advHandleSettingDatas_.end()) {
1391 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1392 return;
1393 }
1394
1395 if (startIter->second.stopAllAdvType_ == STOP_ADV_TYPE_RESOLVING_LIST) {
1396 if (status != BT_SUCCESS) {
1397 startIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1398 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed! %{public}d.", __func__, status);
1399 } else {
1400 if (startIter->second.timer_ != nullptr) {
1401 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1402 startIter->second.timer_->Start(inerval, true);
1403 }
1404 }
1405 return;
1406 }
1407
1408 if (status != BT_SUCCESS) {
1409 startIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1410 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed! %{public}d.", __func__, status);
1411 callback_->OnStartResultEvent(ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle);
1412 return;
1413 }
1414 callback_->OnStartResultEvent(status, advStartHandle);
1415 if (BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) {
1416 if (startIter->second.timer_ == nullptr) {
1417 startIter->second.timer_ =
1418 std::make_unique<utility::Timer>(std::bind(&TimerCallback, this, advStartHandle));
1419 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1420 startIter->second.timer_->Start(inerval, true);
1421 }
1422 }
1423 (static_cast<BleAdapter *>(bleAdapter_))->OnStartAdvertisingEvt();
1424 }
1425
GapAdvStopCompleteEvt(int status) const1426 void BleAdvertiserImpl::GapAdvStopCompleteEvt(int status) const
1427 {
1428 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1429
1430 if (pimpl->advHandleQue_.empty()) {
1431 return;
1432 }
1433 uint8_t advStopHandle = pimpl->advHandleQue_.front().advHandle;
1434 pimpl->advHandleQue_.pop();
1435 auto stopIter = pimpl->advHandleSettingDatas_.find(advStopHandle);
1436 if (stopIter == pimpl->advHandleSettingDatas_.end()) {
1437 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStopHandle);
1438 return;
1439 }
1440
1441 switch (stopIter->second.stopAllAdvType_) {
1442 case STOP_ADV_TYPE_SINGLE:
1443 break;
1444 case STOP_ADV_TYPE_ALL:
1445 callback_->OnAutoStopAdvEvent(advStopHandle);
1446 break;
1447 case STOP_ADV_TYPE_RESOLVING_LIST:
1448 if (status != BT_SUCCESS) {
1449 stopIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1450 if (stopIter->second.timer_ != nullptr) {
1451 int interval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1452 stopIter->second.timer_->Start(interval, true);
1453 }
1454 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop advertising failed! %{public}d.", __func__, status);
1455 }
1456 return;
1457 default:
1458 break;
1459 }
1460
1461 if (status != BT_SUCCESS) {
1462 stopIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1463 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop advertising failed! %{public}d.", __func__, status);
1464 return;
1465 }
1466 RemoveAdvHandle(advStopHandle);
1467 (static_cast<BleAdapter *>(bleAdapter_))->OnStopAdvertisingEvt();
1468 }
1469
HandleGapEvent(const BLE_GAP_CB_EVENT & event,int status,int8_t txPower)1470 void BleAdvertiserImpl::HandleGapEvent(const BLE_GAP_CB_EVENT &event, int status, int8_t txPower)
1471 {
1472 LOG_DEBUG("[BleAdvertiserImpl] %{public}s:[event no: %{public}d]", __func__, static_cast<int>(event));
1473 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1474 switch (event) {
1475 case BLE_GAP_ADV_PARAM_SET_COMPLETE_EVT:
1476 GapAdvParamSetCompleteEvt(status);
1477 break;
1478 case BLE_GAP_ADV_READ_TXPOWER_EVT:
1479 GapAdvReadTxPowerEvt(status, txPower);
1480 break;
1481 case BLE_GAP_ADV_DATA_SET_COMPLETE_EVT:
1482 GapAdvDataSetCompleteEvt(status, txPower);
1483 break;
1484 case BLE_GAP_ADV_SCAN_RSP_DATA_SET_COMPLETE_EVT:
1485 GapAdvScanRspDataSetCompleteEvt(status);
1486 break;
1487 case BLE_GAP_ADV_START_COMPLETE_EVT:
1488 GapAdvStartCompleteEvt(status);
1489 break;
1490 case BLE_GAP_ADV_STOP_COMPLETE_EVT:
1491 GapAdvStopCompleteEvt(status);
1492 break;
1493 default:
1494 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Invalid event! %{public}d.", __func__, event);
1495 break;
1496 }
1497 }
1498
GapExAdvSetRandAddrResultEvt(int status) const1499 void BleAdvertiserImpl::GapExAdvSetRandAddrResultEvt(int status) const
1500 {
1501 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1502
1503 if (pimpl->advHandleQue_.empty()) {
1504 return;
1505 }
1506 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1507 pimpl->advHandleQue_.pop();
1508 pimpl->cvfull_.notify_all();
1509 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1510 if (iter == pimpl->advHandleSettingDatas_.end()) {
1511 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1512 return;
1513 }
1514
1515 if (status != BT_SUCCESS) {
1516 LOG_ERROR("Set rand addr failed! %{public}d", status);
1517 callback_->OnStartResultEvent(
1518 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1519 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1520 RemoveAdvHandle(advStartHandle);
1521 return;
1522 }
1523 int ret = SetExAdvEnableToGap(advStartHandle, true);
1524 if (ret != BT_SUCCESS) {
1525 LOG_ERROR("Start ex advertising failed!");
1526 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1527 callback_->OnStartResultEvent(
1528 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1529 RemoveAdvHandle(advStartHandle);
1530 } else {
1531 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1532 }
1533 }
1534
GapExAdvParamSetCompleteEvt(int status,int8_t txPower) const1535 void BleAdvertiserImpl::GapExAdvParamSetCompleteEvt(int status, int8_t txPower) const
1536 {
1537 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1538
1539 if (pimpl->advHandleQue_.empty()) {
1540 return;
1541 }
1542 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1543 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1544 if (iter == pimpl->advHandleSettingDatas_.end()) {
1545 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1546 return;
1547 }
1548
1549 if (status != BT_SUCCESS) {
1550 LOG_ERROR("Set ex adv parameter failed! %{public}d", status);
1551 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1552 callback_->OnStartResultEvent(
1553 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1554 RemoveAdvHandle(advStartHandle);
1555 return;
1556 }
1557 if ((iter->second.settings_.IsConnectable()) || (iter->second.settings_.IsLegacyMode())) {
1558 int ret = SetExAdvDataToGap(iter->second.advData_, iter->second.settings_, txPower);
1559 pimpl->advHandleQue_.pop();
1560 if (ret != BT_SUCCESS) {
1561 LOG_ERROR("Set ex adv data to gap failed!");
1562 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1563 callback_->OnStartResultEvent(
1564 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1565 RemoveAdvHandle(advStartHandle);
1566 return;
1567 }
1568 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_ADV_DATA));
1569 } else {
1570 int ret = SetExAdvScanRspDataToGap(iter->second.rspData_, iter->second.settings_, txPower);
1571 pimpl->advHandleQue_.pop();
1572 if (ret != BT_SUCCESS) {
1573 LOG_ERROR("Set ex adv response data to gap failed!");
1574 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1575 callback_->OnStartResultEvent(
1576 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1577 RemoveAdvHandle(advStartHandle);
1578 return;
1579 }
1580 }
1581 }
1582
GapExAdvDataSetCompleteEvt(int status,int8_t txPower)1583 void BleAdvertiserImpl::GapExAdvDataSetCompleteEvt(int status, int8_t txPower)
1584 {
1585 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1586
1587 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1588 auto exAdvDataIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1589 if (exAdvDataIter == pimpl->advHandleSettingDatas_.end()) {
1590 pimpl->advHandleQue_.pop();
1591 return;
1592 }
1593
1594 if (status != BT_SUCCESS) {
1595 LOG_ERROR("Set ex adv data failed! %{public}d", status);
1596 callback_->OnStartResultEvent(
1597 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1598 exAdvDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1599 RemoveAdvHandle(advStartHandle);
1600 pimpl->advHandleQue_.pop();
1601 return;
1602 }
1603
1604 if (exAdvDataIter->second.settings_.IsLegacyMode()) {
1605 int ret = SetExAdvScanRspDataToGap(exAdvDataIter->second.rspData_, exAdvDataIter->second.settings_, txPower);
1606 pimpl->advHandleQue_.pop();
1607 if (ret != BT_SUCCESS) {
1608 LOG_ERROR("Set ex adv response data to gap failed!");
1609 exAdvDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1610 callback_->OnStartResultEvent(
1611 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1612 RemoveAdvHandle(advStartHandle);
1613 }
1614 } else {
1615 /// Generate rpa address
1616 if ((BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) && (pimpl->operationLast_)) {
1617 std::unique_lock<std::mutex> exAdvDataLock(pimpl->rpamutex_);
1618 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, this);
1619 if (ret != BT_SUCCESS) {
1620 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1621 }
1622 } else if (pimpl->operationLast_) {
1623 pimpl->advHandleQue_.pop();
1624 int ret = SetExAdvEnableToGap(advStartHandle, true);
1625 if (ret != BT_SUCCESS) {
1626 LOG_ERROR("Start ex advertising failed!");
1627 exAdvDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1628 callback_->OnStartResultEvent(
1629 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1630 RemoveAdvHandle(advStartHandle);
1631 } else {
1632 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1633 }
1634 }
1635 }
1636 }
1637
GapExAdvScanRspDataSetCompleteEvt(int status)1638 void BleAdvertiserImpl::GapExAdvScanRspDataSetCompleteEvt(int status)
1639 {
1640 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1641
1642 if (pimpl->advHandleQue_.empty()) {
1643 return;
1644 }
1645 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1646 auto exAdvScanDataIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1647 if (exAdvScanDataIter == pimpl->advHandleSettingDatas_.end()) {
1648 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1649 pimpl->advHandleQue_.pop();
1650 return;
1651 }
1652
1653 if (status != BT_SUCCESS) {
1654 LOG_ERROR("Set ex scan response data failed! %{public}d", status);
1655 callback_->OnStartResultEvent(
1656 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1657 exAdvScanDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1658 RemoveAdvHandle(advStartHandle);
1659 pimpl->advHandleQue_.pop();
1660 return;
1661 }
1662 if ((BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) && (pimpl->operationLast_)) {
1663 /// Generate rpa address
1664 std::unique_lock<std::mutex> exAdvScanResLock(pimpl->rpamutex_);
1665 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, this);
1666 if (ret != BT_SUCCESS) {
1667 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1668 }
1669 } else if (pimpl->operationLast_) {
1670 pimpl->advHandleQue_.pop();
1671 int ret = SetExAdvEnableToGap(advStartHandle, true);
1672 if (ret != BT_SUCCESS) {
1673 LOG_ERROR("Start ex advertising failed!");
1674 exAdvScanDataIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1675 callback_->OnStartResultEvent(
1676 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1677 RemoveAdvHandle(advStartHandle);
1678 } else {
1679 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_STARTING));
1680 }
1681 }
1682 }
1683
GapExAdvStartCompleteEvt(int status)1684 void BleAdvertiserImpl::GapExAdvStartCompleteEvt(int status)
1685 {
1686 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1687
1688 if (pimpl->advHandleQue_.empty()) {
1689 return;
1690 }
1691 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1692 pimpl->advHandleQue_.pop();
1693 auto exAdvStartIter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1694 if (exAdvStartIter == pimpl->advHandleSettingDatas_.end()) {
1695 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, advStartHandle);
1696 return;
1697 }
1698
1699 if (status != BT_SUCCESS) {
1700 LOG_ERROR("Start ex advertising failed! %{public}d", status);
1701 callback_->OnStartResultEvent(
1702 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1703 exAdvStartIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1704 RemoveAdvHandle(advStartHandle);
1705 return;
1706 }
1707
1708 callback_->OnStartResultEvent(status, advStartHandle);
1709 if (BleConfig::GetInstance().GetBleAddrType() == BLE_ADDR_TYPE_RPA) {
1710 if (exAdvStartIter->second.timer_ == nullptr) {
1711 exAdvStartIter->second.timer_ =
1712 std::make_unique<utility::Timer>(std::bind(&TimerCallbackEx, this, advStartHandle));
1713 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1714 exAdvStartIter->second.timer_->Start(inerval, true);
1715 }
1716 }
1717
1718 if (bleAdapter_ != nullptr) {
1719 (static_cast<BleAdapter *>(bleAdapter_))->OnStartAdvertisingEvt();
1720 }
1721 }
1722
GAPExAdvClearHandle()1723 void BleAdvertiserImpl::GAPExAdvClearHandle()
1724 {
1725 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1726
1727 if (exAdvCallback_.exAdvClearHandleResult == nullptr) {
1728 RegisterExAdvCallbackToGap();
1729 }
1730
1731 int ret = GAPIF_LeExAdvClearHandle();
1732 if (ret != BT_SUCCESS) {
1733 LOG_ERROR("GAPIF_LeExAdvClearHandle failed! %{public}d", ret);
1734 }
1735 }
1736
GapExAdvStopAllCompleteEvt(int status) const1737 void BleAdvertiserImpl::GapExAdvStopAllCompleteEvt(int status) const
1738 {
1739 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1740 pimpl->advHandleQue_.pop();
1741 if (status != BT_SUCCESS) {
1742 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); iter++) {
1743 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1744 LOG_ERROR("Stop ex advertising failed! %{public}d", status);
1745 }
1746 return;
1747 }
1748 RemoveAllAdvHandle(status);
1749 }
1750
GapExAdvResolvingListStartCompleteEvt(int status) const1751 void BleAdvertiserImpl::GapExAdvResolvingListStartCompleteEvt(int status) const
1752 {
1753 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1754 pimpl->advHandleQue_.pop();
1755 if (status != BT_SUCCESS) {
1756 UpdateAllAdvertisingStatus(ADVERTISE_FAILED_INTERNAL_ERROR);
1757 LOG_ERROR("Stop or start resolving list ex advertising failed! %{public}d", status);
1758 return;
1759 }
1760
1761 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); ++iter) {
1762 if (iter->second.timer_ != nullptr) {
1763 int interval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1764 iter->second.timer_->Start(interval, true);
1765 }
1766 }
1767 }
1768
GapExAdvResolvingListStopCompleteEvt(int status) const1769 void BleAdvertiserImpl::GapExAdvResolvingListStopCompleteEvt(int status) const
1770 {
1771 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1772 pimpl->advHandleQue_.pop();
1773 if (status != BT_SUCCESS) {
1774 UpdateAllAdvertisingStatus(ADVERTISE_FAILED_INTERNAL_ERROR);
1775 LOG_ERROR("Stop or start resolving list ex advertising failed! %{public}d", status);
1776 for (auto iter = pimpl->advHandleSettingDatas_.begin(); iter != pimpl->advHandleSettingDatas_.end(); ++iter) {
1777 if (iter->second.timer_ != nullptr) {
1778 int interval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1779 iter->second.timer_->Start(interval, true);
1780 }
1781 }
1782 }
1783 }
1784
GapExAdvStopCompleteEvt(int status) const1785 void BleAdvertiserImpl::GapExAdvStopCompleteEvt(int status) const
1786 {
1787 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1788 if (pimpl->advHandleQue_.empty()) {
1789 LOG_ERROR("[BleAdvertiserImpl] %{public}s advHandleQue_ empty .", __func__);
1790 return;
1791 }
1792 uint8_t tempHandle = pimpl->advHandleQue_.front().advHandle;
1793 pimpl->advHandleQue_.pop();
1794 auto exAdvStopIter = pimpl->advHandleSettingDatas_.find(tempHandle);
1795 if (exAdvStopIter == pimpl->advHandleSettingDatas_.end()) {
1796 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, tempHandle);
1797 return;
1798 }
1799
1800 if (status != BT_SUCCESS) {
1801 exAdvStopIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1802 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Stop ex advertising failed! %{public}d", __func__, status);
1803 return;
1804 }
1805 RemoveAdvHandle(tempHandle);
1806 }
1807
GapExAdvRemoveHandleResultEvt(int status) const1808 void BleAdvertiserImpl::GapExAdvRemoveHandleResultEvt(int status) const
1809 {
1810 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1811 if (pimpl->advHandleQue_.empty()) {
1812 LOG_ERROR("[BleAdvertiserImpl] %{public}s advHandleQue_ empty .", __func__);
1813 return;
1814 }
1815 uint8_t tempHandle = pimpl->advHandleQue_.front().advHandle;
1816 pimpl->advHandleQue_.pop();
1817 auto exAdvRemoveIter = pimpl->advHandleSettingDatas_.find(tempHandle);
1818 if (exAdvRemoveIter == pimpl->advHandleSettingDatas_.end()) {
1819 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, tempHandle);
1820 return;
1821 }
1822
1823 if (status != BT_SUCCESS) {
1824 exAdvRemoveIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1825 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Remove handle failed! %{public}d", __func__, status);
1826 return;
1827 }
1828 RemoveAdvHandle(tempHandle);
1829 }
1830
GapExAdvTerminatedAdvSetEvt(int status,uint8_t handle) const1831 void BleAdvertiserImpl::GapExAdvTerminatedAdvSetEvt(int status, uint8_t handle) const
1832 {
1833 LOG_DEBUG("[BleAdvertiserImpl] %{public}s,%{public}zu", __func__, pimpl->advHandleQue_.size());
1834
1835 auto exAdvTermIter = pimpl->advHandleSettingDatas_.find(handle);
1836 if (exAdvTermIter == pimpl->advHandleSettingDatas_.end()) {
1837 LOG_ERROR("[BleAdvertiserImpl] %{public}s:invalid handle! %u.", __func__, handle);
1838 return;
1839 }
1840
1841 if (exAdvTermIter->second.advStatus_ == ADVERTISE_NOT_STARTED) {
1842 LOG_ERROR("[BleAdvertiserImpl] %{public}s:user stop adv handle! %u.", __func__, handle);
1843 return;
1844 }
1845 if (exAdvTermIter->second.timer_ != nullptr) {
1846 exAdvTermIter->second.timer_->Stop();
1847 int inerval = BLE_CHANGE_RPA_ADDRESS_INTERVAL;
1848 exAdvTermIter->second.timer_->Start(inerval, true);
1849 }
1850 exAdvTermIter->second.advStatus_ = ADVERTISE_FAILED_ALREADY_STARTED;
1851
1852 /// Start adv
1853 int ret = SetExAdvEnableToGap(handle, true);
1854 if (ret != BT_SUCCESS) {
1855 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Start advertising failed!.", __func__);
1856 exAdvTermIter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1857 RemoveAdvHandle(handle);
1858 } else {
1859 pimpl->advHandleQue_.push(BleAdvertiserImplOp(handle, ADV_STATUS_STARTING));
1860 }
1861 }
1862
HandleGapExAdvEvent(const BLE_GAP_CB_EVENT & event,int status,int8_t txPower,uint8_t handle)1863 void BleAdvertiserImpl::HandleGapExAdvEvent(const BLE_GAP_CB_EVENT &event, int status, int8_t txPower, uint8_t handle)
1864 {
1865 HILOGI("event no: %{public}d.", static_cast<int>(event));
1866 std::lock_guard<std::recursive_mutex> lk(pimpl->mutex_);
1867 switch (event) {
1868 case BLE_GAP_EX_ADV_SET_RAND_ADDR_RESULT_EVT:
1869 GapExAdvSetRandAddrResultEvt(status);
1870 break;
1871 case BLE_GAP_EX_ADV_PARAM_SET_COMPLETE_EVT:
1872 GapExAdvParamSetCompleteEvt(status, txPower);
1873 break;
1874 case BLE_GAP_EX_ADV_DATA_SET_COMPLETE_EVT:
1875 GapExAdvDataSetCompleteEvt(status, txPower);
1876 break;
1877 case BLE_GAP_EX_ADV_SCAN_RSP_DATA_SET_COMPLETE_EVT:
1878 GapExAdvScanRspDataSetCompleteEvt(status);
1879 break;
1880 case BLE_GAP_EX_ADV_START_COMPLETE_EVT:
1881 GapExAdvStartCompleteEvt(status);
1882 break;
1883 case BLE_GAP_EX_RESOLVING_LIST_ADV_START_COMPLETE_EVT:
1884 GapExAdvResolvingListStartCompleteEvt(status);
1885 break;
1886 case BLE_GAP_EX_ADV_STOP_COMPLETE_EVT:
1887 GapExAdvStopCompleteEvt(status);
1888 break;
1889 case BLE_GAP_EX_ALL_ADV_STOP_COMPLETE_EVT:
1890 GapExAdvStopAllCompleteEvt(status);
1891 break;
1892 case BLE_GAP_EX_RESOLVING_LIST_ADV_STOP_COMPLETE_EVT:
1893 GapExAdvResolvingListStopCompleteEvt(status);
1894 break;
1895 case BLE_GAP_EX_ADV_REMOVE_HANDLE_RESULT_EVT:
1896 GapExAdvRemoveHandleResultEvt(status);
1897 break;
1898 case BLE_GAP_EX_ADV_CLEAR_HANDLE_RESULT_EVT:
1899 LOG_ERROR("[BleAdvertiserImpl] %{public}s:clrear event! %{public}d.", __func__, event);
1900 break;
1901 case BLE_GAP_EX_ADV_SCAN_REQUEST_RECEIVED_EVT:
1902 LOG_ERROR(
1903 "[BleAdvertiserImpl] %{public}s:scan request! %{public}d status %{public}d.", __func__, event, status);
1904 break;
1905 case BLE_GAP_EX_ADC_TERMINATED_ADV_SET_EVT:
1906 GapExAdvTerminatedAdvSetEvt(status, handle);
1907 break;
1908 default:
1909 LOG_ERROR("[BleAdvertiserImpl] %{public}s:Invalid event! %{public}d.", __func__, event);
1910 break;
1911 }
1912 }
1913
TimerCallback(void * context,uint8_t advHandle)1914 void BleAdvertiserImpl::TimerCallback(void *context, uint8_t advHandle)
1915 {
1916 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
1917
1918 auto *advertiser = static_cast<BleAdvertiserImpl *>(context);
1919 if ((advertiser != nullptr) && (advertiser->dispatcher_ != nullptr)) {
1920 /// Stop adv
1921 auto iter = advertiser->pimpl->advHandleSettingDatas_.find(advHandle);
1922 if (iter == advertiser->pimpl->advHandleSettingDatas_.end()) {
1923 LOG_ERROR("[BleAdvertiserImpl] %{public}s:AdvHandleSettingDatas is empty!", __func__);
1924 return;
1925 }
1926 advertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::SetAdvEnableToGap, advertiser, false));
1927 advertiser->pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STOPING));
1928
1929 std::unique_lock<std::mutex> legacyLock(advertiser->pimpl->rpamutex_);
1930 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, advertiser);
1931 if (ret != BT_SUCCESS) {
1932 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1933 }
1934 if (advertiser->pimpl->cvfull_.wait_for(legacyLock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) ==
1935 std::cv_status::timeout) {
1936 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync timeout!", __func__);
1937 }
1938 /// Start adv
1939 advertiser->dispatcher_->PostTask(std::bind(&BleAdvertiserImpl::SetAdvEnableToGap, advertiser, true));
1940 advertiser->pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STARTING));
1941 }
1942 }
1943
TimerCallbackEx(void * context,uint8_t advHandle)1944 void BleAdvertiserImpl::TimerCallbackEx(void *context, uint8_t advHandle)
1945 {
1946 LOG_DEBUG("[BleAdvertiserImpl] %{public}s", __func__);
1947
1948 auto *advertiser = static_cast<BleAdvertiserImpl *>(context);
1949 if ((advertiser != nullptr) && (advertiser->dispatcher_ != nullptr)) {
1950 /// Stop adv
1951 auto iter = advertiser->pimpl->advHandleSettingDatas_.find(advHandle);
1952 if (iter == advertiser->pimpl->advHandleSettingDatas_.end()) {
1953 LOG_ERROR("[BleAdvertiserImpl] %{public}s:AdvHandleSettingDatas is empty!", __func__);
1954 return;
1955 }
1956 advertiser->dispatcher_->PostTask(
1957 std::bind(&BleAdvertiserImpl::SetExAdvEnableToGap, advertiser, advHandle, false));
1958 advertiser->pimpl->advHandleQue_.push(BleAdvertiserImplOp(advHandle, ADV_STATUS_STOPING));
1959
1960 std::unique_lock<std::mutex> exAdvLock(advertiser->pimpl->rpamutex_);
1961 int ret = GAPIF_LeGenResPriAddr(&BleAdvertiserImpl::GenResPriAddrResult, advertiser);
1962 if (ret != BT_SUCCESS) {
1963 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync failed!", __func__);
1964 }
1965 if (advertiser->pimpl->cvfull_.wait_for(exAdvLock, std::chrono::seconds(BLE_THREAD_WAIT_TIMEOUT)) ==
1966 std::cv_status::timeout) {
1967 LOG_ERROR("[BleAdvertiserImpl] %{public}s:GAP_LeGenResPriAddrAsync timeout!", __func__);
1968 }
1969 /// Start adv in GenResPriAddrResult->GenResPriAddrResultTask
1970 }
1971 }
1972
GenResPriAddrResultTask(uint8_t result,BtAddr btAddr) const1973 void BleAdvertiserImpl::GenResPriAddrResultTask(uint8_t result, BtAddr btAddr) const
1974 {
1975 HILOGI("ResPriAddr = %{public}s", GetEncryptAddr(RawAddress::ConvertToString(btAddr.addr).GetAddress()).c_str());
1976
1977 if (pimpl->advHandleQue_.empty()) {
1978 return;
1979 }
1980 uint8_t advStartHandle = pimpl->advHandleQue_.front().advHandle;
1981 auto iter = pimpl->advHandleSettingDatas_.find(advStartHandle);
1982 if (iter == pimpl->advHandleSettingDatas_.end()) {
1983 LOG_ERROR("[BleAdvertiserImpl] %{public}s:AdvHandleSettingDatas is empty!", __func__);
1984 } else {
1985 if (BleFeature::GetInstance().IsLeExtendedAdvertisingSupported()) {
1986 pimpl->advHandleQue_.pop();
1987 int ret = GAPIF_LeExAdvSetRandAddr(advStartHandle, &btAddr.addr[0]);
1988 if (ret != BT_SUCCESS) {
1989 LOG_ERROR("Set ex adv rand addr gap failed!");
1990 iter->second.advStatus_ = ADVERTISE_FAILED_INTERNAL_ERROR;
1991 callback_->OnStartResultEvent(
1992 ADVERTISE_FAILED_INTERNAL_ERROR, advStartHandle, BLE_ADV_START_FAILED_OP_CODE);
1993 RemoveAdvHandle(advStartHandle);
1994 } else {
1995 pimpl->advHandleQue_.push(BleAdvertiserImplOp(advStartHandle, ADV_STATUS_SET_RAN_ADDR));
1996 }
1997 } else {
1998 int ret = BTM_SetLeRandomAddress(&btAddr);
1999 if (ret != BT_SUCCESS) {
2000 LOG_ERROR("[BleAdapter] %{public}s:GenResPriAddrResult failed!", __func__);
2001 }
2002 pimpl->cvfull_.notify_all();
2003 }
2004 }
2005 }
2006
GenResPriAddrResult(uint8_t result,const uint8_t addr[BT_ADDRESS_SIZE],void * context)2007 void BleAdvertiserImpl::GenResPriAddrResult(uint8_t result, const uint8_t addr[BT_ADDRESS_SIZE], void *context)
2008 {
2009 HILOGI("ResPriAddr = %{public}s", GetEncryptAddr(RawAddress::ConvertToString(addr).GetAddress()).c_str());
2010
2011 auto *bleAdvertiser = static_cast<BleAdvertiserImpl *>(context);
2012
2013 BtAddr btAddr;
2014 (void)memcpy_s(&btAddr.addr, BT_ADDRESS_SIZE, addr, BT_ADDRESS_SIZE);
2015 btAddr.type = BLE_ADDR_TYPE_RANDOM;
2016
2017 if ((bleAdvertiser != nullptr) && (bleAdvertiser->dispatcher_ != nullptr)) {
2018 bleAdvertiser->dispatcher_->PostTask(
2019 std::bind(&BleAdvertiserImpl::GenResPriAddrResultTask, bleAdvertiser, result, btAddr));
2020 }
2021 }
2022
GetMaxAdvertisingDataLength(const BleAdvertiserSettingsImpl & settings)2023 int BleAdvertiserImpl::GetMaxAdvertisingDataLength(const BleAdvertiserSettingsImpl &settings)
2024 {
2025 if (settings.IsLegacyMode()) {
2026 return BLE_LEGACY_ADV_DATA_LEN_MAX;
2027 } else {
2028 return BleFeature::GetInstance().GetBleMaximumAdvertisingDataLength();
2029 }
2030 }
2031 } // namespace bluetooth
2032 } // namespace OHOS
2033