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
31namespace OHOS {
32namespace Bluetooth {
33using namespace OHOS::bluetooth;
34struct 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:
46        explicit BluetoothBleAdvertiserCallbackImp(std::weak_ptr<BleAdvertiser> advertiser)
47            : advertiser_(advertiser){};
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
142class BleAdvertiser::impl::BleAdvertiserDeathRecipient final : public IRemoteObject::DeathRecipient {
143public:
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
157private:
158    std::weak_ptr<BleAdvertiser> advertiser_;
159};
160
161BleAdvertiser::impl::impl()
162{}
163
164BleAdvertiser::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
175BleAdvertiser::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
187BleAdvertiser::~BleAdvertiser()
188{}
189
190void 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
205std::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
214void 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
232uint32_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
280int32_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
291int32_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
312int 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
364int 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
411void 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
436int 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
464int 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
491int 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
513void 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
538uint8_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
548BleAdvertiserData::BleAdvertiserData()
549{}
550
551BleAdvertiserData::~BleAdvertiserData()
552{}
553
554void 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
564void 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
574std::map<uint16_t, std::string> BleAdvertiserData::GetManufacturerData() const
575{
576    return manufacturerSpecificData_;
577}
578
579void BleAdvertiserData::AddServiceUuid(const ParcelUuid &serviceUuid)
580{
581    serviceUuids_.push_back(serviceUuid);
582}
583
584std::vector<ParcelUuid> BleAdvertiserData::GetServiceUuids() const
585{
586    return serviceUuids_;
587}
588
589void BleAdvertiserData::SetAdvFlag(uint8_t flag)
590{
591    advFlag_ = flag;
592}
593
594uint8_t BleAdvertiserData::GetAdvFlag() const
595{
596    return advFlag_;
597}
598
599std::map<ParcelUuid, std::string> BleAdvertiserData::GetServiceData() const
600{
601    return serviceData_;
602}
603
604bool BleAdvertiserData::GetIncludeDeviceName() const
605{
606    return includeDeviceName_;
607}
608
609void BleAdvertiserData::SetIncludeDeviceName(bool flag)
610{
611    includeDeviceName_ = flag;
612}
613
614bool BleAdvertiserData::GetIncludeTxPower() const
615{
616    return includeTxPower_;
617}
618
619void BleAdvertiserData::SetIncludeTxPower(bool flag)
620{
621    includeTxPower_ = flag;
622}
623
624BleAdvertiserSettings::BleAdvertiserSettings()
625{}
626
627BleAdvertiserSettings::~BleAdvertiserSettings()
628{}
629
630void BleAdvertiserSettings::SetConnectable(bool connectable)
631{
632    connectable_ = connectable;
633}
634
635bool BleAdvertiserSettings::IsConnectable() const
636{
637    return connectable_;
638}
639
640void BleAdvertiserSettings::SetLegacyMode(bool legacyMode)
641{
642    legacyMode_ = legacyMode;
643}
644
645bool BleAdvertiserSettings::IsLegacyMode() const
646{
647    return legacyMode_;
648}
649
650void BleAdvertiserSettings::SetInterval(uint16_t interval)
651{
652    interval_ = interval;
653}
654
655uint16_t BleAdvertiserSettings::GetInterval() const
656{
657    return interval_;
658}
659
660void BleAdvertiserSettings::SetTxPower(int8_t txPower)
661{
662    txPower_ = txPower;
663}
664
665int8_t BleAdvertiserSettings::GetTxPower() const
666{
667    return txPower_;
668}
669
670int BleAdvertiserSettings::GetPrimaryPhy() const
671{
672    return primaryPhy_;
673}
674
675void BleAdvertiserSettings::SetPrimaryPhy(int primaryPhy)
676{
677    primaryPhy_ = primaryPhy;
678}
679
680int BleAdvertiserSettings::GetSecondaryPhy() const
681{
682    return secondaryPhy_;
683}
684
685void BleAdvertiserSettings::SetSecondaryPhy(int secondaryPhy)
686{
687    secondaryPhy_ = secondaryPhy;
688}
689
690std::array<uint8_t, OHOS_BD_ADDR_LEN> BleAdvertiserSettings::GetOwnAddr() const
691{
692    return ownAddr_;
693}
694
695void BleAdvertiserSettings::SetOwnAddr(const std::array<uint8_t, OHOS_BD_ADDR_LEN>& addr)
696{
697    ownAddr_ = addr;
698}
699
700int8_t BleAdvertiserSettings::GetOwnAddrType() const
701{
702    return ownAddrType_;
703}
704
705void BleAdvertiserSettings::SetOwnAddrType(int8_t addrType)
706{
707    ownAddrType_ = addrType;
708}
709}  // namespace Bluetooth
710}  // namespace OHOS
711