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