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