1 /*
2  * Copyright (C) 2021 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 #include "bluetooth_ble_advertiser.h"
16 
17 #include "bluetooth_ble_advertise_callback_stub.h"
18 #include "bluetooth_def.h"
19 #include "bluetooth_host.h"
20 #include "bluetooth_log.h"
21 #include "bluetooth_observer_map.h"
22 #include "bluetooth_utils.h"
23 #include "i_bluetooth_ble_advertiser.h"
24 #include "iservice_registry.h"
25 #include "system_ability_definition.h"
26 #include "securec.h"
27 
28 #include <memory>
29 #include "bluetooth_profile_manager.h"
30 
31 namespace OHOS {
32 namespace Bluetooth {
33 using namespace OHOS::bluetooth;
34 struct BleAdvertiser::impl {
35     impl();
36     ~impl();
37     void Init(std::weak_ptr<BleAdvertiser> advertiser);
38     void ConvertBleAdvertiserData(const BleAdvertiserData &data, BluetoothBleAdvertiserData &outData);
39     uint32_t GetAdvertiserTotalBytes(const BluetoothBleAdvertiserData &data, bool isFlagsIncluded);
40     int32_t CheckAdvertiserSettings(const BleAdvertiserSettings &settings);
41     int32_t CheckAdvertiserData(const BluetoothBleAdvertiserSettings &setting,
42         const BluetoothBleAdvertiserData &advData, const BluetoothBleAdvertiserData &scanResponse);
43 
44     class BluetoothBleAdvertiserCallbackImp : public BluetoothBleAdvertiseCallbackStub {
45     public:
BluetoothBleAdvertiserCallbackImp(std::weak_ptr<BleAdvertiser> advertiser)46         explicit BluetoothBleAdvertiserCallbackImp(std::weak_ptr<BleAdvertiser> advertiser)
47             : advertiser_(advertiser){};
~BluetoothBleAdvertiserCallbackImp()48         ~BluetoothBleAdvertiserCallbackImp()
49         {}
50 
51         __attribute__((no_sanitize("cfi")))
52         void OnStartResultEvent(int32_t result, int32_t advHandle, int32_t opcode) override
53         {
54             std::shared_ptr<BleAdvertiser> advertiserSptr = advertiser_.lock();
55             CHECK_AND_RETURN_LOG(advertiserSptr, "BleAdvertiser is destructed");
56 
57             HILOGD("result: %{public}d, advHandle: %{public}d, opcode: %{public}d", result, advHandle, opcode);
58             std::shared_ptr<BleAdvertiseCallback> observer = nullptr;
59             if (opcode == bluetooth::BLE_ADV_START_FAILED_OP_CODE) {
60                 observer = advertiserSptr->pimpl->callbacks_.PopAdvertiserObserver(advHandle);
61             } else {
62                 observer = advertiserSptr->pimpl->callbacks_.GetAdvertiserObserver(advHandle);
63             }
64 
65             if (observer != nullptr) {
66                 observer->OnStartResultEvent(result, advHandle);
67             }
68         }
69 
70         void OnEnableResultEvent(int32_t result, int32_t advHandle) override
71         {
72             std::shared_ptr<BleAdvertiser> advertiserSptr = advertiser_.lock();
73             CHECK_AND_RETURN_LOG(advertiserSptr, "BleAdvertiser is destructed");
74 
75             HILOGI("result: %{public}d, advHandle: %{public}d", result, advHandle);
76             auto observer = advertiserSptr->pimpl->callbacks_.GetAdvertiserObserver(advHandle);
77             if (observer != nullptr) {
78                 observer->OnEnableResultEvent(result, advHandle);
79             }
80         }
81 
82         void OnDisableResultEvent(int32_t result, int32_t advHandle) override
83         {
84             std::shared_ptr<BleAdvertiser> advertiserSptr = advertiser_.lock();
85             CHECK_AND_RETURN_LOG(advertiserSptr, "BleAdvertiser is destructed");
86 
87             HILOGI("result: %{public}d, advHandle: %{public}d", result, advHandle);
88             auto observer = advertiserSptr->pimpl->callbacks_.GetAdvertiserObserver(advHandle);
89             if (observer != nullptr) {
90                 observer->OnDisableResultEvent(result, advHandle);
91             }
92         }
93 
94         void OnStopResultEvent(int32_t result, int32_t advHandle) override
95         {
96             std::shared_ptr<BleAdvertiser> advertiserSptr = advertiser_.lock();
97             CHECK_AND_RETURN_LOG(advertiserSptr, "BleAdvertiser is destructed");
98 
99             HILOGD("result: %{public}d, advHandle: %{public}d", result, advHandle);
100             auto observer = advertiserSptr->pimpl->callbacks_.PopAdvertiserObserver(advHandle);
101             if (observer != nullptr) {
102                 observer->OnStopResultEvent(result, advHandle);
103             }
104         }
105 
106         void OnAutoStopAdvEvent(int32_t advHandle) override
107         {
108             std::shared_ptr<BleAdvertiser> advertiserSptr = advertiser_.lock();
109             CHECK_AND_RETURN_LOG(advertiserSptr, "BleAdvertiser is destructed");
110 
111             HILOGI("advHandle: %{public}d", advHandle);
112             auto observer = advertiserSptr->pimpl->callbacks_.GetAdvertiserObserver(advHandle);
113             if (observer != nullptr) {
114                 advertiserSptr->pimpl->callbacks_.Deregister(observer);
115             }
116         }
117 
118         void OnSetAdvDataEvent(int32_t result, int32_t advHandle) override
119         {
120             std::shared_ptr<BleAdvertiser> advertiserSptr = advertiser_.lock();
121             CHECK_AND_RETURN_LOG(advertiserSptr, "BleAdvertiser is destructed");
122 
123             HILOGD("result: %{public}d, advHandle: %{public}d", result, advHandle);
124             auto observer = advertiserSptr->pimpl->callbacks_.GetAdvertiserObserver(advHandle);
125             if (observer) {
126                 observer->OnSetAdvDataEvent(result);
127             }
128         }
129 
130     private:
131         std::weak_ptr<BleAdvertiser> advertiser_;
132         BLUETOOTH_DISALLOW_COPY_AND_ASSIGN(BluetoothBleAdvertiserCallbackImp);
133     };
134     sptr<BluetoothBleAdvertiserCallbackImp> callbackImp_ = nullptr;
135 
136     BluetoothObserverMap<std::shared_ptr<BleAdvertiseCallback>> callbacks_;
137     class BleAdvertiserDeathRecipient;
138     sptr<BleAdvertiserDeathRecipient> deathRecipient_ = nullptr;
139     int32_t profileRegisterId = 0;
140 };
141 
142 class BleAdvertiser::impl::BleAdvertiserDeathRecipient final : public IRemoteObject::DeathRecipient {
143 public:
BleAdvertiserDeathRecipient(std::weak_ptr<BleAdvertiser> advertiser)144     explicit BleAdvertiserDeathRecipient(std::weak_ptr<BleAdvertiser> advertiser) : advertiser_(advertiser) {}
145     ~BleAdvertiserDeathRecipient() final = default;
146     BLUETOOTH_DISALLOW_COPY_AND_ASSIGN(BleAdvertiserDeathRecipient);
147 
148     void OnRemoteDied(const wptr<IRemoteObject> &remote) final
149     {
150         HILOGI("enter");
151 
152         std::shared_ptr<BleAdvertiser> advertiserSptr = advertiser_.lock();
153         CHECK_AND_RETURN_LOG(advertiserSptr, "BleAdvertiser is destructed");
154         advertiserSptr->pimpl->callbacks_.Clear();
155     }
156 
157 private:
158     std::weak_ptr<BleAdvertiser> advertiser_;
159 };
160 
impl()161 BleAdvertiser::impl::impl()
162 {}
163 
~impl()164 BleAdvertiser::impl::~impl()
165 {
166     HILOGD("start");
167     BluetoothProfileManager::GetInstance().DeregisterFunc(profileRegisterId);
168     callbacks_.Clear();
169     sptr<IBluetoothBleAdvertiser> proxy = GetRemoteProxy<IBluetoothBleAdvertiser>(BLE_ADVERTISER_SERVER);
170     CHECK_AND_RETURN_LOG(proxy != nullptr, "failed: no proxy");
171     proxy->DeregisterBleAdvertiserCallback(callbackImp_);
172     proxy->AsObject()->RemoveDeathRecipient(deathRecipient_);
173 }
174 
BleAdvertiser()175 BleAdvertiser::BleAdvertiser() : pimpl(nullptr)
176 {
177     if (pimpl == nullptr) {
178         pimpl = std::make_unique<impl>();
179         if (!pimpl) {
180             HILOGE("failed, no pimpl");
181         }
182     }
183 
184     HILOGI("successful");
185 }
186 
~BleAdvertiser()187 BleAdvertiser::~BleAdvertiser()
188 {}
189 
Init(std::weak_ptr<BleAdvertiser> advertiser)190 void BleAdvertiser::impl::Init(std::weak_ptr<BleAdvertiser> advertiser)
191 {
192     callbackImp_ = new BluetoothBleAdvertiserCallbackImp(advertiser);
193     profileRegisterId = BluetoothProfileManager::GetInstance().RegisterFunc(BLE_ADVERTISER_SERVER,
194         [this, advertiser](sptr<IRemoteObject> remote) {
195         sptr<IBluetoothBleAdvertiser> proxy = iface_cast<IBluetoothBleAdvertiser>(remote);
196         CHECK_AND_RETURN_LOG(proxy != nullptr, "failed: no proxy");
197         proxy->RegisterBleAdvertiserCallback(callbackImp_);
198         deathRecipient_ = new BleAdvertiserDeathRecipient(advertiser);
199         if (deathRecipient_ != nullptr) {
200             proxy->AsObject()->AddDeathRecipient(deathRecipient_);
201         }
202     });
203 }
204 
CreateInstance(void)205 std::shared_ptr<BleAdvertiser> BleAdvertiser::CreateInstance(void)
206 {
207     auto instance = std::make_shared<BleAdvertiser>(PassKey());
208     CHECK_AND_RETURN_LOG_RET(instance, nullptr, "Create BleAdvertiser failed");
209 
210     instance->pimpl->Init(instance);
211     return instance;
212 }
213 
ConvertBleAdvertiserData(const BleAdvertiserData &data, BluetoothBleAdvertiserData &outData)214 void BleAdvertiser::impl::ConvertBleAdvertiserData(const BleAdvertiserData &data, BluetoothBleAdvertiserData &outData)
215 {
216     std::map<uint16_t, std::string> manufacturerData = data.GetManufacturerData();
217     for (auto iter = manufacturerData.begin(); iter != manufacturerData.end(); iter++) {
218         outData.AddManufacturerData(iter->first, iter->second);
219     }
220     std::map<ParcelUuid, std::string> serviceData = data.GetServiceData();
221     for (auto it = serviceData.begin(); it != serviceData.end(); it++) {
222         outData.AddServiceData(Uuid::ConvertFromString(it->first.ToString()), it->second);
223     }
224     std::vector<ParcelUuid> serviceUuids = data.GetServiceUuids();
225     for (auto it = serviceUuids.begin(); it != serviceUuids.end(); it++) {
226         outData.AddServiceUuid(Uuid::ConvertFromString(it->ToString()));
227     }
228     outData.SetIncludeDeviceName(data.GetIncludeDeviceName());
229     outData.SetIncludeTxPower(data.GetIncludeTxPower());
230 }
231 
GetAdvertiserTotalBytes(const BluetoothBleAdvertiserData &data, bool isFlagsIncluded)232 uint32_t BleAdvertiser::impl::GetAdvertiserTotalBytes(const BluetoothBleAdvertiserData &data, bool isFlagsIncluded)
233 {
234     // If the flag field is contained, the protocol stack adds the flag field, which consists of three bytes.
235     uint32_t size = (isFlagsIncluded) ? BLE_ADV_FLAGS_FIELD_LENGTH : 0;
236     std::map<uint16_t, std::string> manufacturerData = data.GetManufacturerData();
237     for (auto iter = manufacturerData.begin(); iter != manufacturerData.end(); ++iter) {
238         size += BLE_ADV_PER_FIELD_OVERHEAD_LENGTH + BLE_ADV_MANUFACTURER_ID_LENGTH + iter->second.length();
239     }
240 
241     std::map<Uuid, std::string> serviceData = data.GetServiceData();
242     for (auto iter = serviceData.begin(); iter != serviceData.end(); ++iter) {
243         size += BLE_ADV_PER_FIELD_OVERHEAD_LENGTH + static_cast<uint32_t>(iter->first.GetUuidType())
244         + iter->second.length();
245     }
246     int num16BitUuids = 0;
247     int num32BitUuids = 0;
248     int num128BitUuids = 0;
249     std::vector<Uuid> serviceUuids = data.GetServiceUuids();
250     for (auto iter = serviceUuids.begin(); iter != serviceUuids.end(); ++iter) {
251         if (iter->GetUuidType() == Uuid::UUID16_BYTES_TYPE) {
252             ++num16BitUuids;
253         } else if (iter->GetUuidType() == Uuid::UUID32_BYTES_TYPE) {
254             ++num32BitUuids;
255         } else {
256             ++num128BitUuids;
257         }
258     }
259     if (num16BitUuids != 0) {
260         size += BLE_ADV_PER_FIELD_OVERHEAD_LENGTH + static_cast<uint32_t>(num16BitUuids * Uuid::UUID16_BYTES_TYPE);
261     }
262     if (num32BitUuids != 0) {
263         size += BLE_ADV_PER_FIELD_OVERHEAD_LENGTH + static_cast<uint32_t>(num32BitUuids * Uuid::UUID32_BYTES_TYPE);
264     }
265     if (num128BitUuids != 0) {
266         size += BLE_ADV_PER_FIELD_OVERHEAD_LENGTH + static_cast<uint32_t>(num128BitUuids * Uuid::UUID128_BYTES_TYPE);
267     }
268     if (data.GetIncludeDeviceName()) {
269         uint32_t deviceNameLen = BluetoothHost::GetDefaultHost().GetLocalName().length();
270         deviceNameLen = (deviceNameLen > DEVICE_NAME_MAX_LEN) ?  DEVICE_NAME_MAX_LEN : deviceNameLen;
271         size += BLE_ADV_PER_FIELD_OVERHEAD_LENGTH + deviceNameLen;
272     }
273     if (data.GetIncludeTxPower()) {
274         uint32_t txPowerLen = 3;
275         size += BLE_ADV_PER_FIELD_OVERHEAD_LENGTH + txPowerLen;
276     }
277     return size;
278 }
279 
CheckAdvertiserSettings(const BleAdvertiserSettings &settings)280 int32_t BleAdvertiser::impl::CheckAdvertiserSettings(const BleAdvertiserSettings &settings)
281 {
282     int8_t txPower = settings.GetTxPower();
283     if (txPower < BLE_ADV_TX_POWER_MIN_VALUE || txPower > BLE_ADV_TX_POWER_MAX_VALUE) {
284         HILOGE("Illegal txPower argument %{public}d", txPower);
285         return BT_ERR_INVALID_PARAM;
286     }
287 
288     return BT_NO_ERROR;
289 }
290 
CheckAdvertiserData(const BluetoothBleAdvertiserSettings &setting, const BluetoothBleAdvertiserData &advData, const BluetoothBleAdvertiserData &scanResponse)291 int32_t BleAdvertiser::impl::CheckAdvertiserData(const BluetoothBleAdvertiserSettings &setting,
292     const BluetoothBleAdvertiserData &advData, const BluetoothBleAdvertiserData &scanResponse)
293 {
294     uint32_t maxSize = BLE_ADV_MAX_LEGACY_ADVERTISING_DATA_BYTES;
295     if (!setting.IsLegacyMode()) {
296         maxSize = static_cast<uint32_t>(BluetoothHost::GetDefaultHost().GetBleMaxAdvertisingDataLength());
297     }
298     // If is Connect, flag field is contained in AdvertiserData.
299     uint32_t size = GetAdvertiserTotalBytes(advData, setting.IsConnectable());
300     if (size > maxSize) {
301         HILOGE("bleAdvertiserData size = %{public}d, maxSize = %{public}d", size, maxSize);
302         return BT_ERR_INTERNAL_ERROR;
303     }
304     size = GetAdvertiserTotalBytes(scanResponse, false);
305     if (size > maxSize) {
306         HILOGE("bleScanResponse size = %{public}d, maxSize = %{public}d,", size, maxSize);
307         return BT_ERR_INTERNAL_ERROR;
308     }
309     return BT_NO_ERROR;
310 }
311 
StartAdvertising(const BleAdvertiserSettings &settings, const BleAdvertiserData &advData, const BleAdvertiserData &scanResponse, uint16_t duration, std::shared_ptr<BleAdvertiseCallback> callback)312 int BleAdvertiser::StartAdvertising(const BleAdvertiserSettings &settings, const BleAdvertiserData &advData,
313     const BleAdvertiserData &scanResponse, uint16_t duration, std::shared_ptr<BleAdvertiseCallback> callback)
314 {
315     if (!IS_BLE_ENABLED()) {
316         HILOGE("bluetooth is off.");
317         return BT_ERR_INVALID_STATE;
318     }
319     sptr<IBluetoothBleAdvertiser> proxy = GetRemoteProxy<IBluetoothBleAdvertiser>(BLE_ADVERTISER_SERVER);
320     CHECK_AND_RETURN_LOG_RET(proxy != nullptr, BT_ERR_INTERNAL_ERROR, "failed: no proxy");
321     CHECK_AND_RETURN_LOG_RET(callback != nullptr, BT_ERR_INTERNAL_ERROR, "callback is nullptr");
322 
323     int ret = pimpl->CheckAdvertiserSettings(settings);
324     if (ret != BT_NO_ERROR) {
325         return ret;
326     }
327     BluetoothBleAdvertiserSettings setting;
328     setting.SetConnectable(settings.IsConnectable());
329     setting.SetInterval(settings.GetInterval());
330     setting.SetLegacyMode(settings.IsLegacyMode());
331     setting.SetTxPower(settings.GetTxPower());
332     setting.SetOwnAddr(settings.GetOwnAddr());
333     setting.SetOwnAddrType(settings.GetOwnAddrType());
334 
335     BluetoothBleAdvertiserData bleAdvertiserData;
336     BluetoothBleAdvertiserData bleScanResponse;
337     bleAdvertiserData.SetAdvFlag(advData.GetAdvFlag());
338     pimpl->ConvertBleAdvertiserData(advData, bleAdvertiserData);
339     pimpl->ConvertBleAdvertiserData(scanResponse, bleScanResponse);
340 
341     ret = pimpl->CheckAdvertiserData(setting, bleAdvertiserData, bleScanResponse);
342     if (ret != BT_NO_ERROR) {
343         return ret;
344     }
345 
346     HILOGD("duration=%{public}d", duration);
347     int32_t advHandle = BLE_INVALID_ADVERTISING_HANDLE;
348     if (pimpl->callbacks_.IsExistAdvertiserCallback(callback, advHandle)) {
349         ret = proxy->StartAdvertising(setting, bleAdvertiserData, bleScanResponse, advHandle, duration, false);
350     } else {
351         ret = proxy->GetAdvertiserHandle(advHandle);
352         if (ret != BT_NO_ERROR || advHandle == BLE_INVALID_ADVERTISING_HANDLE) {
353             HILOGE("Invalid advertising handle");
354             callback->OnStartResultEvent(BT_ERR_INTERNAL_ERROR, static_cast<int>(BLE_INVALID_ADVERTISING_HANDLE));
355             return ret;
356         }
357         callback->OnGetAdvHandleEvent(0, advHandle);
358         pimpl->callbacks_.Register(advHandle, callback);
359         ret = proxy->StartAdvertising(setting, bleAdvertiserData, bleScanResponse, advHandle, duration, false);
360     }
361     return ret;
362 }
363 
StartAdvertising(const BleAdvertiserSettings &settings, const std::vector<uint8_t> &advData, const std::vector<uint8_t> &scanResponse, uint16_t duration, std::shared_ptr<BleAdvertiseCallback> callback)364 int BleAdvertiser::StartAdvertising(const BleAdvertiserSettings &settings, const std::vector<uint8_t> &advData,
365     const std::vector<uint8_t> &scanResponse, uint16_t duration, std::shared_ptr<BleAdvertiseCallback> callback)
366 {
367     if (!IS_BLE_ENABLED()) {
368         HILOGE("bluetooth is off.");
369         return BT_ERR_INVALID_STATE;
370     }
371 
372     sptr<IBluetoothBleAdvertiser> proxy = GetRemoteProxy<IBluetoothBleAdvertiser>(BLE_ADVERTISER_SERVER);
373     CHECK_AND_RETURN_LOG_RET(proxy != nullptr, BT_ERR_INTERNAL_ERROR, "failed: no proxy");
374     CHECK_AND_RETURN_LOG_RET(callback != nullptr, BT_ERR_INTERNAL_ERROR, "callback is nullptr");
375 
376     int ret = pimpl->CheckAdvertiserSettings(settings);
377     if (ret != BT_NO_ERROR) {
378         return ret;
379     }
380     BluetoothBleAdvertiserSettings setting;
381     setting.SetConnectable(settings.IsConnectable());
382     setting.SetInterval(settings.GetInterval());
383     setting.SetLegacyMode(settings.IsLegacyMode());
384     setting.SetTxPower(settings.GetTxPower());
385     setting.SetOwnAddr(settings.GetOwnAddr());
386     setting.SetOwnAddrType(settings.GetOwnAddrType());
387 
388     BluetoothBleAdvertiserData bleAdvertiserData;
389     bleAdvertiserData.SetPayload(std::string(advData.begin(), advData.end()));
390     bleAdvertiserData.SetAdvFlag(0);
391     BluetoothBleAdvertiserData bleScanResponse;
392     bleScanResponse.SetPayload(std::string(scanResponse.begin(), scanResponse.end()));
393 
394     HILOGI("duration=%{public}d", duration);
395     int32_t advHandle = BLE_INVALID_ADVERTISING_HANDLE;
396     if (pimpl->callbacks_.IsExistAdvertiserCallback(callback, advHandle)) {
397         ret = proxy->StartAdvertising(setting, bleAdvertiserData, bleScanResponse, advHandle, duration, true);
398     } else {
399         ret = proxy->GetAdvertiserHandle(advHandle);
400         if (ret != BT_NO_ERROR || advHandle == BLE_INVALID_ADVERTISING_HANDLE) {
401             HILOGE("Invalid advertising handle");
402             callback->OnStartResultEvent(BT_ERR_INTERNAL_ERROR, BLE_INVALID_ADVERTISING_HANDLE);
403             return ret;
404         }
405         pimpl->callbacks_.Register(advHandle, callback);
406         ret = proxy->StartAdvertising(setting, bleAdvertiserData, bleScanResponse, advHandle, duration, true);
407     }
408     return ret;
409 }
410 
SetAdvertisingData(const std::vector<uint8_t> &advData, const std::vector<uint8_t> &scanResponse, std::shared_ptr<BleAdvertiseCallback> callback)411 void BleAdvertiser::SetAdvertisingData(const std::vector<uint8_t> &advData, const std::vector<uint8_t> &scanResponse,
412     std::shared_ptr<BleAdvertiseCallback> callback)
413 {
414     if (!IS_BLE_ENABLED()) {
415         HILOGE("bluetooth is off.");
416         return;
417     }
418     sptr<IBluetoothBleAdvertiser> proxy = GetRemoteProxy<IBluetoothBleAdvertiser>(BLE_ADVERTISER_SERVER);
419     CHECK_AND_RETURN_LOG(proxy != nullptr, "failed: no proxy");
420 
421     CHECK_AND_RETURN_LOG(callback != nullptr, "callback is nullptr");
422 
423     int advHandle = BLE_INVALID_ADVERTISING_HANDLE;
424     if (!pimpl->callbacks_.IsExistAdvertiserCallback(callback, advHandle)) {
425         HILOGE("Advertising is not started");
426         return;
427     }
428 
429     BluetoothBleAdvertiserData bleAdvertiserData;
430     bleAdvertiserData.SetPayload(std::string(advData.begin(), advData.end()));
431     BluetoothBleAdvertiserData bleScanResponse;
432     bleScanResponse.SetPayload(std::string(scanResponse.begin(), scanResponse.end()));
433     proxy->SetAdvertisingData(bleAdvertiserData, bleScanResponse, advHandle);
434 }
435 
EnableAdvertising(uint8_t advHandle, uint16_t duration, std::shared_ptr<BleAdvertiseCallback> callback)436 int BleAdvertiser::EnableAdvertising(uint8_t advHandle, uint16_t duration,
437     std::shared_ptr<BleAdvertiseCallback> callback)
438 {
439     HILOGI("enter");
440     if (!IS_BLE_ENABLED()) {
441         HILOGE("bluetooth is off.");
442         return BT_ERR_INVALID_STATE;
443     }
444     sptr<IBluetoothBleAdvertiser> proxy = GetRemoteProxy<IBluetoothBleAdvertiser>(BLE_ADVERTISER_SERVER);
445     CHECK_AND_RETURN_LOG_RET(proxy != nullptr, BT_ERR_INTERNAL_ERROR, "failed: no proxy");
446 
447     CHECK_AND_RETURN_LOG_RET(callback != nullptr, BT_ERR_INTERNAL_ERROR, "callback is nullptr");
448     uint8_t tmpAdvHandle = pimpl->callbacks_.GetAdvertiserHandle(callback);
449     if (tmpAdvHandle == BLE_INVALID_ADVERTISING_HANDLE) {
450         HILOGE("Invalid advertising callback");
451         return BT_ERR_INTERNAL_ERROR;
452     }
453 
454     std::shared_ptr<BleAdvertiseCallback> observer = pimpl->callbacks_.GetAdvertiserObserver(advHandle);
455     if (observer == nullptr) {
456         HILOGE("Invalid advertising handle");
457         return BT_ERR_INTERNAL_ERROR;
458     }
459 
460     int ret = proxy->EnableAdvertising(advHandle, duration);
461     return ret;
462 }
463 
DisableAdvertising(uint8_t advHandle, std::shared_ptr<BleAdvertiseCallback> callback)464 int BleAdvertiser::DisableAdvertising(uint8_t advHandle, std::shared_ptr<BleAdvertiseCallback> callback)
465 {
466     HILOGI("enter");
467     if (!IS_BLE_ENABLED()) {
468         HILOGE("bluetooth is off.");
469         return BT_ERR_INVALID_STATE;
470     }
471 
472     sptr<IBluetoothBleAdvertiser> proxy = GetRemoteProxy<IBluetoothBleAdvertiser>(BLE_ADVERTISER_SERVER);
473     CHECK_AND_RETURN_LOG_RET(proxy != nullptr, BT_ERR_INTERNAL_ERROR, "failed: no proxy");
474     CHECK_AND_RETURN_LOG_RET(callback != nullptr, BT_ERR_INTERNAL_ERROR, "callback is nullptr");
475     uint8_t tmpAdvHandle = pimpl->callbacks_.GetAdvertiserHandle(callback);
476     if (tmpAdvHandle == BLE_INVALID_ADVERTISING_HANDLE) {
477         HILOGE("Invalid advertising callback");
478         return BT_ERR_INTERNAL_ERROR;
479     }
480 
481     std::shared_ptr<BleAdvertiseCallback> observer = pimpl->callbacks_.GetAdvertiserObserver(advHandle);
482     if (observer == nullptr) {
483         HILOGE("Invalid advertising handle");
484         return BT_ERR_INTERNAL_ERROR;
485     }
486 
487     int ret = proxy->DisableAdvertising(advHandle);
488     return ret;
489 }
490 
StopAdvertising(std::shared_ptr<BleAdvertiseCallback> callback)491 int BleAdvertiser::StopAdvertising(std::shared_ptr<BleAdvertiseCallback> callback)
492 {
493     if (!IS_BLE_ENABLED()) {
494         HILOGE("bluetooth is off.");
495         return BT_ERR_INVALID_STATE;
496     }
497 
498     sptr<IBluetoothBleAdvertiser> proxy = GetRemoteProxy<IBluetoothBleAdvertiser>(BLE_ADVERTISER_SERVER);
499     CHECK_AND_RETURN_LOG_RET(proxy != nullptr, BT_ERR_INTERNAL_ERROR, "failed: no proxy");
500     CHECK_AND_RETURN_LOG_RET(callback != nullptr, BT_ERR_INTERNAL_ERROR, "callback is nullptr");
501 
502     HILOGD("enter");
503     uint8_t advHandle = pimpl->callbacks_.GetAdvertiserHandle(callback);
504     if (advHandle == BLE_INVALID_ADVERTISING_HANDLE) {
505         HILOGE("Invalid advertising handle");
506         return BT_ERR_INTERNAL_ERROR;
507     }
508 
509     int ret = proxy->StopAdvertising(advHandle);
510     return ret;
511 }
512 
Close(std::shared_ptr<BleAdvertiseCallback> callback)513 void BleAdvertiser::Close(std::shared_ptr<BleAdvertiseCallback> callback)
514 {
515     if (!IS_BLE_ENABLED()) {
516         HILOGE("BLE is not enabled");
517         return;
518     }
519 
520     sptr<IBluetoothBleAdvertiser> proxy = GetRemoteProxy<IBluetoothBleAdvertiser>(BLE_ADVERTISER_SERVER);
521     CHECK_AND_RETURN_LOG(proxy != nullptr, "proxy is nullptr");
522     CHECK_AND_RETURN_LOG(callback != nullptr, "callback is nullptr");
523 
524     HILOGI("enter");
525     if (proxy != nullptr) {
526         uint8_t advHandle = pimpl->callbacks_.GetAdvertiserHandle(callback);
527         if (advHandle != BLE_INVALID_ADVERTISING_HANDLE) {
528             proxy->Close(advHandle);
529         }
530 
531         std::shared_ptr<BleAdvertiseCallback> observer = pimpl->callbacks_.GetAdvertiserObserver(advHandle);
532         if (observer != nullptr) {
533             pimpl->callbacks_.Deregister(observer);
534         }
535     }
536 }
537 
GetAdvHandle(std::shared_ptr<BleAdvertiseCallback> callback)538 uint8_t BleAdvertiser::GetAdvHandle(std::shared_ptr<BleAdvertiseCallback> callback)
539 {
540     if (!BluetoothHost::GetDefaultHost().IsBleEnabled()) {
541         HILOGE("BLE is not enabled");
542         return BLE_INVALID_ADVERTISING_HANDLE;
543     }
544     CHECK_AND_RETURN_LOG_RET(callback != nullptr, BLE_INVALID_ADVERTISING_HANDLE, "callback is nullptr");
545     return pimpl->callbacks_.GetAdvertiserHandle(callback);
546 }
547 
BleAdvertiserData()548 BleAdvertiserData::BleAdvertiserData()
549 {}
550 
~BleAdvertiserData()551 BleAdvertiserData::~BleAdvertiserData()
552 {}
553 
AddServiceData(const ParcelUuid &uuid, const std::string &serviceData)554 void BleAdvertiserData::AddServiceData(const ParcelUuid &uuid, const std::string &serviceData)
555 {
556     if (serviceData.empty()) {
557         HILOGE("serviceData is empty");
558         return;
559     }
560 
561     serviceData_.insert(std::make_pair(uuid, serviceData));
562 }
563 
AddManufacturerData(uint16_t manufacturerId, const std::string &data)564 void BleAdvertiserData::AddManufacturerData(uint16_t manufacturerId, const std::string &data)
565 {
566     if (data.empty()) {
567         HILOGE("serviceData is empty");
568         return;
569     }
570 
571     manufacturerSpecificData_.insert(std::make_pair(manufacturerId, data));
572 }
573 
GetManufacturerData() const574 std::map<uint16_t, std::string> BleAdvertiserData::GetManufacturerData() const
575 {
576     return manufacturerSpecificData_;
577 }
578 
AddServiceUuid(const ParcelUuid &serviceUuid)579 void BleAdvertiserData::AddServiceUuid(const ParcelUuid &serviceUuid)
580 {
581     serviceUuids_.push_back(serviceUuid);
582 }
583 
GetServiceUuids() const584 std::vector<ParcelUuid> BleAdvertiserData::GetServiceUuids() const
585 {
586     return serviceUuids_;
587 }
588 
SetAdvFlag(uint8_t flag)589 void BleAdvertiserData::SetAdvFlag(uint8_t flag)
590 {
591     advFlag_ = flag;
592 }
593 
GetAdvFlag() const594 uint8_t BleAdvertiserData::GetAdvFlag() const
595 {
596     return advFlag_;
597 }
598 
GetServiceData() const599 std::map<ParcelUuid, std::string> BleAdvertiserData::GetServiceData() const
600 {
601     return serviceData_;
602 }
603 
GetIncludeDeviceName() const604 bool BleAdvertiserData::GetIncludeDeviceName() const
605 {
606     return includeDeviceName_;
607 }
608 
SetIncludeDeviceName(bool flag)609 void BleAdvertiserData::SetIncludeDeviceName(bool flag)
610 {
611     includeDeviceName_ = flag;
612 }
613 
GetIncludeTxPower() const614 bool BleAdvertiserData::GetIncludeTxPower() const
615 {
616     return includeTxPower_;
617 }
618 
SetIncludeTxPower(bool flag)619 void BleAdvertiserData::SetIncludeTxPower(bool flag)
620 {
621     includeTxPower_ = flag;
622 }
623 
BleAdvertiserSettings()624 BleAdvertiserSettings::BleAdvertiserSettings()
625 {}
626 
~BleAdvertiserSettings()627 BleAdvertiserSettings::~BleAdvertiserSettings()
628 {}
629 
SetConnectable(bool connectable)630 void BleAdvertiserSettings::SetConnectable(bool connectable)
631 {
632     connectable_ = connectable;
633 }
634 
IsConnectable() const635 bool BleAdvertiserSettings::IsConnectable() const
636 {
637     return connectable_;
638 }
639 
SetLegacyMode(bool legacyMode)640 void BleAdvertiserSettings::SetLegacyMode(bool legacyMode)
641 {
642     legacyMode_ = legacyMode;
643 }
644 
IsLegacyMode() const645 bool BleAdvertiserSettings::IsLegacyMode() const
646 {
647     return legacyMode_;
648 }
649 
SetInterval(uint16_t interval)650 void BleAdvertiserSettings::SetInterval(uint16_t interval)
651 {
652     interval_ = interval;
653 }
654 
GetInterval() const655 uint16_t BleAdvertiserSettings::GetInterval() const
656 {
657     return interval_;
658 }
659 
SetTxPower(int8_t txPower)660 void BleAdvertiserSettings::SetTxPower(int8_t txPower)
661 {
662     txPower_ = txPower;
663 }
664 
GetTxPower() const665 int8_t BleAdvertiserSettings::GetTxPower() const
666 {
667     return txPower_;
668 }
669 
GetPrimaryPhy() const670 int BleAdvertiserSettings::GetPrimaryPhy() const
671 {
672     return primaryPhy_;
673 }
674 
SetPrimaryPhy(int primaryPhy)675 void BleAdvertiserSettings::SetPrimaryPhy(int primaryPhy)
676 {
677     primaryPhy_ = primaryPhy;
678 }
679 
GetSecondaryPhy() const680 int BleAdvertiserSettings::GetSecondaryPhy() const
681 {
682     return secondaryPhy_;
683 }
684 
SetSecondaryPhy(int secondaryPhy)685 void BleAdvertiserSettings::SetSecondaryPhy(int secondaryPhy)
686 {
687     secondaryPhy_ = secondaryPhy;
688 }
689 
GetOwnAddr() const690 std::array<uint8_t, OHOS_BD_ADDR_LEN> BleAdvertiserSettings::GetOwnAddr() const
691 {
692     return ownAddr_;
693 }
694 
SetOwnAddr(const std::array<uint8_t, OHOS_BD_ADDR_LEN>& addr)695 void BleAdvertiserSettings::SetOwnAddr(const std::array<uint8_t, OHOS_BD_ADDR_LEN>& addr)
696 {
697     ownAddr_ = addr;
698 }
699 
GetOwnAddrType() const700 int8_t BleAdvertiserSettings::GetOwnAddrType() const
701 {
702     return ownAddrType_;
703 }
704 
SetOwnAddrType(int8_t addrType)705 void BleAdvertiserSettings::SetOwnAddrType(int8_t addrType)
706 {
707     ownAddrType_ = addrType;
708 }
709 }  // namespace Bluetooth
710 }  // namespace OHOS
711