From da080587271c26456747d69d660e4e5a66cb6017 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 06:58:40 +0000
Subject: [PATCH 01/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 37 +++++++++++++++++--
 1 file changed, 34 insertions(+), 3 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 3bd1d133aa..71577582a3 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -13,8 +13,39 @@
  * limitations under the License.
  */
 
-#include "softbus_ble_gatt.h"
+/**
+ * @file softbus_ble_gatt.h
+ * @brief ble stack adapter
+ *
+ * @since 1.0
+ * @version 1.0
+ */
+
+#ifndef SOFTBUS_BLE_GATT_H
+#define SOFTBUS_BLE_GATT_H
+
+#include "softbus_broadcast_adapter_interface.h"
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+void SoftbusBleAdapterInit(void);
 
-void softbus_ble_adapter_init(void)
-{
+bool SoftBusBcIsLpDeviceAvailable(void);
+
+int32_t SoftBusBcEnableSyncDataToLpDevice(void);
+
+int32_t SoftBusBcDisableSyncDataToLpDevice(void);
+
+int32_t SoftBusBcSetScanReportChannelToLpDevice(int32_t scannerId, bool enable);
+
+int32_t SoftBusBcSetLpDeviceParam(int duration, int maxExtAdvEvents, int window,
+    int interval, int advHandle);
+
+#ifdef __cplusplus
 }
+#endif
+
+#endif /* SOFTBUS_BLE_GATT_H */
\ No newline at end of file
-- 
Gitee


From 5feee15dee14515306832fc845d9aa1cb0c60edd Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 06:59:11 +0000
Subject: [PATCH 02/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 686 +++++++++++++++++-
 1 file changed, 662 insertions(+), 24 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 71577582a3..539ec52b09 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -13,39 +13,677 @@
  * limitations under the License.
  */
 
-/**
- * @file softbus_ble_gatt.h
- * @brief ble stack adapter
- *
- * @since 1.0
- * @version 1.0
- */
+#include "softbus_ble_gatt.h"
+#include "c_header/ohos_bt_gatt.h"
+#include "softbus_error_code.h"
+#include "adapter_bt_utils.h"
+#include "softbus_log_old.h"
+#include "softbus_utils.h"
+#include "softbus_adapter_thread.h"
+#include "softbus_adapter_mem.h"
+#include <securec.h>
+#include <stdatomic.h>
 
-#ifndef SOFTBUS_BLE_GATT_H
-#define SOFTBUS_BLE_GATT_H
+static atomic_bool g_init = false;
+static SoftBusMutex g_advLock = {0};
+static SoftBusMutex g_scannerLock = {0};
 
-#include "softbus_broadcast_adapter_interface.h"
-#include <stdbool.h>
+typedef struct {
+    int advId;
+    bool isUsed;
+    bool isAdvertising;
+    SoftbusBroadcastCallback *advCallback;
+} AdvChannel;
 
-#ifdef __cplusplus
-extern "C"{
-#endif
+typedef struct {
+    int32_t scannerId;
+    bool isUsed;
+    bool isScanning;
+    SoftbusScanCallback *scanCallback;
+} ScanChannel;
 
-void SoftbusBleAdapterInit(void);
+static AdvChannel g_advChannel[ADV_MAX_NUM];
+static ScanChannel g_scanChannel[SCAN_MAX_NUM];
+
+static int32_t Init(void)
+{
+    if (g_init) {
+        return SOFTBUS_OK;
+    }
+    if (SoftBusMutexInit(&g_advLock, NULL) != SOFTBUS_OK) {
+        CLOGE("g_advLock init failed");
+        return SOFTBUS_ERR;
+    }
+    if (SoftBusMutexInit(&g_scannerLock, NULL) != SOFTBUS_OK) {
+        SoftBusMutexDestroy(&g_advLock);
+        CLOGE("g_scannerLock init failed");
+        return SOFTBUS_ERR;
+    }
+    g_init = true;
+    return SOFTBUS_OK;
+}
 
-bool SoftBusBcIsLpDeviceAvailable(void);
+static int32_t DeInit(void)
+{
+    if (!g_init) {
+        return SOFTBUS_OK;
+    }
+    g_init = false;
+    SoftBusMutexDestroy(&g_advLock);
+    SoftBusMutexDestroy(&g_scannerLock);
+    return SOFTBUS_OK;
+}
 
-int32_t SoftBusBcEnableSyncDataToLpDevice(void);
+static void WrapperAdvEnableCallback(int advId, int status)
+{
+    int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
+    for (uint32_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
+        if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+            CLOGW("lock adv failed");
+        }
+        AdvChannel *advChannel = &g_advChannel[channelId];
+        if (advChannel->advId != advId || !advChannel->isUsed) {
+            SoftBusMutexUnlock(&g_advLock);
+            continue;
+        }
+        CLOGI("start adv callback, adv: %d, bt-advId: %d, status: %d", channelId, advId, st);
+        advChannel->isAdvertising = (st == SOFTBUS_BT_STATUS_SUCCESS);
+        if (advChannel->advCallback != NULL && advChannel->advCallback->OnStartBroadcastingCallback != NULL) {
+            advChannel->advCallback->OnStartBroadcastingCallback(channelId, st);
+        }
+        SoftBusMutexUnlock(&g_advLock);
+        break;
+    }
+}
 
-int32_t SoftBusBcDisableSyncDataToLpDevice(void);
+static void WrapperAdvDisableCallback(int advId, int status)
+{
+    int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
+    for (uint32_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
+        if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+            CLOGW("lock adv failed");
+        }
+        AdvChannel *advChannel = &g_advChannel[channelId];
+        if (advChannel->advId != advId || !advChannel->isUsed) {
+            SoftBusMutexUnlock(&g_advLock);
+            continue;
+        }
+        CLOGI("stop adv callback, adv: %d, bt-advId: %d, status: %d", channelId, advId, st);
+        advChannel->isAdvertising = (st == SOFTBUS_BT_STATUS_SUCCESS);
+        if (advChannel->advCallback != NULL && advChannel->advCallback->OnStopBroadcastingCallback != NULL) {
+            advChannel->advCallback->OnStopBroadcastingCallback(channelId, st);
+        }
+        SoftBusMutexUnlock(&g_advLock);
+        break;
+    }
+}
 
-int32_t SoftBusBcSetScanReportChannelToLpDevice(int32_t scannerId, bool enable);
+static BtGattCallbacks g_softbusGattCb = {
+    .advEnableCb = WrapperAdvEnableCallback,
+    .advDisableCb = WrapperAdvDisableCallback
+};
 
-int32_t SoftBusBcSetLpDeviceParam(int duration, int maxExtAdvEvents, int window,
-    int interval, int advHandle);
+static int32_t RegisterBroadcaster(int32_t *advId, const SoftbusBroadcastCallback *cb)
+{
+    if (advId == NULL || cb == NULL) {
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+        return SOFTBUS_LOCK_ERR;
+    }
+    for (int32_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
+        if (g_advChannel[channelId].isUsed) {
+            continue;
+        }
+        if (BleGattRegisterCallbacks(&g_softbusGattCb) != OHOS_BT_STATUS_SUCCESS) {
+            CLOGE("register adv cb failed: %d", channelId);
+            SoftBusMutexUnlock(&g_advLock);
+            return SOFTBUS_ERR;
+        }
+        g_advChannel[channelId].advId = -1;
+        g_advChannel[channelId].isUsed = true;
+        g_advChannel[channelId].isAdvertising = false;
+        g_advChannel[channelId].advCallback = (SoftbusBroadcastCallback *)cb;
+        *advId = channelId;
+        SoftBusMutexUnlock(&g_advLock);
+        return SOFTBUS_OK;
+    }
+    CLOGE("no available adv channel");
+    SoftBusMutexUnlock(&g_advLock);
+    return SOFTBUS_ERR;
+}
+
+static int32_t UnRegisterBroadcaster(int32_t advId)
+{
+    if (advId < 0 || advId >= ADV_MAX_NUM) {
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+        return SOFTBUS_LOCK_ERR;
+    }
+    if (!g_advChannel[advId].isUsed) {
+        SoftBusMutexUnlock(&g_advLock);
+        return SOFTBUS_OK;
+    }
+    g_advChannel[advId].advId = -1;
+    g_advChannel[advId].isUsed = false;
+    g_advChannel[advId].isAdvertising = false;
+    g_advChannel[advId].advCallback = NULL;
+    SoftBusMutexUnlock(&g_advLock);
+    return SOFTBUS_OK;
+}
+
+static uint8_t ConvertScanEventType(unsigned char eventType)
+{
+    switch (eventType) {
+        case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE:
+            return SOFTBUS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE;
+        case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED:
+            return SOFTBUS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
+        case OHOS_BLE_EVT_CONNECTABLE:
+            return SOFTBUS_BLE_EVT_CONNECTABLE;
+        case OHOS_BLE_EVT_CONNECTABLE_DIRECTED:
+            return SOFTBUS_BLE_EVT_CONNECTABLE_DIRECTED;
+        case OHOS_BLE_EVT_SCANNABLE:
+            return SOFTBUS_BLE_EVT_SCANNABLE;
+        case OHOS_BLE_EVT_SCANNABLE_DIRECTED:
+            return SOFTBUS_BLE_EVT_SCANNABLE_DIRECTED;
+        case OHOS_BLE_EVT_LEGACY_NON_CONNECTABLE:
+            return SOFTBUS_BLE_EVT_LEGACY_NON_CONNECTABLE;
+        case OHOS_BLE_EVT_LEGACY_SCANNABLE:
+            return SOFTBUS_BLE_EVT_LEGACY_SCANNABLE;
+        case OHOS_BLE_EVT_LEGACY_CONNECTABLE:
+            return SOFTBUS_BLE_EVT_LEGACY_CONNECTABLE;
+        case OHOS_BLE_EVT_LEGACY_CONNECTABLE_DIRECTED:
+            return SOFTBUS_BLE_EVT_LEGACY_CONNECTABLE_DIRECTED;
+        case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN:
+            return SOFTBUS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN;
+        case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV:
+            return SOFTBUS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV;
+        default:
+            return SOFTBUS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE;
+    }
+}
+
+static uint8_t ConvertScanDataStatus(unsigned char dataStatus)
+{
+    switch (dataStatus) {
+        case OHOS_BLE_DATA_COMPLETE:
+            return SOFTBUS_BLE_DATA_COMPLETE;
+        case OHOS_BLE_DATA_INCOMPLETE_MORE_TO_COME:
+            return SOFTBUS_BLE_DATA_INCOMPLETE_MORE_TO_COME;
+        case OHOS_BLE_DATA_INCOMPLETE_TRUNCATED:
+            return SOFTBUS_BLE_DATA_INCOMPLETE_TRUNCATED;
+        default:
+            return SOFTBUS_BLE_DATA_INCOMPLETE_TRUNCATED;
+    }
+}
+
+static uint8_t ConvertScanAddrType(unsigned char addrType)
+{
+    switch (addrType) {
+        case OHOS_BLE_PUBLIC_DEVICE_ADDRESS:
+            return SOFTBUS_BLE_PUBLIC_DEVICE_ADDRESS;
+        case OHOS_BLE_RANDOM_DEVICE_ADDRESS:
+            return SOFTBUS_BLE_RANDOM_DEVICE_ADDRESS;
+        case OHOS_BLE_PUBLIC_IDENTITY_ADDRESS:
+            return SOFTBUS_BLE_PUBLIC_IDENTITY_ADDRESS;
+        case OHOS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS:
+            return SOFTBUS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS;
+        case OHOS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS:
+            return SOFTBUS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS;
+        case OHOS_BLE_NO_ADDRESS:
+            return SOFTBUS_BLE_NO_ADDRESS;
+        default:
+            return SOFTBUS_BLE_NO_ADDRESS;
+    }
+}
+
+static uint8_t ConvertScanPhyType(unsigned char phyType)
+{
+    switch (phyType) {
+        case OHOS_BLE_SCAN_PHY_NO_PACKET:
+            return SOFTBUS_BLE_SCAN_PHY_NO_PACKET;
+        case OHOS_BLE_SCAN_PHY_1M:
+            return SOFTBUS_BLE_SCAN_PHY_1M;
+        case OHOS_BLE_SCAN_PHY_2M:
+            return SOFTBUS_BLE_SCAN_PHY_2M;
+        case OHOS_BLE_SCAN_PHY_CODED:
+            return SOFTBUS_BLE_SCAN_PHY_CODED;
+        default:
+            return SOFTBUS_BLE_SCAN_PHY_NO_PACKET;
+    }
+}
+
+static void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *dst)
+{
+    dst->eventType = ConvertScanEventType(src->eventType);
+    dst->dataStatus = ConvertScanDataStatus(src->dataStatus);
+    dst->addrType = ConvertScanAddrType(src->addrType);
+    if (memcpy_s(dst->addr.addr, BT_ADDR_LEN, src->addr.addr, BT_ADDR_LEN) != EOK) {
+        CLOGE("copy addr failed");
+    }
+    dst->primaryPhy = ConvertScanPhyType(src->primaryPhy);
+    dst->secondaryPhy = ConvertScanPhyType(src->secondaryPhy);
+    dst->advSid = (uint8_t)src->advSid;
+    dst->txPower = (int8_t)src->txPower;
+    dst->rssi = (int8_t)src->rssi;
+    dst->data.rawDataLen = (uint16_t)src->advLen;
+    if (memcpy_s(dst->data.rawData, dst->data.rawDataLen, src->advData, dst->data.rawDataLen) != EOK) {
+        CLOGE("copy adv data failed");
+    }
+}
+
+static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
+{
+    if (scanResultdata == NULL) {
+        return;
+    }
+    SoftBusBcScanResult sr;
+    ConvertScanResult(scanResultdata, &sr);
+    for (int32_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
+        if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+            CLOGW("lock scan failed");
+        }
+        ScanChannel *scanChannel = &g_scanChannel[channelId];
+        if (!scanChannel->isUsed || !scanChannel->isScanning) {
+            SoftBusMutexUnlock(&g_scannerLock);
+            continue;
+        }
+        if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnReportScanDataCallback != NULL) {
+            scanChannel->scanCallback->OnReportScanDataCallback(channelId, &sr);
+        }
+        SoftBusMutexUnlock(&g_scannerLock);
+    }
+}
+
+static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
+{
+    int32_t st = BleOhosStatusToSoftBus((BtStatus)resultCode);
+    for (int32_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
+        if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+            CLOGW("lock scan failed");
+        }
+        ScanChannel *scanChannel = &g_scanChannel[channelId];
+        if (!scanChannel->isUsed || !scanChannel->isScanning) {
+            SoftBusMutexUnlock(&g_scannerLock);
+            continue;
+        }
+        if (isStartScan && scanChannel->scanCallback != NULL &&
+            scanChannel->scanCallback->OnStartScanCallback != NULL) {
+            scanChannel->scanCallback->OnStartScanCallback(channelId, st);
+        }
+        if (!isStartScan && scanChannel->scanCallback != NULL &&
+            scanChannel->scanCallback->OnStopScanCallback != NULL) {
+            scanChannel->scanCallback->OnStopScanCallback(channelId, st);
+        }
+        if (isStartScan) {
+            scanChannel->isScanning = (st == SOFTBUS_BT_STATUS_SUCCESS);
+        } else {
+            scanChannel->isScanning = !(st == SOFTBUS_BT_STATUS_SUCCESS);
+        }
+        SoftBusMutexUnlock(&g_scannerLock);
+    }
+}
+
+static BleScanCallbacks g_softbusBleScanCb = {
+    .scanResultCb = WrapperScanResultCallback,
+    .scanStateChangeCb = WrapperScanStateChangeCallback
+};
+
+static int32_t RegisterScanListener(int32_t *scannerId, const SoftbusScanCallback *cb)
+{
+    if (scannerId == NULL || cb == NULL) {
+        return SOFTBUS_ERR;
+    }
+    if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        return SOFTBUS_LOCK_ERR;
+    }
+    for (int32_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
+        if (g_scanChannel[channelId].isUsed) {
+            continue;
+        }
+        if (BleRegisterScanCallbacks(&g_softbusBleScanCb,
+            &g_scanChannel[channelId].scannerId) !=OHOS_BT_STATUS_SUCCESS) {
+            CLOGE("register ble scan callback failed");
+            SoftBusMutexUnlock(&g_scannerLock);
+            return SOFTBUS_ERR;
+        }
+        g_scanChannel[channelId].isUsed = true;
+        g_scanChannel[channelId].isScanning = false;
+        g_scanChannel[channelId].scanCallback = (SoftbusScanCallback *)cb;
+        *scannerId = channelId;
+        SoftBusMutexUnlock(&g_scannerLock);
+        return SOFTBUS_OK;
+    }
+    CLOGE("no available scan channel");
+    SoftBusMutexUnlock(&g_scannerLock);
+    return SOFTBUS_ERR;
+}
+
+static int32_t UnRegisterScanListener(int32_t scannerId)
+{
+    if (scannerId < 0 || scannerId >= SCAN_MAX_NUM) {
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        return SOFTBUS_LOCK_ERR;
+    }
+    if (!g_scanChannel[scannerId].isUsed) {
+        return SOFTBUS_OK;
+    }
+    g_scanChannel[scannerId].scannerId = -1;
+    g_scanChannel[scannerId].isUsed = false;
+    g_scanChannel[scannerId].isScanning = false;
+    g_scanChannel[scannerId].scanCallback = NULL;
+    SoftBusMutexUnlock(&g_scannerLock);
+    return SOFTBUS_OK;
+}
+
+static BleAdvType ConvertAdvType(uint8_t advType)
+{
+    switch (advType) {
+        case SOFTBUS_BLE_ADV_IND:
+            return OHOS_BLE_ADV_IND;
+        case SOFTBUS_BLE_ADV_DIRECT_IND_HIGH:
+            return OHOS_BLE_ADV_DIRECT_IND_HIGH;
+        case SOFTBUS_BLE_ADV_SCAN_IND:
+            return OHOS_BLE_ADV_SCAN_IND;
+        case SOFTBUS_BLE_ADV_NONCONN_IND:
+            return OHOS_BLE_ADV_NONCONN_IND;
+        case SOFTBUS_BLE_ADV_DIRECT_IND_LOW:
+            return OHOS_BLE_ADV_DIRECT_IND_LOW;
+        default:
+            return OHOS_BLE_ADV_IND;
+    }
+}
 
-#ifdef __cplusplus
+static BleAdvFilter ConvertAdvFilter(uint8_t advFilter)
+{
+    switch (advFilter) {
+        case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY:
+            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
+        case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY:
+            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY;
+        case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST:
+            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST;
+        case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST:
+            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST;
+        default:
+            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
+    }
 }
-#endif
 
-#endif /* SOFTBUS_BLE_GATT_H */
\ No newline at end of file
+static void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst)
+{
+    if (memcpy_s(dst->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN, src->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
+        CLOGE("copy peer addr failed");
+        return;
+    }
+    dst->minInterval = src->minInterval;
+    dst->maxInterval = src->maxInterval;
+    dst->advType = ConvertAdvType(src->advType);
+    dst->ownAddrType = (unsigned char)src->ownAddrType;
+    dst->peerAddrType = (unsigned char)src->peerAddrType;
+    dst->channelMap = src->channelMap;
+    dst->advFilterPolicy = ConvertAdvFilter(src->advFilterPolicy);
+    dst->txPower = src->txPower;
+    dst->duration = src->duration;
+}
+
+static bool CheckAdvChannelInUsed(int32_t advId)
+{
+    if (advId < 0 || advId >= ADV_MAX_NUM) {
+        return false;
+    }
+    if (!g_advChannel[advId].isUsed) {
+        CLOGE("adv %d is not in used", advId);
+        return false;
+    }
+    return true;
+}
+
+static int32_t StartBroadcasting(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *bcData,
+    const SoftbusBroadcastData *rspData)
+{
+    if (param == NULL || bcData == NULL || rspData == NULL) {
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+        return SOFTBUS_LOCK_ERR;
+    }
+    if (!CheckAdvChannelInUsed(advId)) {
+        SoftBusMutexUnlock(&g_advLock);
+        return SOFTBUS_ERR;
+    }
+    if (g_advChannel[advId].isAdvertising) {
+        CLOGW("adv %d already started", advId);
+        SoftBusMutexUnlock(&g_advLock);
+        return SOFTBUS_OK;
+    }
+    BleAdvParams advParam;
+    ConvertAdvParam(param, &advParam);
+    StartAdvRawData advData = {
+        .advDataLen = bcData->rawDataLen,
+        .advData = bcData->rawData,
+        .rspDataLen = rspData->rawDataLen,
+        .rspData = rspData->rawData,
+    };
+    if (BleStartAdvEx(&g_advChannel[advId].advId, advData, advParam) != OHOS_BT_STATUS_SUCCESS) {
+        CLOGI("adv: %d, start adv failed", advId);
+        SoftBusMutexUnlock(&g_advLock);
+        return SOFTBUS_ERR;
+    }
+    g_advChannel[advId].isAdvertising = true;
+    SoftBusMutexUnlock(&g_advLock);
+    return SOFTBUS_OK;
+}
+
+static int32_t StopBroadcasting(int32_t advId)
+{
+    if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+        return SOFTBUS_LOCK_ERR;
+    }
+    if (!CheckAdvChannelInUsed(advId)) {
+        SoftBusMutexUnlock(&g_advLock);
+        return SOFTBUS_ERR;
+    }
+    if (!g_advChannel[advId].isAdvertising) {
+        SoftBusMutexUnlock(&g_advLock);
+        CLOGI("adv %d is not advertising", g_advChannel[advId].advId);
+        return SOFTBUS_OK;
+    }
+    if (BleStopAdv(g_advChannel[advId].advId) != OHOS_BT_STATUS_SUCCESS) {
+        SoftBusMutexUnlock(&g_advLock);
+        CLOGI("adv: %d, stop adv failed", advId);
+        return SOFTBUS_ERR;
+    }
+    g_advChannel[advId].isAdvertising = false;
+    SoftBusMutexUnlock(&g_advLock);
+    return SOFTBUS_OK;
+}
+
+static void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize)
+{
+    while (filterSize-- > 0) {
+        (nativeFilter + filterSize)->address = (char *)(filter + filterSize)->address;
+        (nativeFilter + filterSize)->deviceName = (char *)(filter + filterSize)->deviceName;
+        (nativeFilter + filterSize)->manufactureData = (unsigned char *)(filter + filterSize)->manufactureData;
+        (nativeFilter + filterSize)->manufactureDataLength =
+            (unsigned int)(filter + filterSize)->manufactureDataLength;
+        (nativeFilter + filterSize)->manufactureDataMask = (unsigned char *)(filter + filterSize)->manufactureDataMask;
+        (nativeFilter + filterSize)->manufactureId = (unsigned short)(filter + filterSize)->manufactureId;
+        (nativeFilter + filterSize)->serviceData = (unsigned char *)(filter + filterSize)->serviceData;
+        (nativeFilter + filterSize)->serviceDataLength = (unsigned int)(filter + filterSize)->serviceDataLength;
+        (nativeFilter + filterSize)->serviceDataMask = (unsigned char *)(filter + filterSize)->serviceDataMask;
+        (nativeFilter + filterSize)->serviceUuid = (unsigned char *)(filter + filterSize)->serviceUuid;
+        (nativeFilter + filterSize)->serviceUuidLength = (unsigned int)(filter + filterSize)->serviceUuidLength;
+        (nativeFilter + filterSize)->serviceUuidMask = (unsigned char *)(filter + filterSize)->serviceUuidMask;
+    }
+}
+
+static void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
+{
+    while (filterSize-- > 0) {
+        int32_t len = (nativeFilter + filterSize)->serviceDataLength;
+        if (len <= 0) {
+            continue;
+        }
+        int32_t hexLen = HEXIFY_LEN(len);
+        char *serviceData = (char *)SoftBusCalloc(sizeof(char) * hexLen);
+        char *serviceDataMask = (char *)SoftBusCalloc(sizeof(char) * hexLen);
+        if (serviceData == NULL || serviceDataMask == NULL) {
+            SoftBusFree(serviceData);
+            SoftBusFree(serviceDataMask);
+            continue;
+        }
+        (void)ConvertBytesToHexString(serviceData, hexLen, (nativeFilter + filterSize)->serviceData, len);
+        (void)ConvertBytesToHexString(serviceDataMask, hexLen, (nativeFilter + filterSize)->serviceDataMask, len);
+        CLOGI("BLE Scan Filter size:%d [serviceData:%s, serviceDataMask:%s]",
+            filterSize, serviceData, serviceDataMask);
+        SoftBusFree(serviceData);
+        SoftBusFree(serviceDataMask);
+    }
+}
+
+static int GetScanMode(uint16_t scanInterval, uint16_t scanWindow)
+{
+    if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P2 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P2) {
+        return OHOS_BLE_SCAN_MODE_OP_P2_60_3000;
+    }
+    if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P10 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P10) {
+        return OHOS_BLE_SCAN_MODE_OP_P10_60_600;
+    }
+    if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P25 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P25) {
+        return OHOS_BLE_SCAN_MODE_OP_P25_60_240;
+    }
+    if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P100 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P100) {
+        return OHOS_BLE_SCAN_MODE_OP_P100_1000_1000;
+    }
+    return OHOS_BLE_SCAN_MODE_LOW_POWER;
+}
+
+static bool CheckScanChannelInUsed(int32_t scannerId)
+{
+    if (scannerId < 0 || scannerId >= SCAN_MAX_NUM) {
+        return false;
+    }
+    if (!g_scanChannel[scannerId].isUsed) {
+        CLOGE("scanner %d is not in used", scannerId);
+        return false;
+    }
+    return true;
+}
+
+static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, const SoftBusBcScanFilter *scanFilter,
+    uint8_t filterSize)
+{
+    if (param == NULL || scanFilter == NULL || filterSize == 0) {
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        return SOFTBUS_LOCK_ERR;
+    }
+    if (!CheckScanChannelInUsed(scannerId)) {
+        SoftBusMutexUnlock(&g_scannerLock);
+        CLOGE("ScanChannel id:%d is not in use", scannerId);
+        return SOFTBUS_ERR;
+    }
+    if (g_scanChannel[scannerId].isScanning) {
+        SoftBusMutexUnlock(&g_scannerLock);
+        CLOGI("scan %d is already scanning", scannerId);
+        return SOFTBUS_OK;
+    }
+    BleScanNativeFilter *nativeFilter =
+        (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * filterSize);
+    if (nativeFilter == NULL) {
+        SoftBusMutexUnlock(&g_scannerLock);
+        CLOGE("scan %d malloc native filter failed", scannerId);
+        return SOFTBUS_MALLOC_ERR;
+    }
+    ConvertFilter(nativeFilter, scanFilter, filterSize);
+    DumpBleScanFilter(nativeFilter, filterSize);
+    BleScanConfigs scanConfig = {
+        .scanMode = GetScanMode(param->scanInterval, param->scanWindow),
+        .phy = (int)param->scanPhy
+    };
+    if (BleStartScanEx(scannerId, &scanConfig, nativeFilter, filterSize) != OHOS_BT_STATUS_SUCCESS) {
+        SoftBusFree(nativeFilter);
+        SoftBusMutexUnlock(&g_scannerLock);
+        CLOGE("scan %d, start scan failed", scannerId);
+        return SOFTBUS_ERR;
+    }
+    g_scanChannel[scannerId].isScanning = true;
+    SoftBusFree(nativeFilter);
+    SoftBusMutexUnlock(&g_scannerLock);
+    return SOFTBUS_OK;
+}
+
+static int32_t StopScan(int32_t scannerId)
+{
+    if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        return SOFTBUS_LOCK_ERR;
+    }
+    if (!CheckScanChannelInUsed(scannerId)) {
+        SoftBusMutexUnlock(&g_scannerLock);
+        return SOFTBUS_ERR;
+    }
+    if (!g_scanChannel[scannerId].isScanning) {
+        SoftBusMutexUnlock(&g_scannerLock);
+        CLOGI("scan %d is not scanning", scannerId);
+        return SOFTBUS_OK;
+    }
+    if (BleStopScan(g_scanChannel[scannerId].scannerId) != OHOS_BT_STATUS_SUCCESS) {
+        SoftBusMutexUnlock(&g_scannerLock);
+        CLOGE("scan %d, stop scan failed", scannerId);
+        return SOFTBUS_ERR;
+    }
+    g_scanChannel[scannerId].isScanning = false;
+    SoftBusMutexUnlock(&g_scannerLock);
+    return SOFTBUS_OK;
+}
+
+void SoftbusBleAdapterInit(void)
+{
+    static SoftbusBroadcastMediumInterface interface = {
+        .InitBroadcastAdapter = Init,
+        .DeInitBroadcastAdapter = DeInit,
+        .RegisterBroadcaster = RegisterBroadcaster,
+        .UnRegisterBroadcaster = UnRegisterBroadcaster,
+        .RegisterScanListener = RegisterScanListener,
+        .UnRegisterScanListener = UnRegisterScanListener,
+        .StartBroadcasting = StartBroadcasting,
+        .StopBroadcasting = StopBroadcasting,
+        .StartScan = StartScan,
+        .StopScan = StopScan
+    };
+    if (RegisterBroadcastMediumFunction(BROADCAST_MEDIUM_TYPE_BLE, &interface) != 0) {
+        CLOGE("register broadcast medium function failed.");
+    }
+}
+
+bool SoftBusBcIsLpDeviceAvailable(void)
+{
+    return IsLpDeviceAvailable();
+}
+
+int32_t SoftBusBcEnableSyncDataToLpDevice(void)
+{
+    return EnableSyncDataToLpDevice();
+}
+
+int32_t SoftBusBcDisableSyncDataToLpDevice(void)
+{
+    return DisableSyncDataToLpDevice();
+}
+
+int32_t SoftBusBcSetScanReportChannelToLpDevice(int scannerId, bool enable)
+{
+    return SetScanReportChannelToLpDevice(scannerId, enable);
+}
+
+int32_t SoftBusBcSetLpDeviceParam(int duration, int maxExtAdvEvents, int window,
+    int interval, int advHandle)
+{
+    return SetLpDeviceAdvParam(duration, maxExtAdvEvents, window, interval, advHandle);
+}
\ No newline at end of file
-- 
Gitee


From 3eb805eac971f9e5f37f6154ad59688c246ddf1b Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 06:59:32 +0000
Subject: [PATCH 03/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Fgatt.h.=20gatt=20ada?=
 =?UTF-8?q?pter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/include/softbus_ble_gatt.h     | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
index 0f732d92c4..71577582a3 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
@@ -24,16 +24,28 @@
 #ifndef SOFTBUS_BLE_GATT_H
 #define SOFTBUS_BLE_GATT_H
 
-#include "softbus_broadcast_adapter.h"
+#include "softbus_broadcast_adapter_interface.h"
+#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C"{
 #endif
 
-void softbus_ble_adapter_init(void);
+void SoftbusBleAdapterInit(void);
+
+bool SoftBusBcIsLpDeviceAvailable(void);
+
+int32_t SoftBusBcEnableSyncDataToLpDevice(void);
+
+int32_t SoftBusBcDisableSyncDataToLpDevice(void);
+
+int32_t SoftBusBcSetScanReportChannelToLpDevice(int32_t scannerId, bool enable);
+
+int32_t SoftBusBcSetLpDeviceParam(int duration, int maxExtAdvEvents, int window,
+    int interval, int advHandle);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* SOFTBUS_BLE_GATT_H */
+#endif /* SOFTBUS_BLE_GATT_H */
\ No newline at end of file
-- 
Gitee


From e9d050101fac58ea231d4c95f25cfc726ddedbd2 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 07:00:16 +0000
Subject: [PATCH 04/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Finterfac?=
 =?UTF-8?q?e.h.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5?=
 =?UTF-8?q?=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1?=
 =?UTF-8?q?=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../softbus_broadcast_adapter_interface.h     | 35 ++++++++-----------
 1 file changed, 15 insertions(+), 20 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
index 64584e8be4..06ca7a6374 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
@@ -52,7 +52,7 @@ typedef struct {
 typedef struct {
     void (*OnStartScanCallback)(int32_t scanId, int32_t status);
     void (*OnStopScanCallback)(int32_t scanId, int32_t status);
-    void (*OnReportScanDataCallback)(int32_t scanId, const SoftBusBleScanResult *reportData);
+    void (*OnReportScanDataCallback)(int32_t scanId, const SoftBusBcScanResult *reportData);
 } SoftbusScanCallback;
 
 /**
@@ -61,24 +61,20 @@ typedef struct {
  * @since 1.0
  * @version 1.0
  */
-struct SoftbusBroadcastMediumInterface {
-    int32_t (*InitBroadcast)(void);
-    int32_t (*DeInitBroadcast)(void);
+typedef struct {
+    int32_t (*InitBroadcastAdapter)(void);
+    int32_t (*DeInitBroadcastAdapter)(void);
     int32_t (*RegisterBroadcaster)(int32_t *advId, const SoftbusBroadcastCallback *cb);
     int32_t (*UnRegisterBroadcaster)(int32_t advId);
-    int32_t (*RegisterScanListener)(int32_t *scanerId, const SoftbusScanCallback *cb);
-    int32_t (*UnRegisterScanListener)(int32_t scanerId);
-    int32_t (*StartBroadcasting)(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *bcData,
-        const SoftbusBroadcastData *rspData);
-    int32_t (*UpdateBroadcasting)(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *bcData,
-        const SoftbusBroadcastData *rspData);
+    int32_t (*RegisterScanListener)(int32_t *scannerId, const SoftbusScanCallback *cb);
+    int32_t (*UnRegisterScanListener)(int32_t scannerId);
+    int32_t (*StartBroadcasting)(int32_t advId, const SoftbusBroadcastParam *param,
+        const SoftbusBroadcastData *bcData, const SoftbusBroadcastData *rspData);
     int32_t (*StopBroadcasting)(int32_t advId);
-    int32_t (*StartScan)(int32_t scanerId, const SoftBusBcScanParams *param);
-    int32_t (*StopScan)(int32_t scanerId);
-    int32_t (*SetScanFilter)(int32_t scanerId, const SoftBusBcScanFilter *scanFilter, uint8_t filterSize);
-    int32_t (*GetScanFilter)(int32_t scanerId, const SoftBusBcScanFilter *scanFilter, uint8_t *filterSize);
-    int32_t (*QueryBroadcastStatus)(int32_t advId, int32_t *status);
-};
+    int32_t (*StartScan)(int32_t scannerId, const SoftBusBcScanParams *param, const SoftBusBcScanFilter *scanFilter,
+        uint8_t filterSize);
+    int32_t (*StopScan)(int32_t scannerId);
+} SoftbusBroadcastMediumInterface;
 
 /**
  * @brief Defines interface functions for registering different media
@@ -86,19 +82,18 @@ struct SoftbusBroadcastMediumInterface {
  * @since 1.0
  * @version 1.0
  */
+int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBroadcastMediumInterface *interface);
 
-int32_t RegisterBroadcastMediumFunction(enum SoftbusMediumType type,
-    const struct SoftbusBroadcastMediumInterface *interface);
 /**
  * @brief Defines interface functions for unregistering different media
  *
  * @since 1.0
  * @version 1.0
  */
-int32_t UnRegisterBroadcastMediumFunction(enum SoftbusMediumType type);
+int32_t UnRegisterBroadcastMediumFunction(SoftbusMediumType type);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* SOFTBUS_BROADCAST_ADAPTER_INTERFACE_H */
+#endif /* SOFTBUS_BROADCAST_ADAPTER_INTERFACE_H */
\ No newline at end of file
-- 
Gitee


From 53f1238f842f84a0acebb2ac1f2ea46dc79075f0 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 07:00:37 +0000
Subject: [PATCH 05/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Ftype.h.?=
 =?UTF-8?q?=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3?=
 =?UTF-8?q?=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86?=
 =?UTF-8?q?=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../include/softbus_broadcast_adapter_type.h  | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
index 698a7132e4..6b0ad69f2a 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
@@ -44,11 +44,11 @@ extern "C"{
  * @since 1.0
  * @version 1.0
  */
-enum SoftbusMediumType {
+typedef enum {
     BROADCAST_MEDIUM_TYPE_BLE,
     BROADCAST_MEDIUM_TYPE_SLE,
     BROADCAST_MEDIUM_TYPE_BUTT,
-};
+} SoftbusMediumType;
 
 /**
  * @brief Defines the broadcast data information
@@ -57,15 +57,8 @@ enum SoftbusMediumType {
  * @version 1.0
  */
 typedef struct {
-    uint16_t uuidLen;
-    uint16_t serviceLen;
-    uint8_t *uuid;
-    uint8_t *serviceData;
-    uint16_t companyId;
-    uint16_t manufacturerDataLen;
-    uint8_t *manufacturerData;
-    uint8_t flag;
-    uint8_t rsv[3]; // Reserved
+    uint16_t rawDataLen;
+    uint8_t *rawData;
 } SoftbusBroadcastData;
 
 /**
@@ -95,7 +88,7 @@ typedef struct {
     uint8_t addrType;
     SoftbusMacAddr addr;
     SoftbusBroadcastData data;
-} SoftBusBleScanResult;
+} SoftBusBcScanResult;
 
 /**
  * @brief Defines the broadcast parameters
@@ -155,4 +148,4 @@ typedef struct {
 }
 #endif
 
-#endif /* SOFTBUS_BROADCAST_ADAPTER_TYPE_H */
+#endif /* SOFTBUS_BROADCAST_ADAPTER_TYPE_H */
\ No newline at end of file
-- 
Gitee


From 2905beabd892ab8c89c85fda825a28db7c13932e Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 07:01:06 +0000
Subject: [PATCH 06/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Fmanager.h.=20gatt=20adap?=
 =?UTF-8?q?ter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../interface/softbus_broadcast_manager.h      | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
index 2ecf1d559c..05d9d658eb 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
@@ -88,7 +88,7 @@ int32_t DeInitBroadcastMgr(void);
  * @since 1.0
  * @version 1.0
  */
-int32_t RegisterBroadcaster(enum BaseServiceType type, int32_t *bcId, const BroadcastCallback *cb);
+int32_t RegisterBroadcaster(BaseServiceType type, int32_t *bcId, const BroadcastCallback *cb);
 
 /**
  * @brief UnRegister the service to the broadcast manager.
@@ -116,7 +116,7 @@ int32_t UnRegisterBroadcaster(int32_t bcId);
  * @since 1.0
  * @version 1.0
  */
-int32_t RegisterScanListener(enum BaseServiceType type, int32_t *listenerId, const ScanCallback *cb);
+int32_t RegisterScanListener(BaseServiceType type, int32_t *listenerId, const ScanCallback *cb);
 
 /**
  * @brief UnRegister the service listener to the broadcast manager.
@@ -145,8 +145,8 @@ int32_t UnRegisterScanListener(int32_t listenerId);
  * @since 1.0
  * @version 1.0
  */
-int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastData *bcData,
-    const BroadcastData *rspData);
+int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPayload *bcData,
+    const BroadcastPayload *rspData);
 
 /**
  * @brief The service update broadcast data and parameters.
@@ -162,8 +162,8 @@ int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const Broad
  * @since 1.0
  * @version 1.0
  */
-int32_t UpdateBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastData *bcData,
-    const BroadcastData *rspData);
+int32_t UpdateBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPayload *bcData,
+    const BroadcastPayload *rspData);
 
 /**
  * @brief The service stop broadcast
@@ -249,8 +249,12 @@ int32_t GetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_
  */
 int32_t QueryBroadcastStatus(int32_t bcId, int32_t *status);
 
+void SetBroadcastAdvFlag();
+
+uint8_t GetBroadcastFlag();
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* SOFTBUS_BROADCAST_MANAGER_H */
+#endif /* SOFTBUS_BROADCAST_MANAGER_H */
\ No newline at end of file
-- 
Gitee


From e34cae9043aa0c0fda4e8e06e8b426ac748702a2 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 07:01:24 +0000
Subject: [PATCH 07/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Ftype.h.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../interface/softbus_broadcast_type.h        | 118 +++++++++++++++---
 1 file changed, 101 insertions(+), 17 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
index 833707c6e5..cfa2456116 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
@@ -38,13 +38,23 @@ extern "C"{
  */
 #define BC_ADDR_MAC_LEN 6
 
+// Bluetooth scan duty cycle, unit: ms
+#define SOFTBUS_BC_SCAN_INTERVAL_P2 3000
+#define SOFTBUS_BC_SCAN_INTERVAL_P10 600
+#define SOFTBUS_BC_SCAN_INTERVAL_P25 240
+#define SOFTBUS_BC_SCAN_INTERVAL_P100 1000
+#define SOFTBUS_BC_SCAN_WINDOW_P2 60
+#define SOFTBUS_BC_SCAN_WINDOW_P10 60
+#define SOFTBUS_BC_SCAN_WINDOW_P25 60
+#define SOFTBUS_BC_SCAN_WINDOW_P100 1000
+
 /**
  * @brief Defines the broadcast service type.
  *
  * @since 1.0
  * @version 1.0
  */
-enum BaseServiceType {
+typedef enum {
     SRV_TYPE_HB, // The service type is heart beat.
     SRV_TYPE_CONN, // The service type is connection.
     SRV_TYPE_TRANS_MSG, // The service type is transmission message.
@@ -52,7 +62,86 @@ enum BaseServiceType {
     SRV_TYPE_SHARE, // The service type is share discovery.
     SRV_TYPE_APPROACH, // The service type is approach discovery.
     SRV_TYPE_BUTT,
-};
+} BaseServiceType;
+
+typedef enum {
+    SOFTBUS_BC_STATUS_SUCCESS = 0x00,
+    SOFTBUS_BC_STATUS_FAIL,
+    SOFTBUS_BC_STATUS_NOT_READY,
+    SOFTBUS_BC_STATUS_NOMEM,
+    SOFTBUS_BC_STATUS_BUSY,
+    SOFTBUS_BC_STATUS_DONE,
+    SOFTBUS_BC_STATUS_UNSUPPORTED,
+    SOFTBUS_BC_STATUS_PARM_INVALID,
+    SOFTBUS_BC_STATUS_UNHANDLED,
+    SOFTBUS_BC_STATUS_AUTH_FAILURE,
+    SOFTBUS_BC_STATUS_RMT_DEV_DOWN,
+    SOFTBUS_BC_STATUS_AUTH_REJECTED
+} SoftBusBcStatus;
+
+typedef enum {
+    SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE = 0x00,
+    SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED = 0x04,
+    SOFTBUS_BC_EVT_CONNECTABLE = 0x01,
+    SOFTBUS_BC_EVT_CONNECTABLE_DIRECTED = 0x05,
+    SOFTBUS_BC_EVT_SCANNABLE = 0x02,
+    SOFTBUS_BC_EVT_SCANNABLE_DIRECTED = 0x06,
+    SOFTBUS_BC_EVT_LEGACY_NON_CONNECTABLE = 0x10,
+    SOFTBUS_BC_EVT_LEGACY_SCANNABLE = 0x12,
+    SOFTBUS_BC_EVT_LEGACY_CONNECTABLE = 0x13,
+    SOFTBUS_BC_EVT_LEGACY_CONNECTABLE_DIRECTED = 0x15,
+    SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN = 0x1A,
+    SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV = 0x1B
+} SoftBusBcScanResultEvtType;
+
+typedef enum {
+    SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS = 0x00,
+    SOFTBUS_BC_RANDOM_DEVICE_ADDRESS = 0x01,
+    SOFTBUS_BC_PUBLIC_IDENTITY_ADDRESS = 0x02,
+    SOFTBUS_BC_RANDOM_STATIC_IDENTITY_ADDRESS = 0x03,
+    SOFTBUS_BC_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS = 0xFE,
+    SOFTBUS_BC_NO_ADDRESS = 0xFF,
+} SoftBusBcScanResultAddrType;
+
+typedef enum {
+    SOFTBUS_BC_SCAN_TYPE_PASSIVE = 0x00,
+    SOFTBUS_BC_SCAN_TYPE_ACTIVE,
+} SoftBusBcScanType;
+
+typedef enum {
+    SOFTBUS_BC_SCAN_PHY_NO_PACKET = 0x00,
+    SOFTBUS_BC_SCAN_PHY_1M = 0x01,
+    SOFTBUS_BC_SCAN_PHY_2M = 0x02,
+    SOFTBUS_BC_SCAN_PHY_CODED = 0x03
+} SoftBusBcScanResultPhyType;
+
+typedef enum {
+    SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL = 0x00,
+    SOFTBUS_BC_SCAN_FILTER_POLICY_ONLY_WHITE_LIST,
+    SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL_AND_RPA,
+    SOFTBUS_BC_SCAN_FILTER_POLICY_ONLY_WHITE_LIST_AND_RPA
+} SoftBusBcScanFilterPolicy;
+
+typedef enum {
+    SOFTBUS_BC_ADV_IND = 0x00,
+    SOFTBUS_BC_ADV_DIRECT_IND_HIGH = 0x01,
+    SOFTBUS_BC_ADV_SCAN_IND = 0x02,
+    SOFTBUS_BC_ADV_NONCONN_IND = 0x03,
+    SOFTBUS_BC_ADV_DIRECT_IND_LOW  = 0x04,
+} SoftBusBcAdvType;
+
+typedef enum {
+    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY = 0x00,
+    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY = 0x01,
+    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST = 0x02,
+    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST = 0x03,
+} SoftBusBcAdvFilter;
+
+typedef enum {
+    SOFTBUS_BC_DATA_COMPLETE = 0x00,
+    SOFTBUS_BC_DATA_INCOMPLETE_MORE_TO_COME = 0x01,
+    SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED = 0x02,
+} SoftBusScanResultDataStatus;
 
 /**
  * @brief Defines the broadcast data information
@@ -61,16 +150,10 @@ enum BaseServiceType {
  * @version 1.0
  */
 typedef struct {
-    uint16_t uuidLen;
-    uint16_t serviceLen;
-    uint8_t *uuid;
-    uint8_t *serviceData;
-    uint16_t companyId;
-    uint16_t manufacturerDataLen;
-    uint8_t *manufacturerData;
-    uint8_t flag;
-    uint8_t rsv[3]; // Reserved
-} BroadcastData;
+    uint16_t uuid;
+    uint16_t payloadLen;
+    uint8_t *payload; // if pointer defines rsp payload, pointer may be null
+} BroadcastPayload;
 
 /**
  * @brief Defines mac address information
@@ -98,7 +181,8 @@ typedef struct {
     int8_t rssi;
     uint8_t addrType;
     BcMacAddr addr;
-    BroadcastData data;
+    BroadcastPayload bcData;
+    BroadcastPayload rspData;
 } BroadcastReportInfo;
 
 /**
@@ -129,9 +213,9 @@ typedef struct {
 typedef struct {
     int8_t *address;
     int8_t *deviceName;
-    uint32_t serviceUuidLength;
-    uint8_t *serviceUuid;
-    uint8_t *serviceUuidMask;
+    uint32_t serviceUuidLength; // reserve
+    uint8_t *serviceUuid; // reserve
+    uint8_t *serviceUuidMask; // reserve
     uint32_t serviceDataLength;
     uint8_t *serviceData;
     uint8_t *serviceDataMask;
@@ -159,4 +243,4 @@ typedef struct {
 }
 #endif
 
-#endif /* SOFTBUS_BROADCAST_TYPE_H */
+#endif /* SOFTBUS_BROADCAST_TYPE_H */
\ No newline at end of file
-- 
Gitee


From b1c435f38f87cbe3ed25e77614260ac96a17ba12 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 07:01:50 +0000
Subject: [PATCH 08/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/manager/src/softbus=5Fbroadcast=5Fmgr.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c  | 1 +
 1 file changed, 1 insertion(+)

diff --git a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
index b5f23358c3..684349544f 100644
--- a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
+++ b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
@@ -15,6 +15,7 @@
 
 #include "softbus_broadcast_manager.h"
 #include "softbus_broadcast_type.h"
+#include "softbus_error_code.h"
 
 int32_t InitBroadcastMgr(void)
 {
-- 
Gitee


From 5c2ff722acb0c7ab5520d856f6125b2c721e89cc Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 07:02:29 +0000
Subject: [PATCH 09/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/net?=
 =?UTF-8?q?=5Fbluetooth.gni.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91?=
 =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4?=
 =?UTF-8?q?=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 adapter/common/net/bluetooth/net_bluetooth.gni | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/adapter/common/net/bluetooth/net_bluetooth.gni b/adapter/common/net/bluetooth/net_bluetooth.gni
index 249e3d0b69..3afb89cb19 100644
--- a/adapter/common/net/bluetooth/net_bluetooth.gni
+++ b/adapter/common/net/bluetooth/net_bluetooth.gni
@@ -18,6 +18,9 @@ adapter_ble_inc = [
   "$dsoftbus_root_path/core/common/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/interface",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/include",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/include",
 ]
 adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/ble/softbus_adapter_ble_gatt.c",
@@ -25,6 +28,8 @@ adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/ble/softbus_adapter_ble_gatt_server.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/adapter_bt_utils.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c",
 ]
 adapter_net_br_src = [ "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c" ]
 adapter_ble_external_deps = [ "bluetooth:btframework" ]
-- 
Gitee


From 84c8a8b3f68cb55e0922dc0625dc8ed9619dc9f8 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 08:57:09 +0000
Subject: [PATCH 10/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Fgatt.h.=20gatt=20ada?=
 =?UTF-8?q?pter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h  | 2 --
 1 file changed, 2 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
index 71577582a3..0230341f6d 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
@@ -31,8 +31,6 @@
 extern "C"{
 #endif
 
-void SoftbusBleAdapterInit(void);
-
 bool SoftBusBcIsLpDeviceAvailable(void);
 
 int32_t SoftBusBcEnableSyncDataToLpDevice(void);
-- 
Gitee


From 9bd325ba325c4cf741d8f9d0d9076e1febad5fa5 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 08:57:11 +0000
Subject: [PATCH 11/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c  | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 539ec52b09..bcc28abcc0 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -643,7 +643,7 @@ static int32_t StopScan(int32_t scannerId)
     return SOFTBUS_OK;
 }
 
-void SoftbusBleAdapterInit(void)
+const SoftbusBroadcastMediumInterface *GetBroadcastMediumFunction(SoftbusMediumType type)
 {
     static SoftbusBroadcastMediumInterface interface = {
         .InitBroadcastAdapter = Init,
@@ -657,9 +657,7 @@ void SoftbusBleAdapterInit(void)
         .StartScan = StartScan,
         .StopScan = StopScan
     };
-    if (RegisterBroadcastMediumFunction(BROADCAST_MEDIUM_TYPE_BLE, &interface) != 0) {
-        CLOGE("register broadcast medium function failed.");
-    }
+    return &interface;
 }
 
 bool SoftBusBcIsLpDeviceAvailable(void)
-- 
Gitee


From e10761e65cb87ebe8a5f88fa4d5c9ae9c54acff0 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 08:57:15 +0000
Subject: [PATCH 12/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Finterfac?=
 =?UTF-8?q?e.h.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5?=
 =?UTF-8?q?=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1?=
 =?UTF-8?q?=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../include/softbus_broadcast_adapter_interface.h      | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
index 06ca7a6374..d3d4b052a9 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
@@ -82,15 +82,7 @@ typedef struct {
  * @since 1.0
  * @version 1.0
  */
-int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBroadcastMediumInterface *interface);
-
-/**
- * @brief Defines interface functions for unregistering different media
- *
- * @since 1.0
- * @version 1.0
- */
-int32_t UnRegisterBroadcastMediumFunction(SoftbusMediumType type);
+const SoftbusBroadcastMediumInterface *GetBroadcastMediumFunction(SoftbusMediumType type);
 
 #ifdef __cplusplus
 }
-- 
Gitee


From 4b66c7541e2f7eaacb69082083add57336e4cc5c Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 08:57:18 +0000
Subject: [PATCH 13/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/net?=
 =?UTF-8?q?=5Fbluetooth.gni.=20=20gatt=20adapter=E5=B1=82=E9=9D=A2?=
 =?UTF-8?q?=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB?=
 =?UTF-8?q?=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 adapter/common/net/bluetooth/net_bluetooth.gni | 2 --
 1 file changed, 2 deletions(-)

diff --git a/adapter/common/net/bluetooth/net_bluetooth.gni b/adapter/common/net/bluetooth/net_bluetooth.gni
index 3afb89cb19..307e402fa6 100644
--- a/adapter/common/net/bluetooth/net_bluetooth.gni
+++ b/adapter/common/net/bluetooth/net_bluetooth.gni
@@ -18,7 +18,6 @@ adapter_ble_inc = [
   "$dsoftbus_root_path/core/common/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common",
-  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/interface",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/include",
 ]
@@ -29,7 +28,6 @@ adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/adapter_bt_utils.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c",
-  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c",
 ]
 adapter_net_br_src = [ "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c" ]
 adapter_ble_external_deps = [ "bluetooth:btframework" ]
-- 
Gitee


From b677e4d1c7765d2d8f6d18a76bef558e3e4a0971 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 08:58:46 +0000
Subject: [PATCH 14/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/manager/src/softbus=5Fbroadcast=5Fmgr.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c  | 1 -
 1 file changed, 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
index 684349544f..b5f23358c3 100644
--- a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
+++ b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
@@ -15,7 +15,6 @@
 
 #include "softbus_broadcast_manager.h"
 #include "softbus_broadcast_type.h"
-#include "softbus_error_code.h"
 
 int32_t InitBroadcastMgr(void)
 {
-- 
Gitee


From 940e18e8af6e72a6fc75edc2dc8a2385001cea57 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 08:59:34 +0000
Subject: [PATCH 15/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Fmanager.h.=20gatt=20adap?=
 =?UTF-8?q?ter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../interface/softbus_broadcast_manager.h      | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
index 05d9d658eb..2ecf1d559c 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
@@ -88,7 +88,7 @@ int32_t DeInitBroadcastMgr(void);
  * @since 1.0
  * @version 1.0
  */
-int32_t RegisterBroadcaster(BaseServiceType type, int32_t *bcId, const BroadcastCallback *cb);
+int32_t RegisterBroadcaster(enum BaseServiceType type, int32_t *bcId, const BroadcastCallback *cb);
 
 /**
  * @brief UnRegister the service to the broadcast manager.
@@ -116,7 +116,7 @@ int32_t UnRegisterBroadcaster(int32_t bcId);
  * @since 1.0
  * @version 1.0
  */
-int32_t RegisterScanListener(BaseServiceType type, int32_t *listenerId, const ScanCallback *cb);
+int32_t RegisterScanListener(enum BaseServiceType type, int32_t *listenerId, const ScanCallback *cb);
 
 /**
  * @brief UnRegister the service listener to the broadcast manager.
@@ -145,8 +145,8 @@ int32_t UnRegisterScanListener(int32_t listenerId);
  * @since 1.0
  * @version 1.0
  */
-int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPayload *bcData,
-    const BroadcastPayload *rspData);
+int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastData *bcData,
+    const BroadcastData *rspData);
 
 /**
  * @brief The service update broadcast data and parameters.
@@ -162,8 +162,8 @@ int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const Broad
  * @since 1.0
  * @version 1.0
  */
-int32_t UpdateBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPayload *bcData,
-    const BroadcastPayload *rspData);
+int32_t UpdateBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastData *bcData,
+    const BroadcastData *rspData);
 
 /**
  * @brief The service stop broadcast
@@ -249,12 +249,8 @@ int32_t GetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_
  */
 int32_t QueryBroadcastStatus(int32_t bcId, int32_t *status);
 
-void SetBroadcastAdvFlag();
-
-uint8_t GetBroadcastFlag();
-
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* SOFTBUS_BROADCAST_MANAGER_H */
\ No newline at end of file
+#endif /* SOFTBUS_BROADCAST_MANAGER_H */
-- 
Gitee


From 0e3b90f9c8a646bdb0bb6b35b96d698bdbc6918b Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 08:59:51 +0000
Subject: [PATCH 16/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Ftype.h.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../interface/softbus_broadcast_type.h        | 118 +++---------------
 1 file changed, 17 insertions(+), 101 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
index cfa2456116..833707c6e5 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
@@ -38,23 +38,13 @@ extern "C"{
  */
 #define BC_ADDR_MAC_LEN 6
 
-// Bluetooth scan duty cycle, unit: ms
-#define SOFTBUS_BC_SCAN_INTERVAL_P2 3000
-#define SOFTBUS_BC_SCAN_INTERVAL_P10 600
-#define SOFTBUS_BC_SCAN_INTERVAL_P25 240
-#define SOFTBUS_BC_SCAN_INTERVAL_P100 1000
-#define SOFTBUS_BC_SCAN_WINDOW_P2 60
-#define SOFTBUS_BC_SCAN_WINDOW_P10 60
-#define SOFTBUS_BC_SCAN_WINDOW_P25 60
-#define SOFTBUS_BC_SCAN_WINDOW_P100 1000
-
 /**
  * @brief Defines the broadcast service type.
  *
  * @since 1.0
  * @version 1.0
  */
-typedef enum {
+enum BaseServiceType {
     SRV_TYPE_HB, // The service type is heart beat.
     SRV_TYPE_CONN, // The service type is connection.
     SRV_TYPE_TRANS_MSG, // The service type is transmission message.
@@ -62,86 +52,7 @@ typedef enum {
     SRV_TYPE_SHARE, // The service type is share discovery.
     SRV_TYPE_APPROACH, // The service type is approach discovery.
     SRV_TYPE_BUTT,
-} BaseServiceType;
-
-typedef enum {
-    SOFTBUS_BC_STATUS_SUCCESS = 0x00,
-    SOFTBUS_BC_STATUS_FAIL,
-    SOFTBUS_BC_STATUS_NOT_READY,
-    SOFTBUS_BC_STATUS_NOMEM,
-    SOFTBUS_BC_STATUS_BUSY,
-    SOFTBUS_BC_STATUS_DONE,
-    SOFTBUS_BC_STATUS_UNSUPPORTED,
-    SOFTBUS_BC_STATUS_PARM_INVALID,
-    SOFTBUS_BC_STATUS_UNHANDLED,
-    SOFTBUS_BC_STATUS_AUTH_FAILURE,
-    SOFTBUS_BC_STATUS_RMT_DEV_DOWN,
-    SOFTBUS_BC_STATUS_AUTH_REJECTED
-} SoftBusBcStatus;
-
-typedef enum {
-    SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE = 0x00,
-    SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED = 0x04,
-    SOFTBUS_BC_EVT_CONNECTABLE = 0x01,
-    SOFTBUS_BC_EVT_CONNECTABLE_DIRECTED = 0x05,
-    SOFTBUS_BC_EVT_SCANNABLE = 0x02,
-    SOFTBUS_BC_EVT_SCANNABLE_DIRECTED = 0x06,
-    SOFTBUS_BC_EVT_LEGACY_NON_CONNECTABLE = 0x10,
-    SOFTBUS_BC_EVT_LEGACY_SCANNABLE = 0x12,
-    SOFTBUS_BC_EVT_LEGACY_CONNECTABLE = 0x13,
-    SOFTBUS_BC_EVT_LEGACY_CONNECTABLE_DIRECTED = 0x15,
-    SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN = 0x1A,
-    SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV = 0x1B
-} SoftBusBcScanResultEvtType;
-
-typedef enum {
-    SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS = 0x00,
-    SOFTBUS_BC_RANDOM_DEVICE_ADDRESS = 0x01,
-    SOFTBUS_BC_PUBLIC_IDENTITY_ADDRESS = 0x02,
-    SOFTBUS_BC_RANDOM_STATIC_IDENTITY_ADDRESS = 0x03,
-    SOFTBUS_BC_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS = 0xFE,
-    SOFTBUS_BC_NO_ADDRESS = 0xFF,
-} SoftBusBcScanResultAddrType;
-
-typedef enum {
-    SOFTBUS_BC_SCAN_TYPE_PASSIVE = 0x00,
-    SOFTBUS_BC_SCAN_TYPE_ACTIVE,
-} SoftBusBcScanType;
-
-typedef enum {
-    SOFTBUS_BC_SCAN_PHY_NO_PACKET = 0x00,
-    SOFTBUS_BC_SCAN_PHY_1M = 0x01,
-    SOFTBUS_BC_SCAN_PHY_2M = 0x02,
-    SOFTBUS_BC_SCAN_PHY_CODED = 0x03
-} SoftBusBcScanResultPhyType;
-
-typedef enum {
-    SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL = 0x00,
-    SOFTBUS_BC_SCAN_FILTER_POLICY_ONLY_WHITE_LIST,
-    SOFTBUS_BC_SCAN_FILTER_POLICY_ACCEPT_ALL_AND_RPA,
-    SOFTBUS_BC_SCAN_FILTER_POLICY_ONLY_WHITE_LIST_AND_RPA
-} SoftBusBcScanFilterPolicy;
-
-typedef enum {
-    SOFTBUS_BC_ADV_IND = 0x00,
-    SOFTBUS_BC_ADV_DIRECT_IND_HIGH = 0x01,
-    SOFTBUS_BC_ADV_SCAN_IND = 0x02,
-    SOFTBUS_BC_ADV_NONCONN_IND = 0x03,
-    SOFTBUS_BC_ADV_DIRECT_IND_LOW  = 0x04,
-} SoftBusBcAdvType;
-
-typedef enum {
-    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY = 0x00,
-    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY = 0x01,
-    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST = 0x02,
-    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST = 0x03,
-} SoftBusBcAdvFilter;
-
-typedef enum {
-    SOFTBUS_BC_DATA_COMPLETE = 0x00,
-    SOFTBUS_BC_DATA_INCOMPLETE_MORE_TO_COME = 0x01,
-    SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED = 0x02,
-} SoftBusScanResultDataStatus;
+};
 
 /**
  * @brief Defines the broadcast data information
@@ -150,10 +61,16 @@ typedef enum {
  * @version 1.0
  */
 typedef struct {
-    uint16_t uuid;
-    uint16_t payloadLen;
-    uint8_t *payload; // if pointer defines rsp payload, pointer may be null
-} BroadcastPayload;
+    uint16_t uuidLen;
+    uint16_t serviceLen;
+    uint8_t *uuid;
+    uint8_t *serviceData;
+    uint16_t companyId;
+    uint16_t manufacturerDataLen;
+    uint8_t *manufacturerData;
+    uint8_t flag;
+    uint8_t rsv[3]; // Reserved
+} BroadcastData;
 
 /**
  * @brief Defines mac address information
@@ -181,8 +98,7 @@ typedef struct {
     int8_t rssi;
     uint8_t addrType;
     BcMacAddr addr;
-    BroadcastPayload bcData;
-    BroadcastPayload rspData;
+    BroadcastData data;
 } BroadcastReportInfo;
 
 /**
@@ -213,9 +129,9 @@ typedef struct {
 typedef struct {
     int8_t *address;
     int8_t *deviceName;
-    uint32_t serviceUuidLength; // reserve
-    uint8_t *serviceUuid; // reserve
-    uint8_t *serviceUuidMask; // reserve
+    uint32_t serviceUuidLength;
+    uint8_t *serviceUuid;
+    uint8_t *serviceUuidMask;
     uint32_t serviceDataLength;
     uint8_t *serviceData;
     uint8_t *serviceDataMask;
@@ -243,4 +159,4 @@ typedef struct {
 }
 #endif
 
-#endif /* SOFTBUS_BROADCAST_TYPE_H */
\ No newline at end of file
+#endif /* SOFTBUS_BROADCAST_TYPE_H */
-- 
Gitee


From d49d3b1e5add48a37dedd5b66c2c219ec4964e00 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 09:31:15 +0000
Subject: [PATCH 17/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c         | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index bcc28abcc0..351efac9ef 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -29,7 +29,7 @@ static SoftBusMutex g_advLock = {0};
 static SoftBusMutex g_scannerLock = {0};
 
 typedef struct {
-    int advId;
+    int32_t advId;
     bool isUsed;
     bool isAdvertising;
     SoftbusBroadcastCallback *advCallback;
@@ -77,7 +77,7 @@ static int32_t DeInit(void)
 static void WrapperAdvEnableCallback(int advId, int status)
 {
     int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
-    for (uint32_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             CLOGW("lock adv failed");
         }
@@ -99,7 +99,7 @@ static void WrapperAdvEnableCallback(int advId, int status)
 static void WrapperAdvDisableCallback(int advId, int status)
 {
     int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
-    for (uint32_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             CLOGW("lock adv failed");
         }
@@ -131,7 +131,7 @@ static int32_t RegisterBroadcaster(int32_t *advId, const SoftbusBroadcastCallbac
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
         return SOFTBUS_LOCK_ERR;
     }
-    for (int32_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
         if (g_advChannel[channelId].isUsed) {
             continue;
         }
@@ -281,7 +281,7 @@ static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
     }
     SoftBusBcScanResult sr;
     ConvertScanResult(scanResultdata, &sr);
-    for (int32_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
             CLOGW("lock scan failed");
         }
@@ -300,7 +300,7 @@ static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
 static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
 {
     int32_t st = BleOhosStatusToSoftBus((BtStatus)resultCode);
-    for (int32_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
             CLOGW("lock scan failed");
         }
@@ -339,7 +339,7 @@ static int32_t RegisterScanListener(int32_t *scannerId, const SoftbusScanCallbac
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
         return SOFTBUS_LOCK_ERR;
     }
-    for (int32_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
         if (g_scanChannel[channelId].isUsed) {
             continue;
         }
@@ -525,11 +525,11 @@ static void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScan
 static void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
 {
     while (filterSize-- > 0) {
-        int32_t len = (nativeFilter + filterSize)->serviceDataLength;
+        uint32_t len = (nativeFilter + filterSize)->serviceDataLength;
         if (len <= 0) {
             continue;
         }
-        int32_t hexLen = HEXIFY_LEN(len);
+        uint32_t hexLen = HEXIFY_LEN(len);
         char *serviceData = (char *)SoftBusCalloc(sizeof(char) * hexLen);
         char *serviceDataMask = (char *)SoftBusCalloc(sizeof(char) * hexLen);
         if (serviceData == NULL || serviceDataMask == NULL) {
-- 
Gitee


From bad8bb98447c894c411d37ff924bf7091e1efa45 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 13:01:49 +0000
Subject: [PATCH 18/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/ble/src/softbus_ble_gatt.c       | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 351efac9ef..adea86f9a0 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -643,11 +643,11 @@ static int32_t StopScan(int32_t scannerId)
     return SOFTBUS_OK;
 }
 
-const SoftbusBroadcastMediumInterface *GetBroadcastMediumFunction(SoftbusMediumType type)
+void SoftbusBleAdapterInit()
 {
     static SoftbusBroadcastMediumInterface interface = {
-        .InitBroadcastAdapter = Init,
-        .DeInitBroadcastAdapter = DeInit,
+        .Init = Init,
+        .DeInit = DeInit,
         .RegisterBroadcaster = RegisterBroadcaster,
         .UnRegisterBroadcaster = UnRegisterBroadcaster,
         .RegisterScanListener = RegisterScanListener,
@@ -657,7 +657,9 @@ const SoftbusBroadcastMediumInterface *GetBroadcastMediumFunction(SoftbusMediumT
         .StartScan = StartScan,
         .StopScan = StopScan
     };
-    return &interface;
+    if (RegisterBroadcastMediumFunction(BROADCAST_MEDIUM_TYPE_BLE, &interface) != 0) {
+        CLOGW("Register gatt interface failed.");
+    }
 }
 
 bool SoftBusBcIsLpDeviceAvailable(void)
-- 
Gitee


From da1c372843e855662570219059ca14ff90948f47 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 13:02:17 +0000
Subject: [PATCH 19/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Fgatt.h.=20gatt=20ada?=
 =?UTF-8?q?pter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/ble/include/softbus_ble_gatt.h          | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
index 0230341f6d..8d54538fd4 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
@@ -31,6 +31,8 @@
 extern "C"{
 #endif
 
+void SoftbusBleAdapterInit(void);
+
 bool SoftBusBcIsLpDeviceAvailable(void);
 
 int32_t SoftBusBcEnableSyncDataToLpDevice(void);
@@ -46,4 +48,4 @@ int32_t SoftBusBcSetLpDeviceParam(int duration, int maxExtAdvEvents, int window,
 }
 #endif
 
-#endif /* SOFTBUS_BLE_GATT_H */
\ No newline at end of file
+#endif /* SOFTBUS_BLE_GATT_H */
-- 
Gitee


From 08caf7380e5cfb0d346f7264dda7c6c9541d1c35 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 13:02:45 +0000
Subject: [PATCH 20/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Finterfac?=
 =?UTF-8?q?e.h.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5?=
 =?UTF-8?q?=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1?=
 =?UTF-8?q?=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../include/softbus_broadcast_adapter_interface.h    | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
index d3d4b052a9..88cdcb3fe5 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
@@ -62,8 +62,8 @@ typedef struct {
  * @version 1.0
  */
 typedef struct {
-    int32_t (*InitBroadcastAdapter)(void);
-    int32_t (*DeInitBroadcastAdapter)(void);
+    int32_t (*Init)(void);
+    int32_t (*DeInit)(void);
     int32_t (*RegisterBroadcaster)(int32_t *advId, const SoftbusBroadcastCallback *cb);
     int32_t (*UnRegisterBroadcaster)(int32_t advId);
     int32_t (*RegisterScanListener)(int32_t *scannerId, const SoftbusScanCallback *cb);
@@ -76,16 +76,18 @@ typedef struct {
     int32_t (*StopScan)(int32_t scannerId);
 } SoftbusBroadcastMediumInterface;
 
+int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBroadcastMediumInterface *interface);
+
 /**
- * @brief Defines interface functions for registering different media
+ * @brief Defines interface functions for unregistering different media
  *
  * @since 1.0
  * @version 1.0
  */
-const SoftbusBroadcastMediumInterface *GetBroadcastMediumFunction(SoftbusMediumType type);
+int32_t UnRegisterBroadcastMediumFunction(SoftbusMediumType type);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* SOFTBUS_BROADCAST_ADAPTER_INTERFACE_H */
\ No newline at end of file
+#endif /* SOFTBUS_BROADCAST_ADAPTER_INTERFACE_H */
-- 
Gitee


From 94fb7d9e32a18db1aaf5a05f23d64290aca74e1d Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 13:30:42 +0000
Subject: [PATCH 21/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Finterfac?=
 =?UTF-8?q?e.h.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5?=
 =?UTF-8?q?=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1?=
 =?UTF-8?q?=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/include/softbus_broadcast_adapter_interface.h       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
index 88cdcb3fe5..b2a2f416b6 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
@@ -52,7 +52,7 @@ typedef struct {
 typedef struct {
     void (*OnStartScanCallback)(int32_t scanId, int32_t status);
     void (*OnStopScanCallback)(int32_t scanId, int32_t status);
-    void (*OnReportScanDataCallback)(int32_t scanId, const SoftBusBcScanResult *reportData);
+    void (*OnReportScanDataCallback)(const SoftBusBcScanResult *reportData);
 } SoftbusScanCallback;
 
 /**
-- 
Gitee


From 710ed882b7d892f156e957e0b8900c6d04fe3af4 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 27 Nov 2023 13:31:17 +0000
Subject: [PATCH 22/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index adea86f9a0..4bc7238321 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -291,7 +291,7 @@ static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
             continue;
         }
         if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnReportScanDataCallback != NULL) {
-            scanChannel->scanCallback->OnReportScanDataCallback(channelId, &sr);
+            scanChannel->scanCallback->OnReportScanDataCallback(&sr);
         }
         SoftBusMutexUnlock(&g_scannerLock);
     }
-- 
Gitee


From 7ea4ed7ffd0ae954851f55707f58e9ce92dd1f20 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Tue, 28 Nov 2023 10:54:27 +0000
Subject: [PATCH 23/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 224 +++++++++++-------
 1 file changed, 139 insertions(+), 85 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 4bc7238321..93d110ea3f 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -16,7 +16,6 @@
 #include "softbus_ble_gatt.h"
 #include "c_header/ohos_bt_gatt.h"
 #include "softbus_error_code.h"
-#include "adapter_bt_utils.h"
 #include "softbus_log_old.h"
 #include "softbus_utils.h"
 #include "softbus_adapter_thread.h"
@@ -42,20 +41,24 @@ typedef struct {
     SoftbusScanCallback *scanCallback;
 } ScanChannel;
 
-static AdvChannel g_advChannel[ADV_MAX_NUM];
-static ScanChannel g_scanChannel[SCAN_MAX_NUM];
+static AdvChannel g_advChannel[BC_ADV_MAX_NUM];
+static ScanChannel g_scanChannel[BC_SCAN_MAX_NUM];
 
 static int32_t Init(void)
 {
     if (g_init) {
+        CLOGI("already init");
         return SOFTBUS_OK;
     }
+    g_init = true;
     if (SoftBusMutexInit(&g_advLock, NULL) != SOFTBUS_OK) {
+        g_init = false;
         CLOGE("g_advLock init failed");
         return SOFTBUS_ERR;
     }
     if (SoftBusMutexInit(&g_scannerLock, NULL) != SOFTBUS_OK) {
         SoftBusMutexDestroy(&g_advLock);
+        g_init = false;
         CLOGE("g_scannerLock init failed");
         return SOFTBUS_ERR;
     }
@@ -66,6 +69,7 @@ static int32_t Init(void)
 static int32_t DeInit(void)
 {
     if (!g_init) {
+        CLOGI("already deInit");
         return SOFTBUS_OK;
     }
     g_init = false;
@@ -74,10 +78,57 @@ static int32_t DeInit(void)
     return SOFTBUS_OK;
 }
 
+static int32_t BleOhosStatusToSoftBus(BtStatus btStatus)
+{
+    int32_t status;
+    switch (btStatus) {
+        case OHOS_BT_STATUS_SUCCESS:
+            status = SOFTBUS_BC_STATUS_SUCCESS;
+            break;
+        case OHOS_BT_STATUS_FAIL:
+            status = SOFTBUS_BC_STATUS_FAIL;
+            break;
+        case OHOS_BT_STATUS_NOT_READY:
+            status = SOFTBUS_BC_STATUS_NOT_READY;
+            break;
+        case OHOS_BT_STATUS_NOMEM:
+            status = SOFTBUS_BC_STATUS_NOMEM;
+            break;
+        case OHOS_BT_STATUS_BUSY:
+            status = SOFTBUS_BC_STATUS_BUSY;
+            break;
+        case OHOS_BT_STATUS_DONE:
+            status = SOFTBUS_BC_STATUS_DONE;
+            break;
+        case OHOS_BT_STATUS_UNSUPPORTED:
+            status = SOFTBUS_BC_STATUS_UNSUPPORTED;
+            break;
+        case OHOS_BT_STATUS_PARM_INVALID:
+            status = SOFTBUS_BC_STATUS_PARM_INVALID;
+            break;
+        case OHOS_BT_STATUS_UNHANDLED:
+            status = SOFTBUS_BC_STATUS_UNHANDLED;
+            break;
+        case OHOS_BT_STATUS_AUTH_FAILURE:
+            status = SOFTBUS_BC_STATUS_AUTH_FAILURE;
+            break;
+        case OHOS_BT_STATUS_RMT_DEV_DOWN:
+            status = SOFTBUS_BC_STATUS_RMT_DEV_DOWN;
+            break;
+        case OHOS_BT_STATUS_AUTH_REJECTED:
+            status = SOFTBUS_BC_STATUS_AUTH_REJECTED;
+            break;
+        default:
+            status = SOFTBUS_BC_STATUS_FAIL;
+            break;
+    }
+    return status;
+}
+
 static void WrapperAdvEnableCallback(int advId, int status)
 {
     int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
-    for (uint8_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < BC_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             CLOGW("lock adv failed");
         }
@@ -86,8 +137,8 @@ static void WrapperAdvEnableCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        CLOGI("start adv callback, adv: %d, bt-advId: %d, status: %d", channelId, advId, st);
-        advChannel->isAdvertising = (st == SOFTBUS_BT_STATUS_SUCCESS);
+        CLOGI("start adv callback, adv: %u, bt-advId: %d, status: %d", channelId, advId, st);
+        advChannel->isAdvertising = (st == SOFTBUS_BC_STATUS_SUCCESS);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnStartBroadcastingCallback != NULL) {
             advChannel->advCallback->OnStartBroadcastingCallback(channelId, st);
         }
@@ -99,7 +150,7 @@ static void WrapperAdvEnableCallback(int advId, int status)
 static void WrapperAdvDisableCallback(int advId, int status)
 {
     int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
-    for (uint8_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < BC_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             CLOGW("lock adv failed");
         }
@@ -108,8 +159,8 @@ static void WrapperAdvDisableCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        CLOGI("stop adv callback, adv: %d, bt-advId: %d, status: %d", channelId, advId, st);
-        advChannel->isAdvertising = (st == SOFTBUS_BT_STATUS_SUCCESS);
+        CLOGI("stop adv callback, adv: %u, bt-advId: %d, status: %d", channelId, advId, st);
+        advChannel->isAdvertising = (st == SOFTBUS_BC_STATUS_SUCCESS);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnStopBroadcastingCallback != NULL) {
             advChannel->advCallback->OnStopBroadcastingCallback(channelId, st);
         }
@@ -126,17 +177,19 @@ static BtGattCallbacks g_softbusGattCb = {
 static int32_t RegisterBroadcaster(int32_t *advId, const SoftbusBroadcastCallback *cb)
 {
     if (advId == NULL || cb == NULL) {
+        CLOGE("invalid param");
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+        CLOGE("lock failed");
         return SOFTBUS_LOCK_ERR;
     }
-    for (uint8_t channelId = 0; channelId < ADV_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < BC_ADV_MAX_NUM; channelId++) {
         if (g_advChannel[channelId].isUsed) {
             continue;
         }
         if (BleGattRegisterCallbacks(&g_softbusGattCb) != OHOS_BT_STATUS_SUCCESS) {
-            CLOGE("register adv cb failed: %d", channelId);
+            CLOGE("register adv cb failed: %u", channelId);
             SoftBusMutexUnlock(&g_advLock);
             return SOFTBUS_ERR;
         }
@@ -155,10 +208,12 @@ static int32_t RegisterBroadcaster(int32_t *advId, const SoftbusBroadcastCallbac
 
 static int32_t UnRegisterBroadcaster(int32_t advId)
 {
-    if (advId < 0 || advId >= ADV_MAX_NUM) {
+    if (advId < 0 || advId >= BC_ADV_MAX_NUM) {
+        CLOGE("invalid advId: %d", advId);
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+        CLOGE("lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!g_advChannel[advId].isUsed) {
@@ -177,31 +232,31 @@ static uint8_t ConvertScanEventType(unsigned char eventType)
 {
     switch (eventType) {
         case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE:
-            return SOFTBUS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE;
+            return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE;
         case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED:
-            return SOFTBUS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
+            return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
         case OHOS_BLE_EVT_CONNECTABLE:
-            return SOFTBUS_BLE_EVT_CONNECTABLE;
+            return SOFTBUS_BC_EVT_CONNECTABLE;
         case OHOS_BLE_EVT_CONNECTABLE_DIRECTED:
-            return SOFTBUS_BLE_EVT_CONNECTABLE_DIRECTED;
+            return SOFTBUS_BC_EVT_CONNECTABLE_DIRECTED;
         case OHOS_BLE_EVT_SCANNABLE:
-            return SOFTBUS_BLE_EVT_SCANNABLE;
+            return SOFTBUS_BC_EVT_SCANNABLE;
         case OHOS_BLE_EVT_SCANNABLE_DIRECTED:
-            return SOFTBUS_BLE_EVT_SCANNABLE_DIRECTED;
+            return SOFTBUS_BC_EVT_SCANNABLE_DIRECTED;
         case OHOS_BLE_EVT_LEGACY_NON_CONNECTABLE:
-            return SOFTBUS_BLE_EVT_LEGACY_NON_CONNECTABLE;
+            return SOFTBUS_BC_EVT_LEGACY_NON_CONNECTABLE;
         case OHOS_BLE_EVT_LEGACY_SCANNABLE:
-            return SOFTBUS_BLE_EVT_LEGACY_SCANNABLE;
+            return SOFTBUS_BC_EVT_LEGACY_SCANNABLE;
         case OHOS_BLE_EVT_LEGACY_CONNECTABLE:
-            return SOFTBUS_BLE_EVT_LEGACY_CONNECTABLE;
+            return SOFTBUS_BC_EVT_LEGACY_CONNECTABLE;
         case OHOS_BLE_EVT_LEGACY_CONNECTABLE_DIRECTED:
-            return SOFTBUS_BLE_EVT_LEGACY_CONNECTABLE_DIRECTED;
+            return SOFTBUS_BC_EVT_LEGACY_CONNECTABLE_DIRECTED;
         case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN:
-            return SOFTBUS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN;
+            return SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN;
         case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV:
-            return SOFTBUS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV;
+            return SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV;
         default:
-            return SOFTBUS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE;
+            return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE;
     }
 }
 
@@ -209,13 +264,13 @@ static uint8_t ConvertScanDataStatus(unsigned char dataStatus)
 {
     switch (dataStatus) {
         case OHOS_BLE_DATA_COMPLETE:
-            return SOFTBUS_BLE_DATA_COMPLETE;
+            return SOFTBUS_BC_DATA_COMPLETE;
         case OHOS_BLE_DATA_INCOMPLETE_MORE_TO_COME:
-            return SOFTBUS_BLE_DATA_INCOMPLETE_MORE_TO_COME;
+            return SOFTBUS_BC_DATA_INCOMPLETE_MORE_TO_COME;
         case OHOS_BLE_DATA_INCOMPLETE_TRUNCATED:
-            return SOFTBUS_BLE_DATA_INCOMPLETE_TRUNCATED;
+            return SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED;
         default:
-            return SOFTBUS_BLE_DATA_INCOMPLETE_TRUNCATED;
+            return SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED;
     }
 }
 
@@ -223,19 +278,19 @@ static uint8_t ConvertScanAddrType(unsigned char addrType)
 {
     switch (addrType) {
         case OHOS_BLE_PUBLIC_DEVICE_ADDRESS:
-            return SOFTBUS_BLE_PUBLIC_DEVICE_ADDRESS;
+            return SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
         case OHOS_BLE_RANDOM_DEVICE_ADDRESS:
-            return SOFTBUS_BLE_RANDOM_DEVICE_ADDRESS;
+            return SOFTBUS_BC_RANDOM_DEVICE_ADDRESS;
         case OHOS_BLE_PUBLIC_IDENTITY_ADDRESS:
-            return SOFTBUS_BLE_PUBLIC_IDENTITY_ADDRESS;
+            return SOFTBUS_BC_PUBLIC_IDENTITY_ADDRESS;
         case OHOS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS:
-            return SOFTBUS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS;
+            return SOFTBUS_BC_RANDOM_STATIC_IDENTITY_ADDRESS;
         case OHOS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS:
-            return SOFTBUS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS;
+            return SOFTBUS_BC_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS;
         case OHOS_BLE_NO_ADDRESS:
-            return SOFTBUS_BLE_NO_ADDRESS;
+            return SOFTBUS_BC_NO_ADDRESS;
         default:
-            return SOFTBUS_BLE_NO_ADDRESS;
+            return SOFTBUS_BC_NO_ADDRESS;
     }
 }
 
@@ -243,15 +298,15 @@ static uint8_t ConvertScanPhyType(unsigned char phyType)
 {
     switch (phyType) {
         case OHOS_BLE_SCAN_PHY_NO_PACKET:
-            return SOFTBUS_BLE_SCAN_PHY_NO_PACKET;
+            return SOFTBUS_BC_SCAN_PHY_NO_PACKET;
         case OHOS_BLE_SCAN_PHY_1M:
-            return SOFTBUS_BLE_SCAN_PHY_1M;
+            return SOFTBUS_BC_SCAN_PHY_1M;
         case OHOS_BLE_SCAN_PHY_2M:
-            return SOFTBUS_BLE_SCAN_PHY_2M;
+            return SOFTBUS_BC_SCAN_PHY_2M;
         case OHOS_BLE_SCAN_PHY_CODED:
-            return SOFTBUS_BLE_SCAN_PHY_CODED;
+            return SOFTBUS_BC_SCAN_PHY_CODED;
         default:
-            return SOFTBUS_BLE_SCAN_PHY_NO_PACKET;
+            return SOFTBUS_BC_SCAN_PHY_NO_PACKET;
     }
 }
 
@@ -260,8 +315,8 @@ static void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *
     dst->eventType = ConvertScanEventType(src->eventType);
     dst->dataStatus = ConvertScanDataStatus(src->dataStatus);
     dst->addrType = ConvertScanAddrType(src->addrType);
-    if (memcpy_s(dst->addr.addr, BT_ADDR_LEN, src->addr.addr, BT_ADDR_LEN) != EOK) {
-        CLOGE("copy addr failed");
+    if (memcpy_s(dst->addr.addr, SOFTBUS_ADDR_MAC_LEN, src->addr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
+        CLOGW("copy addr failed");
     }
     dst->primaryPhy = ConvertScanPhyType(src->primaryPhy);
     dst->secondaryPhy = ConvertScanPhyType(src->secondaryPhy);
@@ -270,18 +325,19 @@ static void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *
     dst->rssi = (int8_t)src->rssi;
     dst->data.rawDataLen = (uint16_t)src->advLen;
     if (memcpy_s(dst->data.rawData, dst->data.rawDataLen, src->advData, dst->data.rawDataLen) != EOK) {
-        CLOGE("copy adv data failed");
+        CLOGW("copy adv data failed");
     }
 }
 
 static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
 {
     if (scanResultdata == NULL) {
+        CLOGE("scanResultdata is null");
         return;
     }
     SoftBusBcScanResult sr;
     ConvertScanResult(scanResultdata, &sr);
-    for (uint8_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < BC_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
             CLOGW("lock scan failed");
         }
@@ -300,7 +356,7 @@ static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
 static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
 {
     int32_t st = BleOhosStatusToSoftBus((BtStatus)resultCode);
-    for (uint8_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < BC_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
             CLOGW("lock scan failed");
         }
@@ -318,9 +374,9 @@ static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
             scanChannel->scanCallback->OnStopScanCallback(channelId, st);
         }
         if (isStartScan) {
-            scanChannel->isScanning = (st == SOFTBUS_BT_STATUS_SUCCESS);
+            scanChannel->isScanning = (st == SOFTBUS_BC_STATUS_SUCCESS);
         } else {
-            scanChannel->isScanning = !(st == SOFTBUS_BT_STATUS_SUCCESS);
+            scanChannel->isScanning = !(st == SOFTBUS_BC_STATUS_SUCCESS);
         }
         SoftBusMutexUnlock(&g_scannerLock);
     }
@@ -334,12 +390,14 @@ static BleScanCallbacks g_softbusBleScanCb = {
 static int32_t RegisterScanListener(int32_t *scannerId, const SoftbusScanCallback *cb)
 {
     if (scannerId == NULL || cb == NULL) {
+        CLOGE("invalid param");
         return SOFTBUS_ERR;
     }
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        CLOGE("lock failed");
         return SOFTBUS_LOCK_ERR;
     }
-    for (uint8_t channelId = 0; channelId < SCAN_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < BC_SCAN_MAX_NUM; channelId++) {
         if (g_scanChannel[channelId].isUsed) {
             continue;
         }
@@ -363,10 +421,12 @@ static int32_t RegisterScanListener(int32_t *scannerId, const SoftbusScanCallbac
 
 static int32_t UnRegisterScanListener(int32_t scannerId)
 {
-    if (scannerId < 0 || scannerId >= SCAN_MAX_NUM) {
+    if (scannerId < 0 || scannerId >= BC_SCAN_MAX_NUM) {
+        CLOGE("invalid scannerId: %d", scannerId);
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        CLOGE("lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!g_scanChannel[scannerId].isUsed) {
@@ -383,15 +443,15 @@ static int32_t UnRegisterScanListener(int32_t scannerId)
 static BleAdvType ConvertAdvType(uint8_t advType)
 {
     switch (advType) {
-        case SOFTBUS_BLE_ADV_IND:
+        case SOFTBUS_BC_ADV_IND:
             return OHOS_BLE_ADV_IND;
-        case SOFTBUS_BLE_ADV_DIRECT_IND_HIGH:
+        case SOFTBUS_BC_ADV_DIRECT_IND_HIGH:
             return OHOS_BLE_ADV_DIRECT_IND_HIGH;
-        case SOFTBUS_BLE_ADV_SCAN_IND:
+        case SOFTBUS_BC_ADV_SCAN_IND:
             return OHOS_BLE_ADV_SCAN_IND;
-        case SOFTBUS_BLE_ADV_NONCONN_IND:
+        case SOFTBUS_BC_ADV_NONCONN_IND:
             return OHOS_BLE_ADV_NONCONN_IND;
-        case SOFTBUS_BLE_ADV_DIRECT_IND_LOW:
+        case SOFTBUS_BC_ADV_DIRECT_IND_LOW:
             return OHOS_BLE_ADV_DIRECT_IND_LOW;
         default:
             return OHOS_BLE_ADV_IND;
@@ -401,13 +461,13 @@ static BleAdvType ConvertAdvType(uint8_t advType)
 static BleAdvFilter ConvertAdvFilter(uint8_t advFilter)
 {
     switch (advFilter) {
-        case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY:
+        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY:
             return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
-        case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY:
+        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY:
             return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY;
-        case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST:
+        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST:
             return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST;
-        case SOFTBUS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST:
+        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST:
             return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST;
         default:
             return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
@@ -417,8 +477,7 @@ static BleAdvFilter ConvertAdvFilter(uint8_t advFilter)
 static void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst)
 {
     if (memcpy_s(dst->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN, src->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
-        CLOGE("copy peer addr failed");
-        return;
+        CLOGW("copy peer addr failed");
     }
     dst->minInterval = src->minInterval;
     dst->maxInterval = src->maxInterval;
@@ -433,7 +492,8 @@ static void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst)
 
 static bool CheckAdvChannelInUsed(int32_t advId)
 {
-    if (advId < 0 || advId >= ADV_MAX_NUM) {
+    if (advId < 0 || advId >= BC_ADV_MAX_NUM) {
+        CLOGE("invalid advId: %d", advId);
         return false;
     }
     if (!g_advChannel[advId].isUsed) {
@@ -447,9 +507,11 @@ static int32_t StartBroadcasting(int32_t advId, const SoftbusBroadcastParam *par
     const SoftbusBroadcastData *rspData)
 {
     if (param == NULL || bcData == NULL || rspData == NULL) {
+        CLOGE("invalid param");
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+        CLOGE("lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
@@ -457,7 +519,6 @@ static int32_t StartBroadcasting(int32_t advId, const SoftbusBroadcastParam *par
         return SOFTBUS_ERR;
     }
     if (g_advChannel[advId].isAdvertising) {
-        CLOGW("adv %d already started", advId);
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_OK;
     }
@@ -470,7 +531,7 @@ static int32_t StartBroadcasting(int32_t advId, const SoftbusBroadcastParam *par
         .rspData = rspData->rawData,
     };
     if (BleStartAdvEx(&g_advChannel[advId].advId, advData, advParam) != OHOS_BT_STATUS_SUCCESS) {
-        CLOGI("adv: %d, start adv failed", advId);
+        CLOGI("start adv failed");
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
@@ -482,23 +543,19 @@ static int32_t StartBroadcasting(int32_t advId, const SoftbusBroadcastParam *par
 static int32_t StopBroadcasting(int32_t advId)
 {
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+        CLOGE("lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
-    if (!g_advChannel[advId].isAdvertising) {
-        SoftBusMutexUnlock(&g_advLock);
-        CLOGI("adv %d is not advertising", g_advChannel[advId].advId);
-        return SOFTBUS_OK;
-    }
+    g_advChannel[advId].isAdvertising = false;
     if (BleStopAdv(g_advChannel[advId].advId) != OHOS_BT_STATUS_SUCCESS) {
         SoftBusMutexUnlock(&g_advLock);
         CLOGI("adv: %d, stop adv failed", advId);
         return SOFTBUS_ERR;
     }
-    g_advChannel[advId].isAdvertising = false;
     SoftBusMutexUnlock(&g_advLock);
     return SOFTBUS_OK;
 }
@@ -526,7 +583,7 @@ static void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterS
 {
     while (filterSize-- > 0) {
         uint32_t len = (nativeFilter + filterSize)->serviceDataLength;
-        if (len <= 0) {
+        if (len == 0) {
             continue;
         }
         uint32_t hexLen = HEXIFY_LEN(len);
@@ -539,7 +596,7 @@ static void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterS
         }
         (void)ConvertBytesToHexString(serviceData, hexLen, (nativeFilter + filterSize)->serviceData, len);
         (void)ConvertBytesToHexString(serviceDataMask, hexLen, (nativeFilter + filterSize)->serviceDataMask, len);
-        CLOGI("BLE Scan Filter size:%d [serviceData:%s, serviceDataMask:%s]",
+        CLOGI("BLE Scan Filter size:%u [serviceData:%s, serviceDataMask:%s]",
             filterSize, serviceData, serviceDataMask);
         SoftBusFree(serviceData);
         SoftBusFree(serviceDataMask);
@@ -548,16 +605,16 @@ static void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterS
 
 static int GetScanMode(uint16_t scanInterval, uint16_t scanWindow)
 {
-    if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P2 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P2) {
+    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P2 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P2) {
         return OHOS_BLE_SCAN_MODE_OP_P2_60_3000;
     }
-    if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P10 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P10) {
+    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P10 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P10) {
         return OHOS_BLE_SCAN_MODE_OP_P10_60_600;
     }
-    if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P25 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P25) {
+    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P25 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P25) {
         return OHOS_BLE_SCAN_MODE_OP_P25_60_240;
     }
-    if (scanInterval == SOFTBUS_BLE_SCAN_INTERVAL_P100 && scanWindow == SOFTBUS_BLE_SCAN_WINDOW_P100) {
+    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P100 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P100) {
         return OHOS_BLE_SCAN_MODE_OP_P100_1000_1000;
     }
     return OHOS_BLE_SCAN_MODE_LOW_POWER;
@@ -565,7 +622,8 @@ static int GetScanMode(uint16_t scanInterval, uint16_t scanWindow)
 
 static bool CheckScanChannelInUsed(int32_t scannerId)
 {
-    if (scannerId < 0 || scannerId >= SCAN_MAX_NUM) {
+    if (scannerId < 0 || scannerId >= BC_SCAN_MAX_NUM) {
+        CLOGE("invalid scannerId: %d", scannerId);
         return false;
     }
     if (!g_scanChannel[scannerId].isUsed) {
@@ -579,19 +637,19 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     uint8_t filterSize)
 {
     if (param == NULL || scanFilter == NULL || filterSize == 0) {
+        CLOGE("invalid param");
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        CLOGE("lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
         SoftBusMutexUnlock(&g_scannerLock);
-        CLOGE("ScanChannel id:%d is not in use", scannerId);
         return SOFTBUS_ERR;
     }
     if (g_scanChannel[scannerId].isScanning) {
         SoftBusMutexUnlock(&g_scannerLock);
-        CLOGI("scan %d is already scanning", scannerId);
         return SOFTBUS_OK;
     }
     BleScanNativeFilter *nativeFilter =
@@ -622,23 +680,19 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
 static int32_t StopScan(int32_t scannerId)
 {
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        CLOGE("lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_ERR;
     }
-    if (!g_scanChannel[scannerId].isScanning) {
-        SoftBusMutexUnlock(&g_scannerLock);
-        CLOGI("scan %d is not scanning", scannerId);
-        return SOFTBUS_OK;
-    }
+    g_scanChannel[scannerId].isScanning = false;
     if (BleStopScan(g_scanChannel[scannerId].scannerId) != OHOS_BT_STATUS_SUCCESS) {
         SoftBusMutexUnlock(&g_scannerLock);
         CLOGE("scan %d, stop scan failed", scannerId);
         return SOFTBUS_ERR;
     }
-    g_scanChannel[scannerId].isScanning = false;
     SoftBusMutexUnlock(&g_scannerLock);
     return SOFTBUS_OK;
 }
-- 
Gitee


From ae71a1e708f557044b792e7a715cb9397bc112b7 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Tue, 28 Nov 2023 10:55:32 +0000
Subject: [PATCH 24/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Ftype.h.?=
 =?UTF-8?q?=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3?=
 =?UTF-8?q?=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86?=
 =?UTF-8?q?=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../include/softbus_broadcast_adapter_type.h  | 88 +++++++++++++++++--
 1 file changed, 81 insertions(+), 7 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
index 6b0ad69f2a..ef1f8434df 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
@@ -30,13 +30,20 @@
 extern "C"{
 #endif
 
-/**
- * @brief Defines mac address length
- *
- * @since 1.0
- * @version 1.0
- */
 #define SOFTBUS_ADDR_MAC_LEN 6
+// max adv and scan limit
+#define BC_ADV_MAX_NUM 16
+#define BC_SCAN_MAX_NUM 16
+
+// Bluetooth scan duty cycle, unit: ms
+#define SOFTBUS_BC_SCAN_INTERVAL_P2 3000
+#define SOFTBUS_BC_SCAN_INTERVAL_P10 600
+#define SOFTBUS_BC_SCAN_INTERVAL_P25 240
+#define SOFTBUS_BC_SCAN_INTERVAL_P100 1000
+#define SOFTBUS_BC_SCAN_WINDOW_P2 60
+#define SOFTBUS_BC_SCAN_WINDOW_P10 60
+#define SOFTBUS_BC_SCAN_WINDOW_P25 60
+#define SOFTBUS_BC_SCAN_WINDOW_P100 1000
 
 /**
  * @brief Defines different broadcast media protocol stacks
@@ -50,6 +57,73 @@ typedef enum {
     BROADCAST_MEDIUM_TYPE_BUTT,
 } SoftbusMediumType;
 
+typedef enum {
+    SOFTBUS_BC_STATUS_SUCCESS = 0x00,
+    SOFTBUS_BC_STATUS_FAIL,
+    SOFTBUS_BC_STATUS_NOT_READY,
+    SOFTBUS_BC_STATUS_NOMEM,
+    SOFTBUS_BC_STATUS_BUSY,
+    SOFTBUS_BC_STATUS_DONE,
+    SOFTBUS_BC_STATUS_UNSUPPORTED,
+    SOFTBUS_BC_STATUS_PARM_INVALID,
+    SOFTBUS_BC_STATUS_UNHANDLED,
+    SOFTBUS_BC_STATUS_AUTH_FAILURE,
+    SOFTBUS_BC_STATUS_RMT_DEV_DOWN,
+    SOFTBUS_BC_STATUS_AUTH_REJECTED
+} SoftBusBtStatus;
+
+typedef enum {
+    SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE = 0x00,
+    SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED = 0x04,
+    SOFTBUS_BC_EVT_CONNECTABLE = 0x01,
+    SOFTBUS_BC_EVT_CONNECTABLE_DIRECTED = 0x05,
+    SOFTBUS_BC_EVT_SCANNABLE = 0x02,
+    SOFTBUS_BC_EVT_SCANNABLE_DIRECTED = 0x06,
+    SOFTBUS_BC_EVT_LEGACY_NON_CONNECTABLE = 0x10,
+    SOFTBUS_BC_EVT_LEGACY_SCANNABLE = 0x12,
+    SOFTBUS_BC_EVT_LEGACY_CONNECTABLE = 0x13,
+    SOFTBUS_BC_EVT_LEGACY_CONNECTABLE_DIRECTED = 0x15,
+    SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN = 0x1A,
+    SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV = 0x1B
+} SoftBusBcScanResultEvtType;
+
+typedef enum {
+    SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS = 0x00,
+    SOFTBUS_BC_RANDOM_DEVICE_ADDRESS = 0x01,
+    SOFTBUS_BC_PUBLIC_IDENTITY_ADDRESS = 0x02,
+    SOFTBUS_BC_RANDOM_STATIC_IDENTITY_ADDRESS = 0x03,
+    SOFTBUS_BC_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS = 0xFE,
+    SOFTBUS_BC_NO_ADDRESS = 0xFF,
+} SoftBusBcScanResultAddrType;
+
+typedef enum {
+    SOFTBUS_BC_DATA_COMPLETE = 0x00,
+    SOFTBUS_BC_DATA_INCOMPLETE_MORE_TO_COME = 0x01,
+    SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED = 0x02,
+} SoftBusBcScanResultDataStatus;
+
+typedef enum {
+    SOFTBUS_BC_SCAN_PHY_NO_PACKET = 0x00,
+    SOFTBUS_BC_SCAN_PHY_1M = 0x01,
+    SOFTBUS_BC_SCAN_PHY_2M = 0x02,
+    SOFTBUS_BC_SCAN_PHY_CODED = 0x03
+} SoftBusBcScanResultPhyType;
+
+typedef enum {
+    SOFTBUS_BC_ADV_IND = 0x00,
+    SOFTBUS_BC_ADV_DIRECT_IND_HIGH = 0x01,
+    SOFTBUS_BC_ADV_SCAN_IND = 0x02,
+    SOFTBUS_BC_ADV_NONCONN_IND = 0x03,
+    SOFTBUS_BC_ADV_DIRECT_IND_LOW  = 0x04,
+} SoftBusBcAdvType;
+
+typedef enum {
+    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY = 0x00,
+    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY = 0x01,
+    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST = 0x02,
+    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST = 0x03,
+} SoftBusBcAdvFilter;
+
 /**
  * @brief Defines the broadcast data information
  *
@@ -148,4 +222,4 @@ typedef struct {
 }
 #endif
 
-#endif /* SOFTBUS_BROADCAST_ADAPTER_TYPE_H */
\ No newline at end of file
+#endif /* SOFTBUS_BROADCAST_ADAPTER_TYPE_H */
-- 
Gitee


From 9981ec4865aba4f97991e0bc88da7a54ce36c012 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Tue, 28 Nov 2023 10:56:02 +0000
Subject: [PATCH 25/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/net?=
 =?UTF-8?q?=5Fbluetooth.gni.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91?=
 =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4?=
 =?UTF-8?q?=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 adapter/common/net/bluetooth/net_bluetooth.gni | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/adapter/common/net/bluetooth/net_bluetooth.gni b/adapter/common/net/bluetooth/net_bluetooth.gni
index 307e402fa6..3afb89cb19 100644
--- a/adapter/common/net/bluetooth/net_bluetooth.gni
+++ b/adapter/common/net/bluetooth/net_bluetooth.gni
@@ -18,6 +18,7 @@ adapter_ble_inc = [
   "$dsoftbus_root_path/core/common/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/interface",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/include",
 ]
@@ -28,6 +29,7 @@ adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/adapter_bt_utils.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c",
 ]
 adapter_net_br_src = [ "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c" ]
 adapter_ble_external_deps = [ "bluetooth:btframework" ]
-- 
Gitee


From 5d818df988a3ab03d0da311afab03e4f34e6a5c6 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Tue, 28 Nov 2023 10:56:24 +0000
Subject: [PATCH 26/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/manager/src/softbus=5Fbroadcast=5Fmgr.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/manager/src/softbus_broadcast_mgr.c          | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
index b5f23358c3..7f17cf3aa1 100644
--- a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
+++ b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
@@ -14,9 +14,16 @@
  */
 
 #include "softbus_broadcast_manager.h"
+#include "softbus_broadcast_adapter_interface.h"
 #include "softbus_broadcast_type.h"
+#include "softbus_error_code.h"
 
 int32_t InitBroadcastMgr(void)
+{
+    return SOFTBUS_OK;
+}
+
+int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBroadcastMediumInterface *interface)
 {
     return SOFTBUS_OK;
 }
\ No newline at end of file
-- 
Gitee


From 731bded33f299eb94f74ceafa0090e2f5087a3a8 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Tue, 28 Nov 2023 11:12:26 +0000
Subject: [PATCH 27/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c    | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 93d110ea3f..002c123ba1 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -131,6 +131,7 @@ static void WrapperAdvEnableCallback(int advId, int status)
     for (uint8_t channelId = 0; channelId < BC_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             CLOGW("lock adv failed");
+            continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
         if (advChannel->advId != advId || !advChannel->isUsed) {
@@ -153,6 +154,7 @@ static void WrapperAdvDisableCallback(int advId, int status)
     for (uint8_t channelId = 0; channelId < BC_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             CLOGW("lock adv failed");
+            continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
         if (advChannel->advId != advId || !advChannel->isUsed) {
@@ -340,6 +342,7 @@ static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
     for (uint8_t channelId = 0; channelId < BC_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
             CLOGW("lock scan failed");
+            continue;
         }
         ScanChannel *scanChannel = &g_scanChannel[channelId];
         if (!scanChannel->isUsed || !scanChannel->isScanning) {
@@ -359,6 +362,7 @@ static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
     for (uint8_t channelId = 0; channelId < BC_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
             CLOGW("lock scan failed");
+            continue;
         }
         ScanChannel *scanChannel = &g_scanChannel[channelId];
         if (!scanChannel->isUsed || !scanChannel->isScanning) {
-- 
Gitee


From f3c257faa25435eacfd29e64114cdb4239b1a47e Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 01:52:53 +0000
Subject: [PATCH 28/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 294 ++----------------
 1 file changed, 20 insertions(+), 274 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 002c123ba1..d102d53204 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -18,11 +18,15 @@
 #include "softbus_error_code.h"
 #include "softbus_log_old.h"
 #include "softbus_utils.h"
+#include "softbus_ble_utils.h"
 #include "softbus_adapter_thread.h"
 #include "softbus_adapter_mem.h"
-#include <securec.h>
+#include "softbus_broadcast_type.h"
 #include <stdatomic.h>
 
+#define GATT_ADV_MAX_NUM 9
+#define GATT_SCAN_MAX_NUM 9
+
 static atomic_bool g_init = false;
 static SoftBusMutex g_advLock = {0};
 static SoftBusMutex g_scannerLock = {0};
@@ -41,8 +45,8 @@ typedef struct {
     SoftbusScanCallback *scanCallback;
 } ScanChannel;
 
-static AdvChannel g_advChannel[BC_ADV_MAX_NUM];
-static ScanChannel g_scanChannel[BC_SCAN_MAX_NUM];
+static AdvChannel g_advChannel[GATT_ADV_MAX_NUM];
+static ScanChannel g_scanChannel[GATT_SCAN_MAX_NUM];
 
 static int32_t Init(void)
 {
@@ -78,57 +82,10 @@ static int32_t DeInit(void)
     return SOFTBUS_OK;
 }
 
-static int32_t BleOhosStatusToSoftBus(BtStatus btStatus)
-{
-    int32_t status;
-    switch (btStatus) {
-        case OHOS_BT_STATUS_SUCCESS:
-            status = SOFTBUS_BC_STATUS_SUCCESS;
-            break;
-        case OHOS_BT_STATUS_FAIL:
-            status = SOFTBUS_BC_STATUS_FAIL;
-            break;
-        case OHOS_BT_STATUS_NOT_READY:
-            status = SOFTBUS_BC_STATUS_NOT_READY;
-            break;
-        case OHOS_BT_STATUS_NOMEM:
-            status = SOFTBUS_BC_STATUS_NOMEM;
-            break;
-        case OHOS_BT_STATUS_BUSY:
-            status = SOFTBUS_BC_STATUS_BUSY;
-            break;
-        case OHOS_BT_STATUS_DONE:
-            status = SOFTBUS_BC_STATUS_DONE;
-            break;
-        case OHOS_BT_STATUS_UNSUPPORTED:
-            status = SOFTBUS_BC_STATUS_UNSUPPORTED;
-            break;
-        case OHOS_BT_STATUS_PARM_INVALID:
-            status = SOFTBUS_BC_STATUS_PARM_INVALID;
-            break;
-        case OHOS_BT_STATUS_UNHANDLED:
-            status = SOFTBUS_BC_STATUS_UNHANDLED;
-            break;
-        case OHOS_BT_STATUS_AUTH_FAILURE:
-            status = SOFTBUS_BC_STATUS_AUTH_FAILURE;
-            break;
-        case OHOS_BT_STATUS_RMT_DEV_DOWN:
-            status = SOFTBUS_BC_STATUS_RMT_DEV_DOWN;
-            break;
-        case OHOS_BT_STATUS_AUTH_REJECTED:
-            status = SOFTBUS_BC_STATUS_AUTH_REJECTED;
-            break;
-        default:
-            status = SOFTBUS_BC_STATUS_FAIL;
-            break;
-    }
-    return status;
-}
-
 static void WrapperAdvEnableCallback(int advId, int status)
 {
-    int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
-    for (uint8_t channelId = 0; channelId < BC_ADV_MAX_NUM; channelId++) {
+    int32_t st = OhosStatusToSoftBus((BtStatus)status);
+    for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             CLOGW("lock adv failed");
             continue;
@@ -150,8 +107,8 @@ static void WrapperAdvEnableCallback(int advId, int status)
 
 static void WrapperAdvDisableCallback(int advId, int status)
 {
-    int32_t st = BleOhosStatusToSoftBus((BtStatus)status);
-    for (uint8_t channelId = 0; channelId < BC_ADV_MAX_NUM; channelId++) {
+    int32_t st = OhosStatusToSoftBus((BtStatus)status);
+    for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             CLOGW("lock adv failed");
             continue;
@@ -186,7 +143,7 @@ static int32_t RegisterBroadcaster(int32_t *advId, const SoftbusBroadcastCallbac
         CLOGE("lock failed");
         return SOFTBUS_LOCK_ERR;
     }
-    for (uint8_t channelId = 0; channelId < BC_ADV_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (g_advChannel[channelId].isUsed) {
             continue;
         }
@@ -210,7 +167,7 @@ static int32_t RegisterBroadcaster(int32_t *advId, const SoftbusBroadcastCallbac
 
 static int32_t UnRegisterBroadcaster(int32_t advId)
 {
-    if (advId < 0 || advId >= BC_ADV_MAX_NUM) {
+    if (advId < 0 || advId >= GATT_ADV_MAX_NUM) {
         CLOGE("invalid advId: %d", advId);
         return SOFTBUS_INVALID_PARAM;
     }
@@ -230,107 +187,6 @@ static int32_t UnRegisterBroadcaster(int32_t advId)
     return SOFTBUS_OK;
 }
 
-static uint8_t ConvertScanEventType(unsigned char eventType)
-{
-    switch (eventType) {
-        case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE:
-            return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE;
-        case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED:
-            return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
-        case OHOS_BLE_EVT_CONNECTABLE:
-            return SOFTBUS_BC_EVT_CONNECTABLE;
-        case OHOS_BLE_EVT_CONNECTABLE_DIRECTED:
-            return SOFTBUS_BC_EVT_CONNECTABLE_DIRECTED;
-        case OHOS_BLE_EVT_SCANNABLE:
-            return SOFTBUS_BC_EVT_SCANNABLE;
-        case OHOS_BLE_EVT_SCANNABLE_DIRECTED:
-            return SOFTBUS_BC_EVT_SCANNABLE_DIRECTED;
-        case OHOS_BLE_EVT_LEGACY_NON_CONNECTABLE:
-            return SOFTBUS_BC_EVT_LEGACY_NON_CONNECTABLE;
-        case OHOS_BLE_EVT_LEGACY_SCANNABLE:
-            return SOFTBUS_BC_EVT_LEGACY_SCANNABLE;
-        case OHOS_BLE_EVT_LEGACY_CONNECTABLE:
-            return SOFTBUS_BC_EVT_LEGACY_CONNECTABLE;
-        case OHOS_BLE_EVT_LEGACY_CONNECTABLE_DIRECTED:
-            return SOFTBUS_BC_EVT_LEGACY_CONNECTABLE_DIRECTED;
-        case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN:
-            return SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN;
-        case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV:
-            return SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV;
-        default:
-            return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE;
-    }
-}
-
-static uint8_t ConvertScanDataStatus(unsigned char dataStatus)
-{
-    switch (dataStatus) {
-        case OHOS_BLE_DATA_COMPLETE:
-            return SOFTBUS_BC_DATA_COMPLETE;
-        case OHOS_BLE_DATA_INCOMPLETE_MORE_TO_COME:
-            return SOFTBUS_BC_DATA_INCOMPLETE_MORE_TO_COME;
-        case OHOS_BLE_DATA_INCOMPLETE_TRUNCATED:
-            return SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED;
-        default:
-            return SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED;
-    }
-}
-
-static uint8_t ConvertScanAddrType(unsigned char addrType)
-{
-    switch (addrType) {
-        case OHOS_BLE_PUBLIC_DEVICE_ADDRESS:
-            return SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
-        case OHOS_BLE_RANDOM_DEVICE_ADDRESS:
-            return SOFTBUS_BC_RANDOM_DEVICE_ADDRESS;
-        case OHOS_BLE_PUBLIC_IDENTITY_ADDRESS:
-            return SOFTBUS_BC_PUBLIC_IDENTITY_ADDRESS;
-        case OHOS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS:
-            return SOFTBUS_BC_RANDOM_STATIC_IDENTITY_ADDRESS;
-        case OHOS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS:
-            return SOFTBUS_BC_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS;
-        case OHOS_BLE_NO_ADDRESS:
-            return SOFTBUS_BC_NO_ADDRESS;
-        default:
-            return SOFTBUS_BC_NO_ADDRESS;
-    }
-}
-
-static uint8_t ConvertScanPhyType(unsigned char phyType)
-{
-    switch (phyType) {
-        case OHOS_BLE_SCAN_PHY_NO_PACKET:
-            return SOFTBUS_BC_SCAN_PHY_NO_PACKET;
-        case OHOS_BLE_SCAN_PHY_1M:
-            return SOFTBUS_BC_SCAN_PHY_1M;
-        case OHOS_BLE_SCAN_PHY_2M:
-            return SOFTBUS_BC_SCAN_PHY_2M;
-        case OHOS_BLE_SCAN_PHY_CODED:
-            return SOFTBUS_BC_SCAN_PHY_CODED;
-        default:
-            return SOFTBUS_BC_SCAN_PHY_NO_PACKET;
-    }
-}
-
-static void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *dst)
-{
-    dst->eventType = ConvertScanEventType(src->eventType);
-    dst->dataStatus = ConvertScanDataStatus(src->dataStatus);
-    dst->addrType = ConvertScanAddrType(src->addrType);
-    if (memcpy_s(dst->addr.addr, SOFTBUS_ADDR_MAC_LEN, src->addr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
-        CLOGW("copy addr failed");
-    }
-    dst->primaryPhy = ConvertScanPhyType(src->primaryPhy);
-    dst->secondaryPhy = ConvertScanPhyType(src->secondaryPhy);
-    dst->advSid = (uint8_t)src->advSid;
-    dst->txPower = (int8_t)src->txPower;
-    dst->rssi = (int8_t)src->rssi;
-    dst->data.rawDataLen = (uint16_t)src->advLen;
-    if (memcpy_s(dst->data.rawData, dst->data.rawDataLen, src->advData, dst->data.rawDataLen) != EOK) {
-        CLOGW("copy adv data failed");
-    }
-}
-
 static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
 {
     if (scanResultdata == NULL) {
@@ -339,7 +195,7 @@ static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
     }
     SoftBusBcScanResult sr;
     ConvertScanResult(scanResultdata, &sr);
-    for (uint8_t channelId = 0; channelId < BC_SCAN_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
             CLOGW("lock scan failed");
             continue;
@@ -358,8 +214,8 @@ static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
 
 static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
 {
-    int32_t st = BleOhosStatusToSoftBus((BtStatus)resultCode);
-    for (uint8_t channelId = 0; channelId < BC_SCAN_MAX_NUM; channelId++) {
+    int32_t st = OhosStatusToSoftBus((BtStatus)resultCode);
+    for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
             CLOGW("lock scan failed");
             continue;
@@ -401,7 +257,7 @@ static int32_t RegisterScanListener(int32_t *scannerId, const SoftbusScanCallbac
         CLOGE("lock failed");
         return SOFTBUS_LOCK_ERR;
     }
-    for (uint8_t channelId = 0; channelId < BC_SCAN_MAX_NUM; channelId++) {
+    for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
         if (g_scanChannel[channelId].isUsed) {
             continue;
         }
@@ -425,7 +281,7 @@ static int32_t RegisterScanListener(int32_t *scannerId, const SoftbusScanCallbac
 
 static int32_t UnRegisterScanListener(int32_t scannerId)
 {
-    if (scannerId < 0 || scannerId >= BC_SCAN_MAX_NUM) {
+    if (scannerId < 0 || scannerId >= GATT_SCAN_MAX_NUM) {
         CLOGE("invalid scannerId: %d", scannerId);
         return SOFTBUS_INVALID_PARAM;
     }
@@ -444,59 +300,9 @@ static int32_t UnRegisterScanListener(int32_t scannerId)
     return SOFTBUS_OK;
 }
 
-static BleAdvType ConvertAdvType(uint8_t advType)
-{
-    switch (advType) {
-        case SOFTBUS_BC_ADV_IND:
-            return OHOS_BLE_ADV_IND;
-        case SOFTBUS_BC_ADV_DIRECT_IND_HIGH:
-            return OHOS_BLE_ADV_DIRECT_IND_HIGH;
-        case SOFTBUS_BC_ADV_SCAN_IND:
-            return OHOS_BLE_ADV_SCAN_IND;
-        case SOFTBUS_BC_ADV_NONCONN_IND:
-            return OHOS_BLE_ADV_NONCONN_IND;
-        case SOFTBUS_BC_ADV_DIRECT_IND_LOW:
-            return OHOS_BLE_ADV_DIRECT_IND_LOW;
-        default:
-            return OHOS_BLE_ADV_IND;
-    }
-}
-
-static BleAdvFilter ConvertAdvFilter(uint8_t advFilter)
-{
-    switch (advFilter) {
-        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY:
-            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
-        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY:
-            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY;
-        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST:
-            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST;
-        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST:
-            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST;
-        default:
-            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
-    }
-}
-
-static void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst)
-{
-    if (memcpy_s(dst->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN, src->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
-        CLOGW("copy peer addr failed");
-    }
-    dst->minInterval = src->minInterval;
-    dst->maxInterval = src->maxInterval;
-    dst->advType = ConvertAdvType(src->advType);
-    dst->ownAddrType = (unsigned char)src->ownAddrType;
-    dst->peerAddrType = (unsigned char)src->peerAddrType;
-    dst->channelMap = src->channelMap;
-    dst->advFilterPolicy = ConvertAdvFilter(src->advFilterPolicy);
-    dst->txPower = src->txPower;
-    dst->duration = src->duration;
-}
-
 static bool CheckAdvChannelInUsed(int32_t advId)
 {
-    if (advId < 0 || advId >= BC_ADV_MAX_NUM) {
+    if (advId < 0 || advId >= GATT_ADV_MAX_NUM) {
         CLOGE("invalid advId: %d", advId);
         return false;
     }
@@ -564,69 +370,9 @@ static int32_t StopBroadcasting(int32_t advId)
     return SOFTBUS_OK;
 }
 
-static void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize)
-{
-    while (filterSize-- > 0) {
-        (nativeFilter + filterSize)->address = (char *)(filter + filterSize)->address;
-        (nativeFilter + filterSize)->deviceName = (char *)(filter + filterSize)->deviceName;
-        (nativeFilter + filterSize)->manufactureData = (unsigned char *)(filter + filterSize)->manufactureData;
-        (nativeFilter + filterSize)->manufactureDataLength =
-            (unsigned int)(filter + filterSize)->manufactureDataLength;
-        (nativeFilter + filterSize)->manufactureDataMask = (unsigned char *)(filter + filterSize)->manufactureDataMask;
-        (nativeFilter + filterSize)->manufactureId = (unsigned short)(filter + filterSize)->manufactureId;
-        (nativeFilter + filterSize)->serviceData = (unsigned char *)(filter + filterSize)->serviceData;
-        (nativeFilter + filterSize)->serviceDataLength = (unsigned int)(filter + filterSize)->serviceDataLength;
-        (nativeFilter + filterSize)->serviceDataMask = (unsigned char *)(filter + filterSize)->serviceDataMask;
-        (nativeFilter + filterSize)->serviceUuid = (unsigned char *)(filter + filterSize)->serviceUuid;
-        (nativeFilter + filterSize)->serviceUuidLength = (unsigned int)(filter + filterSize)->serviceUuidLength;
-        (nativeFilter + filterSize)->serviceUuidMask = (unsigned char *)(filter + filterSize)->serviceUuidMask;
-    }
-}
-
-static void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
-{
-    while (filterSize-- > 0) {
-        uint32_t len = (nativeFilter + filterSize)->serviceDataLength;
-        if (len == 0) {
-            continue;
-        }
-        uint32_t hexLen = HEXIFY_LEN(len);
-        char *serviceData = (char *)SoftBusCalloc(sizeof(char) * hexLen);
-        char *serviceDataMask = (char *)SoftBusCalloc(sizeof(char) * hexLen);
-        if (serviceData == NULL || serviceDataMask == NULL) {
-            SoftBusFree(serviceData);
-            SoftBusFree(serviceDataMask);
-            continue;
-        }
-        (void)ConvertBytesToHexString(serviceData, hexLen, (nativeFilter + filterSize)->serviceData, len);
-        (void)ConvertBytesToHexString(serviceDataMask, hexLen, (nativeFilter + filterSize)->serviceDataMask, len);
-        CLOGI("BLE Scan Filter size:%u [serviceData:%s, serviceDataMask:%s]",
-            filterSize, serviceData, serviceDataMask);
-        SoftBusFree(serviceData);
-        SoftBusFree(serviceDataMask);
-    }
-}
-
-static int GetScanMode(uint16_t scanInterval, uint16_t scanWindow)
-{
-    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P2 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P2) {
-        return OHOS_BLE_SCAN_MODE_OP_P2_60_3000;
-    }
-    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P10 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P10) {
-        return OHOS_BLE_SCAN_MODE_OP_P10_60_600;
-    }
-    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P25 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P25) {
-        return OHOS_BLE_SCAN_MODE_OP_P25_60_240;
-    }
-    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P100 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P100) {
-        return OHOS_BLE_SCAN_MODE_OP_P100_1000_1000;
-    }
-    return OHOS_BLE_SCAN_MODE_LOW_POWER;
-}
-
 static bool CheckScanChannelInUsed(int32_t scannerId)
 {
-    if (scannerId < 0 || scannerId >= BC_SCAN_MAX_NUM) {
+    if (scannerId < 0 || scannerId >= GATT_SCAN_MAX_NUM) {
         CLOGE("invalid scannerId: %d", scannerId);
         return false;
     }
-- 
Gitee


From 3a5b2ec9dd53b296fb48cd62e26a0cea9004d898 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 01:53:13 +0000
Subject: [PATCH 29/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Fgatt.h.=20gatt=20ada?=
 =?UTF-8?q?pter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
index 31f6dc9705..8d54538fd4 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
@@ -17,7 +17,7 @@
  * @file softbus_ble_gatt.h
  * @brief ble stack adapter
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 
-- 
Gitee


From 35a39db41d9272c32942e8e629234ab139260502 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 01:53:50 +0000
Subject: [PATCH 30/89] =?UTF-8?q?add=20adapter/common/net/bluetooth/broadc?=
 =?UTF-8?q?ast/adapter/ble/include/softbus=5Fble=5Futils.h.=20gatt=20adapt?=
 =?UTF-8?q?er=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/include/softbus_ble_utils.h   | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
new file mode 100644
index 0000000000..6367f0b8b4
--- /dev/null
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file softbus_ble_utils.h
+ * @brief ble utils
+ *
+ * @since 1.0
+ * @version 1.0
+ */
+
+#ifndef SOFTBUS_BLE_UTILS_H
+#define SOFTBUS_BLE_UTILS_H
+
+#include "softbus_broadcast_adapter_interface.h"
+#include <stdbool.h>
+#include "c_header/ohos_bt_gatt.h"
+#include "c_header/ohos_bt_def.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+int32_t OhosStatusToSoftBus(BtStatus btStatus);
+
+BleAdvType ConvertAdvType(uint8_t advType);
+
+BleAdvFilter ConvertAdvFilter(uint8_t advFilter);
+
+void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst);
+
+uint8_t ConvertScanEventType(unsigned char eventType);
+
+uint8_t ConvertScanDataStatus(unsigned char dataStatus);
+
+uint8_t ConvertScanAddrType(unsigned char addrType);
+
+uint8_t ConvertScanPhyType(unsigned char phyType);
+
+void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *dst);
+
+void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize);
+
+void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize);
+
+int GetScanMode(uint16_t scanInterval, uint16_t scanWindow);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SOFTBUS_BLE_UTILS_H */
-- 
Gitee


From 612097e8637221c7682e7f2b54ecfd5b000a5c68 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 01:54:28 +0000
Subject: [PATCH 31/89] =?UTF-8?q?add=20adapter/common/net/bluetooth/broadc?=
 =?UTF-8?q?ast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_utils.c       | 279 ++++++++++++++++++
 1 file changed, 279 insertions(+)
 create mode 100644 adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
new file mode 100644
index 0000000000..dc4802acfe
--- /dev/null
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "softbus_ble_utils.h"
+#include <securec.h>
+#include "softbus_utils.h"
+#include "softbus_adapter_mem.h"
+#include "softbus_log_old.h"
+#include "softbus_broadcast_type.h"
+
+int32_t OhosStatusToSoftBus(BtStatus btStatus)
+{
+    int32_t status;
+    switch (btStatus) {
+        case OHOS_BT_STATUS_SUCCESS:
+            status = SOFTBUS_BC_STATUS_SUCCESS;
+            break;
+        case OHOS_BT_STATUS_FAIL:
+            status = SOFTBUS_BC_STATUS_FAIL;
+            break;
+        case OHOS_BT_STATUS_NOT_READY:
+            status = SOFTBUS_BC_STATUS_NOT_READY;
+            break;
+        case OHOS_BT_STATUS_NOMEM:
+            status = SOFTBUS_BC_STATUS_NOMEM;
+            break;
+        case OHOS_BT_STATUS_BUSY:
+            status = SOFTBUS_BC_STATUS_BUSY;
+            break;
+        case OHOS_BT_STATUS_DONE:
+            status = SOFTBUS_BC_STATUS_DONE;
+            break;
+        case OHOS_BT_STATUS_UNSUPPORTED:
+            status = SOFTBUS_BC_STATUS_UNSUPPORTED;
+            break;
+        case OHOS_BT_STATUS_PARM_INVALID:
+            status = SOFTBUS_BC_STATUS_PARM_INVALID;
+            break;
+        case OHOS_BT_STATUS_UNHANDLED:
+            status = SOFTBUS_BC_STATUS_UNHANDLED;
+            break;
+        case OHOS_BT_STATUS_AUTH_FAILURE:
+            status = SOFTBUS_BC_STATUS_AUTH_FAILURE;
+            break;
+        case OHOS_BT_STATUS_RMT_DEV_DOWN:
+            status = SOFTBUS_BC_STATUS_RMT_DEV_DOWN;
+            break;
+        case OHOS_BT_STATUS_AUTH_REJECTED:
+            status = SOFTBUS_BC_STATUS_AUTH_REJECTED;
+            break;
+        default:
+            status = SOFTBUS_BC_STATUS_FAIL;
+            break;
+    }
+    return status;
+}
+
+BleAdvType ConvertAdvType(uint8_t advType)
+{
+    switch (advType) {
+        case SOFTBUS_BC_ADV_IND:
+            return OHOS_BLE_ADV_IND;
+        case SOFTBUS_BC_ADV_DIRECT_IND_HIGH:
+            return OHOS_BLE_ADV_DIRECT_IND_HIGH;
+        case SOFTBUS_BC_ADV_SCAN_IND:
+            return OHOS_BLE_ADV_SCAN_IND;
+        case SOFTBUS_BC_ADV_NONCONN_IND:
+            return OHOS_BLE_ADV_NONCONN_IND;
+        case SOFTBUS_BC_ADV_DIRECT_IND_LOW:
+            return OHOS_BLE_ADV_DIRECT_IND_LOW;
+        default:
+            return OHOS_BLE_ADV_IND;
+    }
+}
+
+BleAdvFilter ConvertAdvFilter(uint8_t advFilter)
+{
+    switch (advFilter) {
+        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY:
+            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
+        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY:
+            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY;
+        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST:
+            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST;
+        case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST:
+            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST;
+        default:
+            return OHOS_BLE_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
+    }
+}
+
+void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst)
+{
+    if (memcpy_s(dst->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN, src->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
+        CLOGW("copy peer addr failed");
+    }
+    dst->minInterval = src->minInterval;
+    dst->maxInterval = src->maxInterval;
+    dst->advType = ConvertAdvType(src->advType);
+    dst->ownAddrType = (unsigned char)src->ownAddrType;
+    dst->peerAddrType = (unsigned char)src->peerAddrType;
+    dst->channelMap = src->channelMap;
+    dst->advFilterPolicy = ConvertAdvFilter(src->advFilterPolicy);
+    dst->txPower = src->txPower;
+    dst->duration = src->duration;
+}
+
+uint8_t ConvertScanEventType(unsigned char eventType)
+{
+    switch (eventType) {
+        case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE:
+            return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE;
+        case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED:
+            return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED;
+        case OHOS_BLE_EVT_CONNECTABLE:
+            return SOFTBUS_BC_EVT_CONNECTABLE;
+        case OHOS_BLE_EVT_CONNECTABLE_DIRECTED:
+            return SOFTBUS_BC_EVT_CONNECTABLE_DIRECTED;
+        case OHOS_BLE_EVT_SCANNABLE:
+            return SOFTBUS_BC_EVT_SCANNABLE;
+        case OHOS_BLE_EVT_SCANNABLE_DIRECTED:
+            return SOFTBUS_BC_EVT_SCANNABLE_DIRECTED;
+        case OHOS_BLE_EVT_LEGACY_NON_CONNECTABLE:
+            return SOFTBUS_BC_EVT_LEGACY_NON_CONNECTABLE;
+        case OHOS_BLE_EVT_LEGACY_SCANNABLE:
+            return SOFTBUS_BC_EVT_LEGACY_SCANNABLE;
+        case OHOS_BLE_EVT_LEGACY_CONNECTABLE:
+            return SOFTBUS_BC_EVT_LEGACY_CONNECTABLE;
+        case OHOS_BLE_EVT_LEGACY_CONNECTABLE_DIRECTED:
+            return SOFTBUS_BC_EVT_LEGACY_CONNECTABLE_DIRECTED;
+        case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN:
+            return SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN;
+        case OHOS_BLE_EVT_LEGACY_SCAN_RSP_TO_ADV:
+            return SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV;
+        default:
+            return SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE;
+    }
+}
+
+uint8_t ConvertScanDataStatus(unsigned char dataStatus)
+{
+    switch (dataStatus) {
+        case OHOS_BLE_DATA_COMPLETE:
+            return SOFTBUS_BC_DATA_COMPLETE;
+        case OHOS_BLE_DATA_INCOMPLETE_MORE_TO_COME:
+            return SOFTBUS_BC_DATA_INCOMPLETE_MORE_TO_COME;
+        case OHOS_BLE_DATA_INCOMPLETE_TRUNCATED:
+            return SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED;
+        default:
+            return SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED;
+    }
+}
+
+uint8_t ConvertScanAddrType(unsigned char addrType)
+{
+    switch (addrType) {
+        case OHOS_BLE_PUBLIC_DEVICE_ADDRESS:
+            return SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS;
+        case OHOS_BLE_RANDOM_DEVICE_ADDRESS:
+            return SOFTBUS_BC_RANDOM_DEVICE_ADDRESS;
+        case OHOS_BLE_PUBLIC_IDENTITY_ADDRESS:
+            return SOFTBUS_BC_PUBLIC_IDENTITY_ADDRESS;
+        case OHOS_BLE_RANDOM_STATIC_IDENTITY_ADDRESS:
+            return SOFTBUS_BC_RANDOM_STATIC_IDENTITY_ADDRESS;
+        case OHOS_BLE_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS:
+            return SOFTBUS_BC_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS;
+        case OHOS_BLE_NO_ADDRESS:
+            return SOFTBUS_BC_NO_ADDRESS;
+        default:
+            return SOFTBUS_BC_NO_ADDRESS;
+    }
+}
+
+uint8_t ConvertScanPhyType(unsigned char phyType)
+{
+    switch (phyType) {
+        case OHOS_BLE_SCAN_PHY_NO_PACKET:
+            return SOFTBUS_BC_SCAN_PHY_NO_PACKET;
+        case OHOS_BLE_SCAN_PHY_1M:
+            return SOFTBUS_BC_SCAN_PHY_1M;
+        case OHOS_BLE_SCAN_PHY_2M:
+            return SOFTBUS_BC_SCAN_PHY_2M;
+        case OHOS_BLE_SCAN_PHY_CODED:
+            return SOFTBUS_BC_SCAN_PHY_CODED;
+        default:
+            return SOFTBUS_BC_SCAN_PHY_NO_PACKET;
+    }
+}
+
+void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *dst)
+{
+    dst->eventType = ConvertScanEventType(src->eventType);
+    dst->dataStatus = ConvertScanDataStatus(src->dataStatus);
+    dst->addrType = ConvertScanAddrType(src->addrType);
+    if (memcpy_s(dst->addr.addr, SOFTBUS_ADDR_MAC_LEN, src->addr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
+        CLOGW("copy addr failed");
+    }
+    dst->primaryPhy = ConvertScanPhyType(src->primaryPhy);
+    dst->secondaryPhy = ConvertScanPhyType(src->secondaryPhy);
+    dst->advSid = (uint8_t)src->advSid;
+    dst->txPower = (int8_t)src->txPower;
+    dst->rssi = (int8_t)src->rssi;
+    dst->data.rawDataLen = (uint16_t)src->advLen;
+    if (memcpy_s(dst->data.rawData, dst->data.rawDataLen, src->advData, dst->data.rawDataLen) != EOK) {
+        CLOGW("copy adv data failed");
+    }
+}
+
+void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize)
+{
+    while (filterSize-- > 0) {
+        (nativeFilter + filterSize)->address = (char *)(filter + filterSize)->address;
+        (nativeFilter + filterSize)->deviceName = (char *)(filter + filterSize)->deviceName;
+        (nativeFilter + filterSize)->manufactureData = (unsigned char *)(filter + filterSize)->manufactureData;
+        (nativeFilter + filterSize)->manufactureDataLength =
+            (unsigned int)(filter + filterSize)->manufactureDataLength;
+        (nativeFilter + filterSize)->manufactureDataMask = (unsigned char *)(filter + filterSize)->manufactureDataMask;
+        (nativeFilter + filterSize)->manufactureId = (unsigned short)(filter + filterSize)->manufactureId;
+        (nativeFilter + filterSize)->serviceData = (unsigned char *)(filter + filterSize)->serviceData;
+        (nativeFilter + filterSize)->serviceDataLength = (unsigned int)(filter + filterSize)->serviceDataLength;
+        (nativeFilter + filterSize)->serviceDataMask = (unsigned char *)(filter + filterSize)->serviceDataMask;
+        (nativeFilter + filterSize)->serviceUuid = (unsigned char *)(filter + filterSize)->serviceUuid;
+        (nativeFilter + filterSize)->serviceUuidLength = (unsigned int)(filter + filterSize)->serviceUuidLength;
+        (nativeFilter + filterSize)->serviceUuidMask = (unsigned char *)(filter + filterSize)->serviceUuidMask;
+    }
+}
+
+void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
+{
+    while (filterSize-- > 0) {
+        uint32_t len = (nativeFilter + filterSize)->serviceDataLength;
+        if (len == 0) {
+            continue;
+        }
+        uint32_t hexLen = HEXIFY_LEN(len);
+        char *serviceData = (char *)SoftBusCalloc(sizeof(char) * hexLen);
+        char *serviceDataMask = (char *)SoftBusCalloc(sizeof(char) * hexLen);
+        if (serviceData == NULL || serviceDataMask == NULL) {
+            SoftBusFree(serviceData);
+            SoftBusFree(serviceDataMask);
+            continue;
+        }
+        (void)ConvertBytesToHexString(serviceData, hexLen, (nativeFilter + filterSize)->serviceData, len);
+        (void)ConvertBytesToHexString(serviceDataMask, hexLen, (nativeFilter + filterSize)->serviceDataMask, len);
+        CLOGI("BLE Scan Filter size:%u [serviceData:%s, serviceDataMask:%s]",
+            filterSize, serviceData, serviceDataMask);
+        SoftBusFree(serviceData);
+        SoftBusFree(serviceDataMask);
+    }
+}
+
+int GetScanMode(uint16_t scanInterval, uint16_t scanWindow)
+{
+    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P2 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P2) {
+        return OHOS_BLE_SCAN_MODE_OP_P2_60_3000;
+    }
+    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P10 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P10) {
+        return OHOS_BLE_SCAN_MODE_OP_P10_60_600;
+    }
+    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P25 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P25) {
+        return OHOS_BLE_SCAN_MODE_OP_P25_60_240;
+    }
+    if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P100 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P100) {
+        return OHOS_BLE_SCAN_MODE_OP_P100_1000_1000;
+    }
+    return OHOS_BLE_SCAN_MODE_LOW_POWER;
+}
-- 
Gitee


From 141603629330d04cba68c7d081b57e73b2c5d32b Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 01:54:47 +0000
Subject: [PATCH 32/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Finterfac?=
 =?UTF-8?q?e.h.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5?=
 =?UTF-8?q?=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1?=
 =?UTF-8?q?=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../softbus_broadcast_adapter_interface.h      | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
index 70f89e2d6a..cb17f8005d 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
@@ -17,7 +17,7 @@
  * @file softbus_broadcast_adapter_interface.h
  * @brief Different broadcast protocol stacks adapt layer interfaces
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 
@@ -30,12 +30,10 @@
 extern "C"{
 #endif
 
-#define MEDIUM_MAX_NUM 2
-
 /**
  * @brief Defines the broadcast callback function.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
@@ -48,7 +46,7 @@ typedef struct {
 /**
  * @brief Defines the broadcast scan callback function.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
@@ -60,7 +58,7 @@ typedef struct {
 /**
  * @brief Defines Different broadcast protocol stacks adapt layer interfaces
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
@@ -70,8 +68,8 @@ typedef struct {
     int32_t (*UnRegisterBroadcaster)(int32_t advId);
     int32_t (*RegisterScanListener)(int32_t *scannerId, const SoftbusScanCallback *cb);
     int32_t (*UnRegisterScanListener)(int32_t scannerId);
-    int32_t (*StartBroadcasting)(int32_t advId, const SoftbusBroadcastParam *param,
-        const SoftbusBroadcastData *bcData, const SoftbusBroadcastData *rspData);
+    int32_t (*StartBroadcasting)(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *bcData,
+        const SoftbusBroadcastData *rspData);
     int32_t (*StopBroadcasting)(int32_t advId);
     int32_t (*StartScan)(int32_t scannerId, const SoftBusBcScanParams *param, const SoftBusBcScanFilter *scanFilter,
         uint8_t filterSize);
@@ -81,7 +79,7 @@ typedef struct {
 /**
  * @brief Defines interface functions for registering different media
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBroadcastMediumInterface *interface);
@@ -89,7 +87,7 @@ int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBro
 /**
  * @brief Defines interface functions for unregistering different media
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t UnRegisterBroadcastMediumFunction(SoftbusMediumType type);
-- 
Gitee


From 2d567331ab91a37b73ed3ad97f9f65093dfd2268 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 01:55:02 +0000
Subject: [PATCH 33/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Ftype.h.?=
 =?UTF-8?q?=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3?=
 =?UTF-8?q?=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86?=
 =?UTF-8?q?=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../include/softbus_broadcast_adapter_type.h  | 88 ++-----------------
 1 file changed, 7 insertions(+), 81 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
index 426625c155..3a3b43ac07 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
@@ -17,7 +17,7 @@
  * @file softbus_broadcast_adapter_type.h
  * @brief Declare functions and constants for the soft bus broadcast adaptation
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 
@@ -30,20 +30,13 @@
 extern "C"{
 #endif
 
+/**
+ * @brief Defines mac address length
+ *
+ * @since 4.1
+ * @version 1.0
+ */
 #define SOFTBUS_ADDR_MAC_LEN 6
-// max adv and scan limit
-#define BC_ADV_MAX_NUM 16
-#define BC_SCAN_MAX_NUM 16
-
-// Bluetooth scan duty cycle, unit: ms
-#define SOFTBUS_BC_SCAN_INTERVAL_P2 3000
-#define SOFTBUS_BC_SCAN_INTERVAL_P10 600
-#define SOFTBUS_BC_SCAN_INTERVAL_P25 240
-#define SOFTBUS_BC_SCAN_INTERVAL_P100 1000
-#define SOFTBUS_BC_SCAN_WINDOW_P2 60
-#define SOFTBUS_BC_SCAN_WINDOW_P10 60
-#define SOFTBUS_BC_SCAN_WINDOW_P25 60
-#define SOFTBUS_BC_SCAN_WINDOW_P100 1000
 
 /**
  * @brief Defines different broadcast media protocol stacks
@@ -57,73 +50,6 @@ typedef enum {
     BROADCAST_MEDIUM_TYPE_BUTT,
 } SoftbusMediumType;
 
-typedef enum {
-    SOFTBUS_BC_STATUS_SUCCESS = 0x00,
-    SOFTBUS_BC_STATUS_FAIL,
-    SOFTBUS_BC_STATUS_NOT_READY,
-    SOFTBUS_BC_STATUS_NOMEM,
-    SOFTBUS_BC_STATUS_BUSY,
-    SOFTBUS_BC_STATUS_DONE,
-    SOFTBUS_BC_STATUS_UNSUPPORTED,
-    SOFTBUS_BC_STATUS_PARM_INVALID,
-    SOFTBUS_BC_STATUS_UNHANDLED,
-    SOFTBUS_BC_STATUS_AUTH_FAILURE,
-    SOFTBUS_BC_STATUS_RMT_DEV_DOWN,
-    SOFTBUS_BC_STATUS_AUTH_REJECTED
-} SoftBusBtStatus;
-
-typedef enum {
-    SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE = 0x00,
-    SOFTBUS_BC_EVT_NON_CONNECTABLE_NON_SCANNABLE_DIRECTED = 0x04,
-    SOFTBUS_BC_EVT_CONNECTABLE = 0x01,
-    SOFTBUS_BC_EVT_CONNECTABLE_DIRECTED = 0x05,
-    SOFTBUS_BC_EVT_SCANNABLE = 0x02,
-    SOFTBUS_BC_EVT_SCANNABLE_DIRECTED = 0x06,
-    SOFTBUS_BC_EVT_LEGACY_NON_CONNECTABLE = 0x10,
-    SOFTBUS_BC_EVT_LEGACY_SCANNABLE = 0x12,
-    SOFTBUS_BC_EVT_LEGACY_CONNECTABLE = 0x13,
-    SOFTBUS_BC_EVT_LEGACY_CONNECTABLE_DIRECTED = 0x15,
-    SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV_SCAN = 0x1A,
-    SOFTBUS_BC_EVT_LEGACY_SCAN_RSP_TO_ADV = 0x1B
-} SoftBusBcScanResultEvtType;
-
-typedef enum {
-    SOFTBUS_BC_PUBLIC_DEVICE_ADDRESS = 0x00,
-    SOFTBUS_BC_RANDOM_DEVICE_ADDRESS = 0x01,
-    SOFTBUS_BC_PUBLIC_IDENTITY_ADDRESS = 0x02,
-    SOFTBUS_BC_RANDOM_STATIC_IDENTITY_ADDRESS = 0x03,
-    SOFTBUS_BC_UNRESOLVABLE_RANDOM_DEVICE_ADDRESS = 0xFE,
-    SOFTBUS_BC_NO_ADDRESS = 0xFF,
-} SoftBusBcScanResultAddrType;
-
-typedef enum {
-    SOFTBUS_BC_DATA_COMPLETE = 0x00,
-    SOFTBUS_BC_DATA_INCOMPLETE_MORE_TO_COME = 0x01,
-    SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED = 0x02,
-} SoftBusBcScanResultDataStatus;
-
-typedef enum {
-    SOFTBUS_BC_SCAN_PHY_NO_PACKET = 0x00,
-    SOFTBUS_BC_SCAN_PHY_1M = 0x01,
-    SOFTBUS_BC_SCAN_PHY_2M = 0x02,
-    SOFTBUS_BC_SCAN_PHY_CODED = 0x03
-} SoftBusBcScanResultPhyType;
-
-typedef enum {
-    SOFTBUS_BC_ADV_IND = 0x00,
-    SOFTBUS_BC_ADV_DIRECT_IND_HIGH = 0x01,
-    SOFTBUS_BC_ADV_SCAN_IND = 0x02,
-    SOFTBUS_BC_ADV_NONCONN_IND = 0x03,
-    SOFTBUS_BC_ADV_DIRECT_IND_LOW  = 0x04,
-} SoftBusBcAdvType;
-
-typedef enum {
-    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY = 0x00,
-    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_ANY = 0x01,
-    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_WLST = 0x02,
-    SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_WLST_CON_WLST = 0x03,
-} SoftBusBcAdvFilter;
-
 /**
  * @brief Defines the broadcast data information
  *
-- 
Gitee


From 174bcc4ef0f22b7c0410cf8811e32309f9fc39f6 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 01:55:23 +0000
Subject: [PATCH 34/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Fmanager.h.=20gatt=20adap?=
 =?UTF-8?q?ter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../interface/softbus_broadcast_manager.h     | 34 +++++++++----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
index b159d98f61..afde23a44f 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
@@ -17,7 +17,7 @@
  * @file softbus_broadcast_manager.h
  * @brief
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 
@@ -33,7 +33,7 @@ extern "C"{
 /**
  * @brief Defines the broadcast callback function.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
@@ -46,7 +46,7 @@ typedef struct {
 /**
  * @brief Defines the broadcast scan callback function.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
@@ -60,7 +60,7 @@ typedef struct {
  *
  * @return Returns <b>0</b> If the broadcast management initialization fails;
  * returns any other value if the request fails.
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t InitBroadcastMgr(void);
@@ -70,7 +70,7 @@ int32_t InitBroadcastMgr(void);
  *
  * @return Returns <b>SOFTBUS_OK</b> If the broadcast management deinitialization fails;
  * returns any other value if the request fails.
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t DeInitBroadcastMgr(void);
@@ -85,7 +85,7 @@ int32_t DeInitBroadcastMgr(void);
  * @return Returns <b>SOFTBUS_OK</b> if the service register is successful.
  * returns any other value if the register fails.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t RegisterBroadcaster(BaseServiceType type, int32_t *bcId, const BroadcastCallback *cb);
@@ -98,7 +98,7 @@ int32_t RegisterBroadcaster(BaseServiceType type, int32_t *bcId, const Broadcast
  * @return Returns <b>SOFTBUS_OK</b> if the service unregister is successful.
  * returns any other value if the unregister fails.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t UnRegisterBroadcaster(int32_t bcId);
@@ -113,7 +113,7 @@ int32_t UnRegisterBroadcaster(int32_t bcId);
  * @return Returns <b>SOFTBUS_OK</b> if the service register is successful.
  * returns any other value if the register fails.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t RegisterScanListener(BaseServiceType type, int32_t *listenerId, const ScanCallback *cb);
@@ -126,7 +126,7 @@ int32_t RegisterScanListener(BaseServiceType type, int32_t *listenerId, const Sc
  * @return Returns <b>SOFTBUS_OK</b> if the service unregister is successful.
  * returns any other value if the unregister fails.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t UnRegisterScanListener(int32_t listenerId);
@@ -142,7 +142,7 @@ int32_t UnRegisterScanListener(int32_t listenerId);
  * @return Returns <b>SOFTBUS_OK</b> if the service starts the broadcast successfully.
  * returns any other value if the unregister fails.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPayload *bcData,
@@ -159,7 +159,7 @@ int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const Broad
  * @return Returns <b>SOFTBUS_OK</b> if the service updates the broadcast successfully.
  * returns any other value if the service fails to update the broadcast.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t UpdateBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPayload *bcData,
@@ -173,7 +173,7 @@ int32_t UpdateBroadcasting(int32_t bcId, const BroadcastParam *param, const Broa
  * @return Returns <b>SOFTBUS_OK</b> if the service stop the broadcast successfully.
  * returns any other value if the service fails to stop the broadcast.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t StopBroadcasting(int32_t bcId);
@@ -187,7 +187,7 @@ int32_t StopBroadcasting(int32_t bcId);
  * @return Returns <b>SOFTBUS_OK</b> if the service start to scan the broadcast successfully.
  * returns any other value if the service fails to scan the broadcast.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t StartScan(int32_t listenerId, const BcScanParams *param);
@@ -200,7 +200,7 @@ int32_t StartScan(int32_t listenerId, const BcScanParams *param);
  * @return Returns <b>SOFTBUS_OK</b> if the service stop to scan the broadcast successfully.
  * returns any other value if the service fails to stop scanning the broadcast.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t StopScan(int32_t listenerId);
@@ -215,7 +215,7 @@ int32_t StopScan(int32_t listenerId);
  * @return Returns <b>SOFTBUS_OK</b> if the service set the Scan Filter successfully.
  * returns any other value if the service fails to set the Scan Filter.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t SetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_t filterNum);
@@ -230,7 +230,7 @@ int32_t SetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_
  * @return Returns <b>SOFTBUS_OK</b> if the service get the Scan Filter successfully.
  * returns any other value if the service fails to get the Scan Filter.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t GetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_t *filterNum);
@@ -244,7 +244,7 @@ int32_t GetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_
  * @return Returns <b>SOFTBUS_OK</b> if the service query status successfully.
  * returns any other value if the service fails to query status.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t QueryBroadcastStatus(int32_t bcId, int32_t *status);
-- 
Gitee


From c045d02a3abf27f31223f32288cba5445cb0975c Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 01:55:41 +0000
Subject: [PATCH 35/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Ftype.h.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../interface/softbus_broadcast_type.h        | 29 ++++++++++---------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
index 402f0502a5..0b5ebe846a 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
@@ -17,7 +17,7 @@
  * @file softbus_broadcast_type.h
  * @brief Declare constants for the softbus broadcast.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 
@@ -33,10 +33,11 @@ extern "C"{
 /**
  * @brief Defines mac address length
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 #define BC_ADDR_MAC_LEN 6
+
 // Bluetooth scan duty cycle, unit: ms
 #define SOFTBUS_BC_SCAN_INTERVAL_P2 3000
 #define SOFTBUS_BC_SCAN_INTERVAL_P10 600
@@ -50,7 +51,7 @@ extern "C"{
 /**
  * @brief Defines the broadcast service type.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef enum {
@@ -140,7 +141,7 @@ typedef enum {
     SOFTBUS_BC_DATA_COMPLETE = 0x00,
     SOFTBUS_BC_DATA_INCOMPLETE_MORE_TO_COME = 0x01,
     SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED = 0x02,
-} SoftBusScanResultDataStatus;
+} SoftBusBcScanResultDataStatus;
 
 typedef enum {
     SOFTBUS_BC_BT_STATE_TURNING_ON = 0x0,
@@ -152,15 +153,15 @@ typedef enum {
     SOFTBUS_BC_BR_STATE_TURNING_OFF,
     SOFTBUS_BC_BR_STATE_TURN_OFF
 } SoftBusBcStackState;
+
 /**
  * @brief Defines the broadcast data information
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
     uint16_t uuid;
-    uint16_t companyId;
     uint16_t payloadLen;
     uint8_t *payload; // if pointer defines rsp payload, pointer may be null
 } BroadcastPayload;
@@ -168,7 +169,7 @@ typedef struct {
 /**
  * @brief Defines mac address information
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
@@ -178,7 +179,7 @@ typedef struct {
 /**
  * @brief Defines the device information returned by <b>SoftbusBroadcastCallback</b>.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
@@ -198,7 +199,7 @@ typedef struct {
 /**
  * @brief Defines the broadcast parameters
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
@@ -217,15 +218,15 @@ typedef struct {
 /**
  * @brief Defines broadcast scan filters
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
     int8_t *address;
     int8_t *deviceName;
-    uint32_t serviceUuidLength; // reserve
-    uint8_t *serviceUuid; // reserve
-    uint8_t *serviceUuidMask; // reserve
+    uint32_t serviceUuidLength;
+    uint8_t *serviceUuid;
+    uint8_t *serviceUuidMask;
     uint32_t serviceDataLength;
     uint8_t *serviceData;
     uint8_t *serviceDataMask;
@@ -238,7 +239,7 @@ typedef struct {
 /**
  * @brief Defines broadcast scan parameters
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
-- 
Gitee


From 97458f1c2aa7724a79bd26032b242ba0ea62f8b6 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 01:55:55 +0000
Subject: [PATCH 36/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Futils.h.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../interface/softbus_broadcast_utils.h       | 58 +++++++++----------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_utils.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_utils.h
index a3c3237a82..fa1288d1ab 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_utils.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_utils.h
@@ -17,7 +17,7 @@
  * @file softbus_broadcast_utils.h
  * @brief Declare functions and constants for the softbus broadcast or scan data fill or parse common functions.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 
@@ -30,16 +30,16 @@
 extern "C"{
 #endif
 
-#define MEDIUM_NUM_MAX         2
+#define MEDIUM_NUM_MAX 2
 
 // max broadcasting and scan limit
-#define BC_NUM_MAX             9
-#define SCAN_NUM_MAX           9
+#define BC_NUM_MAX 9
+#define SCAN_NUM_MAX 9
 
-#define BC_DATA_MAX_LEN        24
-#define RSP_DATA_MAX_LEN       27
-#define BC_BYTE_MASK           0xFF
-#define BC_SHIFT_BIT           8
+#define BC_DATA_MAX_LEN 24  //ADV_DATA_MAX_LEN
+#define RSP_DATA_MAX_LEN 27
+#define BC_BYTE_MASK 0xFF
+#define BC_SHIFT_BIT 8
 
 // adv broadcast head
 #define BC_HEAD_LEN             7
@@ -51,13 +51,13 @@ extern "C"{
 #define IDX_BC_UUID             5
 #define BC_UUID_LEN             2
 
-#define BC_FLAG_BYTE_LEN        0x2
-#define BC_FLAG_AD_TYPE         0x1
-#define BC_FLAG_AD_DATA         0x2
+#define BC_FLAG_BYTE_LEN         0x2
+#define BC_FLAG_AD_TYPE          0x1
+#define BC_FLAG_AD_DATA          0x2
 
 // broadcast type
-#define SERVICE_BC_TYPE          0x16
-#define MANUFACTURE_BC_TYPE      0xFF
+#define SERVICE_BC_TYPE              0x16
+#define MANUFACTURE_BC_TYPE            0xFF
 
 // scan rsp head
 #define RSP_HEAD_LEN             4
@@ -67,9 +67,9 @@ extern "C"{
 #define IDX_RSP_UUID             2
 #define RSP_UUID_LEN             2
 
-#define RSP_FLAG_BYTE_LEN        0x2
-#define RSP_FLAG_AD_TYPE         0x1
-#define RSP_FLAG_AD_DATA         0x2
+#define RSP_FLAG_BYTE_LEN         0x2
+#define RSP_FLAG_AD_TYPE          0x1
+#define RSP_FLAG_AD_DATA          0x2
 
 /**
  * @brief Defines the format of broadcast TLV data
@@ -77,7 +77,7 @@ extern "C"{
  * DATA_FORMAT_TL_1BYTE indicates BcTlvDataFormatThe TLV format is 4 bits for T and 4 bits for L
  * DATA_FORMAT_TL_2BYTE indicates BcTlvDataFormatThe TLV format is 1 byte for T and 1 byte for L
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 enum BcTlvDataFormat {
@@ -88,7 +88,7 @@ enum BcTlvDataFormat {
 /**
  * @brief Defines the broadcast TLV data
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 typedef struct {
@@ -109,7 +109,7 @@ typedef struct {
  * @return Returns <b>SOFTBUS_OK</b> if the service gets service data successful.
  * returns any other value if the service fails to get service data.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t GetServiceAdvData(uint16_t uuid, uint8_t **advPosPtr, uint32_t *advLen,
@@ -127,7 +127,7 @@ int32_t GetServiceAdvData(uint16_t uuid, uint8_t **advPosPtr, uint32_t *advLen,
  * @return Returns <b>SOFTBUS_OK</b> if the service gets respond service data successful.
  * returns any other value if the service fails to get respond service data.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t GetServiceRspData(uint16_t uuid, uint8_t **rspPosPtr, uint32_t *rspLen,
@@ -145,7 +145,7 @@ int32_t GetServiceRspData(uint16_t uuid, uint8_t **rspPosPtr, uint32_t *rspLen,
  * @return Returns <b>SOFTBUS_OK</b> if the service gets manufacturer data successful.
  * returns any other value if the service fails to get manufacturer data.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t GetManufacturerAdvData(uint16_t companyId, uint8_t **advPosPtr, uint32_t *advLen, const uint8_t *rawData,
@@ -163,7 +163,7 @@ int32_t GetManufacturerAdvData(uint16_t companyId, uint8_t **advPosPtr, uint32_t
  * @return Returns <b>SOFTBUS_OK</b> if the service gets respond manufacturer data successful.
  * returns any other value if the service fails to get respond manufacturer data.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t GetManufacturerRspData(uint16_t companyId, uint8_t **rspPosPtr, uint32_t *rspLen, const uint8_t *rawData,
@@ -180,7 +180,7 @@ int32_t GetManufacturerRspData(uint16_t companyId, uint8_t **rspPosPtr, uint32_t
  * @return Returns <b>SOFTBUS_OK</b> if the service gets local name successful.
  * returns any other value if the service fails to get local name.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t GetLocalNameData(uint8_t *localName, uint32_t *len, const uint8_t *rawData, uint32_t dataLen);
@@ -195,7 +195,7 @@ int32_t GetLocalNameData(uint8_t *localName, uint32_t *len, const uint8_t *rawDa
  * @return Returns <b>SOFTBUS_OK</b> if the service gets flag successful.
  * returns any other value if the service fails to get flag.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t GetBcFlag(uint8_t *flag, const uint8_t *rawData, uint32_t dataLen);
@@ -210,7 +210,7 @@ int32_t GetBcFlag(uint8_t *flag, const uint8_t *rawData, uint32_t dataLen);
  * @return Returns <b>SOFTBUS_OK</b> if the service gets uuid successful.
  * returns any other value if the service fails to get uuid.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t GetServiceUuid(uint16_t *uuid, const uint8_t *rawData, uint32_t dataLen);
@@ -225,7 +225,7 @@ int32_t GetServiceUuid(uint16_t *uuid, const uint8_t *rawData, uint32_t dataLen)
  * @return Returns <b>SOFTBUS_OK</b> if the service gets companyId successful.
  * returns any other value if the service fails to get companyId.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t GetManufacturerId(uint16_t *companyId, const uint8_t *rawData, uint32_t dataLen);
@@ -239,7 +239,7 @@ int32_t GetManufacturerId(uint16_t *companyId, const uint8_t *rawData, uint32_t
  * @return true
  * @return false
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 bool IsServiceData(const uint8_t *rawData, uint32_t dataLen);
@@ -254,7 +254,7 @@ bool IsServiceData(const uint8_t *rawData, uint32_t dataLen);
  * @return Returns <b>SOFTBUS_OK</b> if the TLV packet assemble successful.
  * returns any other value if the TLV packet fails to assemble.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t AssembleTlvPkg(enum BcTlvDataFormat, uint8_t *bcData, uint32_t dataLen, const BcTlv *tlv);
@@ -269,7 +269,7 @@ int32_t AssembleTlvPkg(enum BcTlvDataFormat, uint8_t *bcData, uint32_t dataLen,
  * @return Returns <b>SOFTBUS_OK</b> if the TLV packet parse successful.
  * returns any other value if the TLV packet fails to parse.
  *
- * @since 4.1
+ * @since 1.0
  * @version 1.0
  */
 int32_t ParseTlvPkg(enum BcTlvDataFormat, const uint8_t *bcData, uint32_t dataLen, BcTlv *tlv);
-- 
Gitee


From 90a3db4c14ffcf8bf5f59fb075f5a7c9130318bc Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 01:56:42 +0000
Subject: [PATCH 37/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/net?=
 =?UTF-8?q?=5Fbluetooth.gni.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91?=
 =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4?=
 =?UTF-8?q?=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 adapter/common/net/bluetooth/net_bluetooth.gni | 1 +
 1 file changed, 1 insertion(+)

diff --git a/adapter/common/net/bluetooth/net_bluetooth.gni b/adapter/common/net/bluetooth/net_bluetooth.gni
index 3afb89cb19..ea5c540875 100644
--- a/adapter/common/net/bluetooth/net_bluetooth.gni
+++ b/adapter/common/net/bluetooth/net_bluetooth.gni
@@ -29,6 +29,7 @@ adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/adapter_bt_utils.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c",
 ]
 adapter_net_br_src = [ "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c" ]
-- 
Gitee


From c272ce6b1143e53a6dc357b07df050f306595fbc Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 02:11:00 +0000
Subject: [PATCH 38/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Futils.h.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../interface/softbus_broadcast_utils.h       | 58 +++++++++----------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_utils.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_utils.h
index fa1288d1ab..a3c3237a82 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_utils.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_utils.h
@@ -17,7 +17,7 @@
  * @file softbus_broadcast_utils.h
  * @brief Declare functions and constants for the softbus broadcast or scan data fill or parse common functions.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 
@@ -30,16 +30,16 @@
 extern "C"{
 #endif
 
-#define MEDIUM_NUM_MAX 2
+#define MEDIUM_NUM_MAX         2
 
 // max broadcasting and scan limit
-#define BC_NUM_MAX 9
-#define SCAN_NUM_MAX 9
+#define BC_NUM_MAX             9
+#define SCAN_NUM_MAX           9
 
-#define BC_DATA_MAX_LEN 24  //ADV_DATA_MAX_LEN
-#define RSP_DATA_MAX_LEN 27
-#define BC_BYTE_MASK 0xFF
-#define BC_SHIFT_BIT 8
+#define BC_DATA_MAX_LEN        24
+#define RSP_DATA_MAX_LEN       27
+#define BC_BYTE_MASK           0xFF
+#define BC_SHIFT_BIT           8
 
 // adv broadcast head
 #define BC_HEAD_LEN             7
@@ -51,13 +51,13 @@ extern "C"{
 #define IDX_BC_UUID             5
 #define BC_UUID_LEN             2
 
-#define BC_FLAG_BYTE_LEN         0x2
-#define BC_FLAG_AD_TYPE          0x1
-#define BC_FLAG_AD_DATA          0x2
+#define BC_FLAG_BYTE_LEN        0x2
+#define BC_FLAG_AD_TYPE         0x1
+#define BC_FLAG_AD_DATA         0x2
 
 // broadcast type
-#define SERVICE_BC_TYPE              0x16
-#define MANUFACTURE_BC_TYPE            0xFF
+#define SERVICE_BC_TYPE          0x16
+#define MANUFACTURE_BC_TYPE      0xFF
 
 // scan rsp head
 #define RSP_HEAD_LEN             4
@@ -67,9 +67,9 @@ extern "C"{
 #define IDX_RSP_UUID             2
 #define RSP_UUID_LEN             2
 
-#define RSP_FLAG_BYTE_LEN         0x2
-#define RSP_FLAG_AD_TYPE          0x1
-#define RSP_FLAG_AD_DATA          0x2
+#define RSP_FLAG_BYTE_LEN        0x2
+#define RSP_FLAG_AD_TYPE         0x1
+#define RSP_FLAG_AD_DATA         0x2
 
 /**
  * @brief Defines the format of broadcast TLV data
@@ -77,7 +77,7 @@ extern "C"{
  * DATA_FORMAT_TL_1BYTE indicates BcTlvDataFormatThe TLV format is 4 bits for T and 4 bits for L
  * DATA_FORMAT_TL_2BYTE indicates BcTlvDataFormatThe TLV format is 1 byte for T and 1 byte for L
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 enum BcTlvDataFormat {
@@ -88,7 +88,7 @@ enum BcTlvDataFormat {
 /**
  * @brief Defines the broadcast TLV data
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
@@ -109,7 +109,7 @@ typedef struct {
  * @return Returns <b>SOFTBUS_OK</b> if the service gets service data successful.
  * returns any other value if the service fails to get service data.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t GetServiceAdvData(uint16_t uuid, uint8_t **advPosPtr, uint32_t *advLen,
@@ -127,7 +127,7 @@ int32_t GetServiceAdvData(uint16_t uuid, uint8_t **advPosPtr, uint32_t *advLen,
  * @return Returns <b>SOFTBUS_OK</b> if the service gets respond service data successful.
  * returns any other value if the service fails to get respond service data.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t GetServiceRspData(uint16_t uuid, uint8_t **rspPosPtr, uint32_t *rspLen,
@@ -145,7 +145,7 @@ int32_t GetServiceRspData(uint16_t uuid, uint8_t **rspPosPtr, uint32_t *rspLen,
  * @return Returns <b>SOFTBUS_OK</b> if the service gets manufacturer data successful.
  * returns any other value if the service fails to get manufacturer data.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t GetManufacturerAdvData(uint16_t companyId, uint8_t **advPosPtr, uint32_t *advLen, const uint8_t *rawData,
@@ -163,7 +163,7 @@ int32_t GetManufacturerAdvData(uint16_t companyId, uint8_t **advPosPtr, uint32_t
  * @return Returns <b>SOFTBUS_OK</b> if the service gets respond manufacturer data successful.
  * returns any other value if the service fails to get respond manufacturer data.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t GetManufacturerRspData(uint16_t companyId, uint8_t **rspPosPtr, uint32_t *rspLen, const uint8_t *rawData,
@@ -180,7 +180,7 @@ int32_t GetManufacturerRspData(uint16_t companyId, uint8_t **rspPosPtr, uint32_t
  * @return Returns <b>SOFTBUS_OK</b> if the service gets local name successful.
  * returns any other value if the service fails to get local name.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t GetLocalNameData(uint8_t *localName, uint32_t *len, const uint8_t *rawData, uint32_t dataLen);
@@ -195,7 +195,7 @@ int32_t GetLocalNameData(uint8_t *localName, uint32_t *len, const uint8_t *rawDa
  * @return Returns <b>SOFTBUS_OK</b> if the service gets flag successful.
  * returns any other value if the service fails to get flag.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t GetBcFlag(uint8_t *flag, const uint8_t *rawData, uint32_t dataLen);
@@ -210,7 +210,7 @@ int32_t GetBcFlag(uint8_t *flag, const uint8_t *rawData, uint32_t dataLen);
  * @return Returns <b>SOFTBUS_OK</b> if the service gets uuid successful.
  * returns any other value if the service fails to get uuid.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t GetServiceUuid(uint16_t *uuid, const uint8_t *rawData, uint32_t dataLen);
@@ -225,7 +225,7 @@ int32_t GetServiceUuid(uint16_t *uuid, const uint8_t *rawData, uint32_t dataLen)
  * @return Returns <b>SOFTBUS_OK</b> if the service gets companyId successful.
  * returns any other value if the service fails to get companyId.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t GetManufacturerId(uint16_t *companyId, const uint8_t *rawData, uint32_t dataLen);
@@ -239,7 +239,7 @@ int32_t GetManufacturerId(uint16_t *companyId, const uint8_t *rawData, uint32_t
  * @return true
  * @return false
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 bool IsServiceData(const uint8_t *rawData, uint32_t dataLen);
@@ -254,7 +254,7 @@ bool IsServiceData(const uint8_t *rawData, uint32_t dataLen);
  * @return Returns <b>SOFTBUS_OK</b> if the TLV packet assemble successful.
  * returns any other value if the TLV packet fails to assemble.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t AssembleTlvPkg(enum BcTlvDataFormat, uint8_t *bcData, uint32_t dataLen, const BcTlv *tlv);
@@ -269,7 +269,7 @@ int32_t AssembleTlvPkg(enum BcTlvDataFormat, uint8_t *bcData, uint32_t dataLen,
  * @return Returns <b>SOFTBUS_OK</b> if the TLV packet parse successful.
  * returns any other value if the TLV packet fails to parse.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t ParseTlvPkg(enum BcTlvDataFormat, const uint8_t *bcData, uint32_t dataLen, BcTlv *tlv);
-- 
Gitee


From ade9b89ec29151a74ded56fda920b44dc8527753 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 02:11:17 +0000
Subject: [PATCH 39/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Ftype.h.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../interface/softbus_broadcast_type.h        | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
index 0b5ebe846a..1673a05a29 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
@@ -17,7 +17,7 @@
  * @file softbus_broadcast_type.h
  * @brief Declare constants for the softbus broadcast.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 
@@ -33,7 +33,7 @@ extern "C"{
 /**
  * @brief Defines mac address length
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 #define BC_ADDR_MAC_LEN 6
@@ -51,7 +51,7 @@ extern "C"{
 /**
  * @brief Defines the broadcast service type.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef enum {
@@ -157,7 +157,7 @@ typedef enum {
 /**
  * @brief Defines the broadcast data information
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
@@ -169,7 +169,7 @@ typedef struct {
 /**
  * @brief Defines mac address information
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
@@ -179,7 +179,7 @@ typedef struct {
 /**
  * @brief Defines the device information returned by <b>SoftbusBroadcastCallback</b>.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
@@ -199,7 +199,7 @@ typedef struct {
 /**
  * @brief Defines the broadcast parameters
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
@@ -218,15 +218,15 @@ typedef struct {
 /**
  * @brief Defines broadcast scan filters
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
     int8_t *address;
     int8_t *deviceName;
-    uint32_t serviceUuidLength;
-    uint8_t *serviceUuid;
-    uint8_t *serviceUuidMask;
+    uint32_t serviceUuidLength; // reserve
+    uint8_t *serviceUuid; // reserve
+    uint8_t *serviceUuidMask; // reserve
     uint32_t serviceDataLength;
     uint8_t *serviceData;
     uint8_t *serviceDataMask;
@@ -239,7 +239,7 @@ typedef struct {
 /**
  * @brief Defines broadcast scan parameters
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
-- 
Gitee


From e5662b6441fdd2152d0abe64acff0ce13340db1d Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 02:11:37 +0000
Subject: [PATCH 40/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Fmanager.h.=20gatt=20adap?=
 =?UTF-8?q?ter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../interface/softbus_broadcast_manager.h     | 34 +++++++++----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
index afde23a44f..b159d98f61 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_manager.h
@@ -17,7 +17,7 @@
  * @file softbus_broadcast_manager.h
  * @brief
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 
@@ -33,7 +33,7 @@ extern "C"{
 /**
  * @brief Defines the broadcast callback function.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
@@ -46,7 +46,7 @@ typedef struct {
 /**
  * @brief Defines the broadcast scan callback function.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
@@ -60,7 +60,7 @@ typedef struct {
  *
  * @return Returns <b>0</b> If the broadcast management initialization fails;
  * returns any other value if the request fails.
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t InitBroadcastMgr(void);
@@ -70,7 +70,7 @@ int32_t InitBroadcastMgr(void);
  *
  * @return Returns <b>SOFTBUS_OK</b> If the broadcast management deinitialization fails;
  * returns any other value if the request fails.
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t DeInitBroadcastMgr(void);
@@ -85,7 +85,7 @@ int32_t DeInitBroadcastMgr(void);
  * @return Returns <b>SOFTBUS_OK</b> if the service register is successful.
  * returns any other value if the register fails.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t RegisterBroadcaster(BaseServiceType type, int32_t *bcId, const BroadcastCallback *cb);
@@ -98,7 +98,7 @@ int32_t RegisterBroadcaster(BaseServiceType type, int32_t *bcId, const Broadcast
  * @return Returns <b>SOFTBUS_OK</b> if the service unregister is successful.
  * returns any other value if the unregister fails.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t UnRegisterBroadcaster(int32_t bcId);
@@ -113,7 +113,7 @@ int32_t UnRegisterBroadcaster(int32_t bcId);
  * @return Returns <b>SOFTBUS_OK</b> if the service register is successful.
  * returns any other value if the register fails.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t RegisterScanListener(BaseServiceType type, int32_t *listenerId, const ScanCallback *cb);
@@ -126,7 +126,7 @@ int32_t RegisterScanListener(BaseServiceType type, int32_t *listenerId, const Sc
  * @return Returns <b>SOFTBUS_OK</b> if the service unregister is successful.
  * returns any other value if the unregister fails.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t UnRegisterScanListener(int32_t listenerId);
@@ -142,7 +142,7 @@ int32_t UnRegisterScanListener(int32_t listenerId);
  * @return Returns <b>SOFTBUS_OK</b> if the service starts the broadcast successfully.
  * returns any other value if the unregister fails.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPayload *bcData,
@@ -159,7 +159,7 @@ int32_t StartBroadcasting(int32_t bcId, const BroadcastParam *param, const Broad
  * @return Returns <b>SOFTBUS_OK</b> if the service updates the broadcast successfully.
  * returns any other value if the service fails to update the broadcast.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t UpdateBroadcasting(int32_t bcId, const BroadcastParam *param, const BroadcastPayload *bcData,
@@ -173,7 +173,7 @@ int32_t UpdateBroadcasting(int32_t bcId, const BroadcastParam *param, const Broa
  * @return Returns <b>SOFTBUS_OK</b> if the service stop the broadcast successfully.
  * returns any other value if the service fails to stop the broadcast.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t StopBroadcasting(int32_t bcId);
@@ -187,7 +187,7 @@ int32_t StopBroadcasting(int32_t bcId);
  * @return Returns <b>SOFTBUS_OK</b> if the service start to scan the broadcast successfully.
  * returns any other value if the service fails to scan the broadcast.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t StartScan(int32_t listenerId, const BcScanParams *param);
@@ -200,7 +200,7 @@ int32_t StartScan(int32_t listenerId, const BcScanParams *param);
  * @return Returns <b>SOFTBUS_OK</b> if the service stop to scan the broadcast successfully.
  * returns any other value if the service fails to stop scanning the broadcast.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t StopScan(int32_t listenerId);
@@ -215,7 +215,7 @@ int32_t StopScan(int32_t listenerId);
  * @return Returns <b>SOFTBUS_OK</b> if the service set the Scan Filter successfully.
  * returns any other value if the service fails to set the Scan Filter.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t SetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_t filterNum);
@@ -230,7 +230,7 @@ int32_t SetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_
  * @return Returns <b>SOFTBUS_OK</b> if the service get the Scan Filter successfully.
  * returns any other value if the service fails to get the Scan Filter.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t GetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_t *filterNum);
@@ -244,7 +244,7 @@ int32_t GetScanFilter(int32_t listenerId, const BcScanFilter *scanFilter, uint8_
  * @return Returns <b>SOFTBUS_OK</b> if the service query status successfully.
  * returns any other value if the service fails to query status.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t QueryBroadcastStatus(int32_t bcId, int32_t *status);
-- 
Gitee


From 4df8e6183a7c54aad05893c0fe57398b9ed4c3c1 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 02:11:57 +0000
Subject: [PATCH 41/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Ftype.h.?=
 =?UTF-8?q?=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3?=
 =?UTF-8?q?=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86?=
 =?UTF-8?q?=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/include/softbus_broadcast_adapter_type.h  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
index 3a3b43ac07..e87e8f0322 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_type.h
@@ -17,7 +17,7 @@
  * @file softbus_broadcast_adapter_type.h
  * @brief Declare functions and constants for the soft bus broadcast adaptation
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 
-- 
Gitee


From 1518e048e822d172f8a5d596f05557165d8dd04a Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 02:12:12 +0000
Subject: [PATCH 42/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Finterfac?=
 =?UTF-8?q?e.h.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5?=
 =?UTF-8?q?=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1?=
 =?UTF-8?q?=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../include/softbus_broadcast_adapter_interface.h  | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
index cb17f8005d..098dc53f0d 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
@@ -17,7 +17,7 @@
  * @file softbus_broadcast_adapter_interface.h
  * @brief Different broadcast protocol stacks adapt layer interfaces
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 
@@ -30,10 +30,12 @@
 extern "C"{
 #endif
 
+#define MEDIUM_MAX_NUM 2
+
 /**
  * @brief Defines the broadcast callback function.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
@@ -46,7 +48,7 @@ typedef struct {
 /**
  * @brief Defines the broadcast scan callback function.
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
@@ -58,7 +60,7 @@ typedef struct {
 /**
  * @brief Defines Different broadcast protocol stacks adapt layer interfaces
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 typedef struct {
@@ -79,7 +81,7 @@ typedef struct {
 /**
  * @brief Defines interface functions for registering different media
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBroadcastMediumInterface *interface);
@@ -87,7 +89,7 @@ int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBro
 /**
  * @brief Defines interface functions for unregistering different media
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 int32_t UnRegisterBroadcastMediumFunction(SoftbusMediumType type);
-- 
Gitee


From d79511a8dd6b8b4780743a9d37f1913939ae7067 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 02:12:36 +0000
Subject: [PATCH 43/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Fgatt.h.=20gatt=20ada?=
 =?UTF-8?q?pter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
index 8d54538fd4..31f6dc9705 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
@@ -17,7 +17,7 @@
  * @file softbus_ble_gatt.h
  * @brief ble stack adapter
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 
-- 
Gitee


From ce91d54521229d90627916ad314599de68d67f64 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 02:15:23 +0000
Subject: [PATCH 44/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Ftype.h.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../net/bluetooth/broadcast/interface/softbus_broadcast_type.h   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
index 1673a05a29..2c9bd520d2 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
@@ -162,6 +162,7 @@ typedef enum {
  */
 typedef struct {
     uint16_t uuid;
+    uint16_t companyId;
     uint16_t payloadLen;
     uint8_t *payload; // if pointer defines rsp payload, pointer may be null
 } BroadcastPayload;
-- 
Gitee


From 56d8afe8743126ddabba047ca4340d27b35d8986 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 02:16:52 +0000
Subject: [PATCH 45/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/manager/src/softbus=5Fbroadcast=5Fmgr.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/manager/src/softbus_broadcast_mgr.c          | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
index 7f17cf3aa1..b5f23358c3 100644
--- a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
+++ b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
@@ -14,16 +14,9 @@
  */
 
 #include "softbus_broadcast_manager.h"
-#include "softbus_broadcast_adapter_interface.h"
 #include "softbus_broadcast_type.h"
-#include "softbus_error_code.h"
 
 int32_t InitBroadcastMgr(void)
-{
-    return SOFTBUS_OK;
-}
-
-int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBroadcastMediumInterface *interface)
 {
     return SOFTBUS_OK;
 }
\ No newline at end of file
-- 
Gitee


From 477b4e9f8077e10cce823773210ed60772122f59 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 03:09:20 +0000
Subject: [PATCH 46/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/ble/src/softbus_ble_gatt.c  | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index d102d53204..d9fe42fa75 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -415,7 +415,8 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
         .scanMode = GetScanMode(param->scanInterval, param->scanWindow),
         .phy = (int)param->scanPhy
     };
-    if (BleStartScanEx(scannerId, &scanConfig, nativeFilter, filterSize) != OHOS_BT_STATUS_SUCCESS) {
+    if (BleStartScanEx(g_scanChannel[scannerId].scannerId, &scanConfig, nativeFilter,
+        filterSize) != OHOS_BT_STATUS_SUCCESS) {
         SoftBusFree(nativeFilter);
         SoftBusMutexUnlock(&g_scannerLock);
         CLOGE("scan %d, start scan failed", scannerId);
@@ -483,7 +484,17 @@ int32_t SoftBusBcDisableSyncDataToLpDevice(void)
 
 int32_t SoftBusBcSetScanReportChannelToLpDevice(int scannerId, bool enable)
 {
-    return SetScanReportChannelToLpDevice(scannerId, enable);
+    if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        CLOGE("lock failed");
+        return SOFTBUS_LOCK_ERR;
+    }
+    if (!CheckScanChannelInUsed(scannerId)) {
+        SoftBusMutexUnlock(&g_scannerLock);
+        return SOFTBUS_ERR;
+    }
+    int32_t ret = SetScanReportChannelToLpDevice(g_scanChannel[scannerId].scannerId, enable);
+    SoftBusMutexUnlock(&g_scannerLock);
+    return ret;
 }
 
 int32_t SoftBusBcSetLpDeviceParam(int duration, int maxExtAdvEvents, int window,
-- 
Gitee


From 6c4043b66ae300866d4a7fbe2f9230f23abbf0bf Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 29 Nov 2023 07:46:15 +0000
Subject: [PATCH 47/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c   | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index dc4802acfe..7b326b3804 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -213,9 +213,7 @@ void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *dst)
     dst->txPower = (int8_t)src->txPower;
     dst->rssi = (int8_t)src->rssi;
     dst->data.rawDataLen = (uint16_t)src->advLen;
-    if (memcpy_s(dst->data.rawData, dst->data.rawDataLen, src->advData, dst->data.rawDataLen) != EOK) {
-        CLOGW("copy adv data failed");
-    }
+    dst->data.rawData = src->advData;
 }
 
 void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize)
-- 
Gitee


From e06a980af86e1111f120b8f37248460605cf6a8d Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 6 Dec 2023 08:47:49 +0000
Subject: [PATCH 48/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_utils.c       | 193 ++++++++++++++++--
 1 file changed, 171 insertions(+), 22 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index 7b326b3804..ad5b188934 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -16,11 +16,12 @@
 #include "softbus_ble_utils.h"
 #include <securec.h>
 #include "softbus_utils.h"
+#include "softbus_broadcast_utils.h"
 #include "softbus_adapter_mem.h"
 #include "softbus_log_old.h"
 #include "softbus_broadcast_type.h"
 
-int32_t OhosStatusToSoftBus(BtStatus btStatus)
+int32_t BtStatusToSoftBus(BtStatus btStatus)
 {
     int32_t status;
     switch (btStatus) {
@@ -67,21 +68,27 @@ int32_t OhosStatusToSoftBus(BtStatus btStatus)
     return status;
 }
 
-BleAdvType ConvertAdvType(uint8_t advType)
+uint16_t SoftbusAdvTypeToBt(uint16_t advType)
 {
     switch (advType) {
-        case SOFTBUS_BC_ADV_IND:
-            return OHOS_BLE_ADV_IND;
-        case SOFTBUS_BC_ADV_DIRECT_IND_HIGH:
-            return OHOS_BLE_ADV_DIRECT_IND_HIGH;
-        case SOFTBUS_BC_ADV_SCAN_IND:
-            return OHOS_BLE_ADV_SCAN_IND;
-        case SOFTBUS_BC_ADV_NONCONN_IND:
-            return OHOS_BLE_ADV_NONCONN_IND;
-        case SOFTBUS_BC_ADV_DIRECT_IND_LOW:
-            return OHOS_BLE_ADV_DIRECT_IND_LOW;
+        case BC_DATA_TYPE_SERVICE:
+            return SERVICE_BC_TYPE;
+        case BC_DATA_TYPE_MANUFACTURER:
+            return MANUFACTURE_BC_TYPE;
         default:
-            return OHOS_BLE_ADV_IND;
+            return 0x00;
+    }
+}
+
+uint16_t BtAdvTypeToSoftbus(uint16_t advType)
+{
+    switch (advType) {
+        case SERVICE_BC_TYPE:
+            return BC_DATA_TYPE_SERVICE;
+        case MANUFACTURE_BC_TYPE:
+            return BC_DATA_TYPE_MANUFACTURER;
+        default:
+            return 0x00;
     }
 }
 
@@ -101,6 +108,24 @@ BleAdvFilter ConvertAdvFilter(uint8_t advFilter)
     }
 }
 
+static BleAdvType ConvertAdvParamType(uint8_t advType)
+{
+    switch (advType) {
+        case SOFTBUS_BC_ADV_IND:
+            return OHOS_BLE_ADV_IND;
+        case SOFTBUS_BC_ADV_DIRECT_IND_HIGH:
+            return OHOS_BLE_ADV_DIRECT_IND_HIGH;
+        case SOFTBUS_BC_ADV_SCAN_IND:
+            return OHOS_BLE_ADV_SCAN_IND;
+        case SOFTBUS_BC_ADV_NONCONN_IND:
+            return OHOS_BLE_ADV_NONCONN_IND;
+        case SOFTBUS_BC_ADV_DIRECT_IND_LOW:
+            return OHOS_BLE_ADV_DIRECT_IND_LOW;
+        default:
+            return OHOS_BLE_ADV_IND;
+    }
+}
+
 void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst)
 {
     if (memcpy_s(dst->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN, src->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
@@ -108,7 +133,7 @@ void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst)
     }
     dst->minInterval = src->minInterval;
     dst->maxInterval = src->maxInterval;
-    dst->advType = ConvertAdvType(src->advType);
+    dst->advType = ConvertAdvParamType(src->advType);
     dst->ownAddrType = (unsigned char)src->ownAddrType;
     dst->peerAddrType = (unsigned char)src->peerAddrType;
     dst->channelMap = src->channelMap;
@@ -212,8 +237,6 @@ void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *dst)
     dst->advSid = (uint8_t)src->advSid;
     dst->txPower = (int8_t)src->txPower;
     dst->rssi = (int8_t)src->rssi;
-    dst->data.rawDataLen = (uint16_t)src->advLen;
-    dst->data.rawData = src->advData;
 }
 
 void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize)
@@ -226,12 +249,38 @@ void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter
             (unsigned int)(filter + filterSize)->manufactureDataLength;
         (nativeFilter + filterSize)->manufactureDataMask = (unsigned char *)(filter + filterSize)->manufactureDataMask;
         (nativeFilter + filterSize)->manufactureId = (unsigned short)(filter + filterSize)->manufactureId;
-        (nativeFilter + filterSize)->serviceData = (unsigned char *)(filter + filterSize)->serviceData;
-        (nativeFilter + filterSize)->serviceDataLength = (unsigned int)(filter + filterSize)->serviceDataLength;
-        (nativeFilter + filterSize)->serviceDataMask = (unsigned char *)(filter + filterSize)->serviceDataMask;
-        (nativeFilter + filterSize)->serviceUuid = (unsigned char *)(filter + filterSize)->serviceUuid;
-        (nativeFilter + filterSize)->serviceUuidLength = (unsigned int)(filter + filterSize)->serviceUuidLength;
-        (nativeFilter + filterSize)->serviceUuidMask = (unsigned char *)(filter + filterSize)->serviceUuidMask;
+
+        // serviceData = uuid + serviceData, serviceDataMask = 0xFFFF + serviceDataMask
+        uint16_t serviceUuid = (filter + filterSize)->serviceUuid;
+        uint16_t serviceDataLen = (filter + filterSize)->serviceDataLength + 2;
+        uint8_t *serviceData = (uint8_t *)SoftBusCalloc(serviceDataLen);
+        if (serviceData != NULL) {
+            serviceData[0] = serviceUuid & BC_BYTE_MASK;
+            serviceData[1] = (serviceUuid >> BC_SHIFT_BIT) & BC_BYTE_MASK;
+            if(memcpy_s(serviceData + 2, serviceDataLen - 2, (filter + filterSize)->serviceData,
+                serviceDataLen - 2) != EOK) {
+                CLOGW("copy service data failed");
+            }
+        } else {
+            CLOGW("malloc service data failed");
+            continue;
+        }
+        uint8_t *serviceDataMask = (uint8_t *)SoftBusCalloc(serviceDataLen);
+        if (serviceDataMask != NULL) {
+            serviceDataMask[0] = BC_BYTE_MASK;
+            serviceDataMask[1] = BC_BYTE_MASK;
+            if(memcpy_s(serviceDataMask + 2, serviceDataLen - 2, (filter + filterSize)->serviceDataMask,
+                serviceDataLen - 2) != EOK) {
+                CLOGW("copy service data mask failed");
+            }
+        } else {
+            SoftBusFree(serviceData);
+            CLOGW("malloc service data mask failed");
+            continue;
+        }
+        (nativeFilter + filterSize)->serviceData = (unsigned char *)serviceData;
+        (nativeFilter + filterSize)->serviceDataLength = (unsigned int)serviceDataLen;
+        (nativeFilter + filterSize)->serviceDataMask = (unsigned char *)serviceDataMask;
     }
 }
 
@@ -275,3 +324,103 @@ int GetScanMode(uint16_t scanInterval, uint16_t scanWindow)
     }
     return OHOS_BLE_SCAN_MODE_LOW_POWER;
 }
+
+uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen)
+{
+    uint16_t payloadLen = (data->bcData.payloadLen > BC_DATA_MAX_LEN) ? BC_DATA_MAX_LEN : data->bcData.payloadLen;
+    *dataLen = payloadLen + BC_HEAD_LEN;
+    uint8_t *advData = (uint8_t *)SoftBusCalloc(*dataLen);
+    if (advData == NULL) {
+        CLOGE("malloc adv data failed");
+        return NULL;
+    }
+    if (data->isSupportFlag) {
+        advData[IDX_BC_FLAG_BYTE_LEN] = BC_FLAG_BYTE_LEN;
+        advData[IDX_BC_FLAG_AD_TYPE] = BC_FLAG_AD_TYPE;
+        advData[IDX_BC_FLAG_AD_DATA] = data->flag;
+    }
+    advData[IDX_PACKET_LEN] = *dataLen - IDX_PACKET_LEN - 1;
+    advData[IDX_BC_TYPE] = SoftbusAdvTypeToBt(data->bcData.type);
+    uint16_t payloadId = data->bcData.id;
+    advData[IDX_BC_UUID] = (uint8_t)(payloadId & BC_BYTE_MASK);
+    advData[IDX_BC_UUID + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
+
+    if (memcpy_s(&advData[BC_HEAD_LEN], payloadLen, data->bcData.payload, payloadLen) != EOK) {
+        CLOGE("copy adv payload failed");
+        SoftBusFree(advData);
+        return NULL;
+    }
+    return advData;
+}
+
+uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen)
+{
+    uint16_t payloadLen = (data->payloadLen > RSP_DATA_MAX_LEN) ? RSP_DATA_MAX_LEN : data->payloadLen;
+    *dataLen = payloadLen + RSP_HEAD_LEN;
+    uint8_t *rspData = (uint8_t *)SoftBusCalloc(*dataLen);
+    if (rspData == NULL) {
+        CLOGE("malloc adv data failed");
+        return NULL;
+    }
+    rspData[IDX_RSP_PACKET_LEN] = *dataLen - IDX_RSP_PACKET_LEN - 1;
+    rspData[IDX_RSP_TYPE] = SoftbusAdvTypeToBt(data->type);
+    uint16_t payloadId = data->id;
+    rspData[IDX_RSP_UUID] = (uint8_t)(payloadId & BC_BYTE_MASK);
+    rspData[IDX_RSP_UUID + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
+
+    if (memcpy_s(&rspData[RSP_HEAD_LEN], payloadLen, data->payload, payloadLen) != EOK) {
+        CLOGE("copy adv payload failed");
+        SoftBusFree(rspData);
+        return NULL;
+    }
+    return rspData;
+}
+
+void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult *dst)
+{
+    uint8_t index = 0;
+    bool isRsp = false;
+    while (index <= advLen) {
+        uint8_t len = advData[index];
+        if (index + len >= advLen) {
+            CLOGE("invalid len, index: %u, len: %u", index, len);
+            break;
+        }
+        uint8_t type = advData[++index];
+        if (type == BC_FLAG_AD_TYPE) {
+            dst->data.flag = advData[index + len - 1];
+            dst->data.isSupportFlag = true;
+        } else if (type == SHORTENED_LOCAL_NAME_BC_TYPE || type == LOCAL_NAME_BC_TYPE) {
+            if(memcpy_s(dst->localName, len - 1, &advData[index + 1], len - 1) != EOK) {
+                CLOGE("copy local name failed");
+            }
+        } else {
+            if (type != SERVICE_BC_TYPE && type != MANUFACTURE_BC_TYPE) {
+                index += len;
+                CLOGD("unsupported adv type: %u", type);
+                continue;
+            }
+            uint8_t *payload = (uint8_t *)SoftBusCalloc(len -3);
+            if (payload == NULL) {
+                index += len;
+                CLOGE("malloc payload failed");
+                continue;
+            }
+            SoftbusBroadcastPayload *data;
+            if (!isRsp) {
+                data = &dst->data.bcData;
+            } else {
+                data = &dst->data.rspData;
+            }
+            isRsp = !isRsp;
+            data->type = BtAdvTypeToSoftbus(type);
+            data->id = ((uint16_t)advData[index + 2] << BC_SHIFT_BIT) | (uint16_t)advData[index + 1];
+            data->payloadLen = len -3;
+            data->payload = payload;
+            if(memcpy_s(data->payload, data->payloadLen, &advData[index + 3], data->payloadLen) != EOK) {
+                CLOGE("copy payload failed");
+            }
+        }
+        index += len;
+    }
+}
\ No newline at end of file
-- 
Gitee


From d76e1d32b2d18d67b1a8df1b1c3020fe7459c299 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 6 Dec 2023 08:48:09 +0000
Subject: [PATCH 49/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 52 ++++++++++++-------
 1 file changed, 32 insertions(+), 20 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index d9fe42fa75..77ab283f09 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -84,7 +84,7 @@ static int32_t DeInit(void)
 
 static void WrapperAdvEnableCallback(int advId, int status)
 {
-    int32_t st = OhosStatusToSoftBus((BtStatus)status);
+    int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             CLOGW("lock adv failed");
@@ -107,7 +107,7 @@ static void WrapperAdvEnableCallback(int advId, int status)
 
 static void WrapperAdvDisableCallback(int advId, int status)
 {
-    int32_t st = OhosStatusToSoftBus((BtStatus)status);
+    int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             CLOGW("lock adv failed");
@@ -187,14 +187,15 @@ static int32_t UnRegisterBroadcaster(int32_t advId)
     return SOFTBUS_OK;
 }
 
-static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
+static void WrapperScanResultCallback(BtScanResultData *data)
 {
-    if (scanResultdata == NULL) {
-        CLOGE("scanResultdata is null");
+    if (data == NULL) {
+        CLOGE("scan result data is invalid: %p", data);
         return;
     }
     SoftBusBcScanResult sr;
-    ConvertScanResult(scanResultdata, &sr);
+    ConvertScanResult(data, &sr);
+    ParseScanResult(data->advData, data->advLen, &sr);
     for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
             CLOGW("lock scan failed");
@@ -206,15 +207,17 @@ static void WrapperScanResultCallback(BtScanResultData *scanResultdata)
             continue;
         }
         if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnReportScanDataCallback != NULL) {
-            scanChannel->scanCallback->OnReportScanDataCallback(&sr);
+            scanChannel->scanCallback->OnReportScanDataCallback(channelId, &sr);
         }
         SoftBusMutexUnlock(&g_scannerLock);
     }
+    SoftBusFree(sr.data.bcData.payload);
+    SoftBusFree(sr.data.rspData.payload);
 }
 
 static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
 {
-    int32_t st = OhosStatusToSoftBus((BtStatus)resultCode);
+    int32_t st = BtStatusToSoftBus((BtStatus)resultCode);
     for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
             CLOGW("lock scan failed");
@@ -313,10 +316,9 @@ static bool CheckAdvChannelInUsed(int32_t advId)
     return true;
 }
 
-static int32_t StartBroadcasting(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *bcData,
-    const SoftbusBroadcastData *rspData)
+static int32_t StartBroadcasting(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
 {
-    if (param == NULL || bcData == NULL || rspData == NULL) {
+    if (param == NULL || data == NULL || data->bcData.payloadLen == 0 || data->bcData.payload == NULL) {
         CLOGE("invalid param");
         return SOFTBUS_INVALID_PARAM;
     }
@@ -332,21 +334,31 @@ static int32_t StartBroadcasting(int32_t advId, const SoftbusBroadcastParam *par
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_OK;
     }
+    // 组装广播报文
+    uint16_t advDataLen;
+    uint8_t *advData = AssembleAdvData(data, &advDataLen);
+    uint16_t rspDataLen = 0;
+    uint8_t *rspData = NULL;
+    if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
+        rspData = AssembleRspData(&data->rspData, &rspDataLen);
+    }
     BleAdvParams advParam;
     ConvertAdvParam(param, &advParam);
-    StartAdvRawData advData = {
-        .advDataLen = bcData->rawDataLen,
-        .advData = bcData->rawData,
-        .rspDataLen = rspData->rawDataLen,
-        .rspData = rspData->rawData,
+    StartAdvRawData advRawData = {
+        .advDataLen = advDataLen,
+        .advData = advData,
+        .rspDataLen = rspDataLen,
+        .rspData = rspData,
     };
-    if (BleStartAdvEx(&g_advChannel[advId].advId, advData, advParam) != OHOS_BT_STATUS_SUCCESS) {
+    int32_t ret = BleStartAdvEx(&g_advChannel[advId].advId, advRawData, advParam);
+    SoftBusFree(advData);
+    SoftBusFree(rspData);
+    g_advChannel[advId].isAdvertising = (ret != OHOS_BT_STATUS_SUCCESS);
+    SoftBusMutexUnlock(&g_advLock);
+    if (ret != OHOS_BT_STATUS_SUCCESS) {
         CLOGI("start adv failed");
-        SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
-    g_advChannel[advId].isAdvertising = true;
-    SoftBusMutexUnlock(&g_advLock);
     return SOFTBUS_OK;
 }
 
-- 
Gitee


From df6f610cdf37a44415e8f11fa6d82fe34a16c09d Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 6 Dec 2023 08:53:12 +0000
Subject: [PATCH 50/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Futils.h.=20gatt=20ad?=
 =?UTF-8?q?apter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/include/softbus_ble_utils.h   | 22 +++++++------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
index 6367f0b8b4..7a249d0bcd 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
@@ -33,22 +33,10 @@
 extern "C"{
 #endif
 
-int32_t OhosStatusToSoftBus(BtStatus btStatus);
-
-BleAdvType ConvertAdvType(uint8_t advType);
-
-BleAdvFilter ConvertAdvFilter(uint8_t advFilter);
+int32_t BtStatusToSoftBus(BtStatus btStatus);
 
 void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst);
 
-uint8_t ConvertScanEventType(unsigned char eventType);
-
-uint8_t ConvertScanDataStatus(unsigned char dataStatus);
-
-uint8_t ConvertScanAddrType(unsigned char addrType);
-
-uint8_t ConvertScanPhyType(unsigned char phyType);
-
 void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *dst);
 
 void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize);
@@ -57,8 +45,14 @@ void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize);
 
 int GetScanMode(uint16_t scanInterval, uint16_t scanWindow);
 
+uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen);
+
+uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen);
+
+void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult *dst);
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* SOFTBUS_BLE_UTILS_H */
+#endif /* SOFTBUS_BLE_UTILS_H */
\ No newline at end of file
-- 
Gitee


From 58f0370a13ab699513602180e74b6219e203b1da Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 6 Dec 2023 08:53:57 +0000
Subject: [PATCH 51/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/ble/src/softbus_ble_utils.c  | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index ad5b188934..2aa025f630 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -68,7 +68,7 @@ int32_t BtStatusToSoftBus(BtStatus btStatus)
     return status;
 }
 
-uint16_t SoftbusAdvTypeToBt(uint16_t advType)
+static uint16_t SoftbusAdvTypeToBt(uint16_t advType)
 {
     switch (advType) {
         case BC_DATA_TYPE_SERVICE:
@@ -80,7 +80,7 @@ uint16_t SoftbusAdvTypeToBt(uint16_t advType)
     }
 }
 
-uint16_t BtAdvTypeToSoftbus(uint16_t advType)
+static uint16_t BtAdvTypeToSoftbus(uint16_t advType)
 {
     switch (advType) {
         case SERVICE_BC_TYPE:
@@ -92,7 +92,7 @@ uint16_t BtAdvTypeToSoftbus(uint16_t advType)
     }
 }
 
-BleAdvFilter ConvertAdvFilter(uint8_t advFilter)
+static BleAdvFilter ConvertAdvFilter(uint8_t advFilter)
 {
     switch (advFilter) {
         case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY:
@@ -142,7 +142,7 @@ void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst)
     dst->duration = src->duration;
 }
 
-uint8_t ConvertScanEventType(unsigned char eventType)
+static uint8_t ConvertScanEventType(unsigned char eventType)
 {
     switch (eventType) {
         case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE:
@@ -174,7 +174,7 @@ uint8_t ConvertScanEventType(unsigned char eventType)
     }
 }
 
-uint8_t ConvertScanDataStatus(unsigned char dataStatus)
+static uint8_t ConvertScanDataStatus(unsigned char dataStatus)
 {
     switch (dataStatus) {
         case OHOS_BLE_DATA_COMPLETE:
@@ -188,7 +188,7 @@ uint8_t ConvertScanDataStatus(unsigned char dataStatus)
     }
 }
 
-uint8_t ConvertScanAddrType(unsigned char addrType)
+static uint8_t ConvertScanAddrType(unsigned char addrType)
 {
     switch (addrType) {
         case OHOS_BLE_PUBLIC_DEVICE_ADDRESS:
@@ -208,7 +208,7 @@ uint8_t ConvertScanAddrType(unsigned char addrType)
     }
 }
 
-uint8_t ConvertScanPhyType(unsigned char phyType)
+static uint8_t ConvertScanPhyType(unsigned char phyType)
 {
     switch (phyType) {
         case OHOS_BLE_SCAN_PHY_NO_PACKET:
-- 
Gitee


From dda89cdf9270c5f603ce5a20aa846a14c5c7eb8a Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Thu, 14 Dec 2023 09:29:17 +0000
Subject: [PATCH 52/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Fgatt.h.=20gatt=20ada?=
 =?UTF-8?q?pter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/ble/include/softbus_ble_gatt.h | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
index 31f6dc9705..675f07b3df 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
@@ -25,7 +25,6 @@
 #define SOFTBUS_BLE_GATT_H
 
 #include "softbus_broadcast_adapter_interface.h"
-#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C"{
@@ -33,17 +32,6 @@ extern "C"{
 
 void SoftbusBleAdapterInit(void);
 
-bool SoftBusBcIsLpDeviceAvailable(void);
-
-int32_t SoftBusBcEnableSyncDataToLpDevice(void);
-
-int32_t SoftBusBcDisableSyncDataToLpDevice(void);
-
-int32_t SoftBusBcSetScanReportChannelToLpDevice(int32_t scannerId, bool enable);
-
-int32_t SoftBusBcSetLpDeviceParam(int duration, int maxExtAdvEvents, int window,
-    int interval, int advHandle);
-
 #ifdef __cplusplus
 }
 #endif
-- 
Gitee


From 3e604582acd65871d1a089fc818d6267c1b63965 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Thu, 14 Dec 2023 09:29:46 +0000
Subject: [PATCH 53/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Futils.h.=20gatt=20ad?=
 =?UTF-8?q?apter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/ble/include/softbus_ble_utils.h  | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
index 7a249d0bcd..a8ae773617 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
@@ -25,9 +25,9 @@
 #define SOFTBUS_BLE_UTILS_H
 
 #include "softbus_broadcast_adapter_interface.h"
-#include <stdbool.h>
 #include "c_header/ohos_bt_gatt.h"
 #include "c_header/ohos_bt_def.h"
+#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C"{
@@ -35,15 +35,15 @@ extern "C"{
 
 int32_t BtStatusToSoftBus(BtStatus btStatus);
 
-void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst);
+void SoftbusAdvParamToBt(const SoftbusBroadcastParam *src, BleAdvParams *dst);
 
-void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *dst);
+void BtScanResultToSoftbus(const BtScanResultData *src, SoftBusBcScanResult *dst);
 
-void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize);
+void SoftbusFilterToBt(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize);
 
 void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize);
 
-int GetScanMode(uint16_t scanInterval, uint16_t scanWindow);
+int GetBtScanMode(uint16_t scanInterval, uint16_t scanWindow);
 
 uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen);
 
-- 
Gitee


From 8931d55cf12b9d3d0a2d7e467d266964739dc6dd Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Thu, 14 Dec 2023 09:30:49 +0000
Subject: [PATCH 54/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_utils.c       | 45 ++++++++++---------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index 2aa025f630..915d11fa00 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -14,12 +14,13 @@
  */
 
 #include "softbus_ble_utils.h"
-#include <securec.h>
+#include "softbus_adapter_mem.h"
+#include "softbus_broadcast_type.h"
 #include "softbus_utils.h"
 #include "softbus_broadcast_utils.h"
-#include "softbus_adapter_mem.h"
+#include "disc_log.h"
 #include "softbus_log_old.h"
-#include "softbus_broadcast_type.h"
+#include <securec.h>
 
 int32_t BtStatusToSoftBus(BtStatus btStatus)
 {
@@ -126,10 +127,10 @@ static BleAdvType ConvertAdvParamType(uint8_t advType)
     }
 }
 
-void ConvertAdvParam(const SoftbusBroadcastParam *src, BleAdvParams *dst)
+void SoftbusAdvParamToBt(const SoftbusBroadcastParam *src, BleAdvParams *dst)
 {
     if (memcpy_s(dst->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN, src->peerAddr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
-        CLOGW("copy peer addr failed");
+        DISC_LOGW(DISC_BLE_ADAPTER, "copy peer addr failed");
     }
     dst->minInterval = src->minInterval;
     dst->maxInterval = src->maxInterval;
@@ -224,13 +225,13 @@ static uint8_t ConvertScanPhyType(unsigned char phyType)
     }
 }
 
-void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *dst)
+void BtScanResultToSoftbus(const BtScanResultData *src, SoftBusBcScanResult *dst)
 {
     dst->eventType = ConvertScanEventType(src->eventType);
     dst->dataStatus = ConvertScanDataStatus(src->dataStatus);
     dst->addrType = ConvertScanAddrType(src->addrType);
     if (memcpy_s(dst->addr.addr, SOFTBUS_ADDR_MAC_LEN, src->addr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
-        CLOGW("copy addr failed");
+        DISC_LOGW(DISC_BLE_ADAPTER, "copy addr failed");
     }
     dst->primaryPhy = ConvertScanPhyType(src->primaryPhy);
     dst->secondaryPhy = ConvertScanPhyType(src->secondaryPhy);
@@ -239,7 +240,7 @@ void ConvertScanResult(const BtScanResultData *src, SoftBusBcScanResult *dst)
     dst->rssi = (int8_t)src->rssi;
 }
 
-void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize)
+void SoftbusFilterToBt(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize)
 {
     while (filterSize-- > 0) {
         (nativeFilter + filterSize)->address = (char *)(filter + filterSize)->address;
@@ -259,10 +260,10 @@ void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter
             serviceData[1] = (serviceUuid >> BC_SHIFT_BIT) & BC_BYTE_MASK;
             if(memcpy_s(serviceData + 2, serviceDataLen - 2, (filter + filterSize)->serviceData,
                 serviceDataLen - 2) != EOK) {
-                CLOGW("copy service data failed");
+                DISC_LOGW(DISC_BLE_ADAPTER, "copy service data failed");
             }
         } else {
-            CLOGW("malloc service data failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "malloc service data failed");
             continue;
         }
         uint8_t *serviceDataMask = (uint8_t *)SoftBusCalloc(serviceDataLen);
@@ -271,11 +272,11 @@ void ConvertFilter(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter
             serviceDataMask[1] = BC_BYTE_MASK;
             if(memcpy_s(serviceDataMask + 2, serviceDataLen - 2, (filter + filterSize)->serviceDataMask,
                 serviceDataLen - 2) != EOK) {
-                CLOGW("copy service data mask failed");
+                DISC_LOGW(DISC_BLE_ADAPTER, "copy service data mask failed");
             }
         } else {
             SoftBusFree(serviceData);
-            CLOGW("malloc service data mask failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "malloc service data mask failed");
             continue;
         }
         (nativeFilter + filterSize)->serviceData = (unsigned char *)serviceData;
@@ -301,14 +302,14 @@ void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
         }
         (void)ConvertBytesToHexString(serviceData, hexLen, (nativeFilter + filterSize)->serviceData, len);
         (void)ConvertBytesToHexString(serviceDataMask, hexLen, (nativeFilter + filterSize)->serviceDataMask, len);
-        CLOGI("BLE Scan Filter size:%u [serviceData:%s, serviceDataMask:%s]",
+        DISC_LOGI(DISC_BLE_ADAPTER, "BLE Scan Filter size:%u [serviceData:%s, serviceDataMask:%s]",
             filterSize, serviceData, serviceDataMask);
         SoftBusFree(serviceData);
         SoftBusFree(serviceDataMask);
     }
 }
 
-int GetScanMode(uint16_t scanInterval, uint16_t scanWindow)
+int GetBtScanMode(uint16_t scanInterval, uint16_t scanWindow)
 {
     if (scanInterval == SOFTBUS_BC_SCAN_INTERVAL_P2 && scanWindow == SOFTBUS_BC_SCAN_WINDOW_P2) {
         return OHOS_BLE_SCAN_MODE_OP_P2_60_3000;
@@ -331,7 +332,7 @@ uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen)
     *dataLen = payloadLen + BC_HEAD_LEN;
     uint8_t *advData = (uint8_t *)SoftBusCalloc(*dataLen);
     if (advData == NULL) {
-        CLOGE("malloc adv data failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "malloc adv data failed");
         return NULL;
     }
     if (data->isSupportFlag) {
@@ -346,7 +347,7 @@ uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen)
     advData[IDX_BC_UUID + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
 
     if (memcpy_s(&advData[BC_HEAD_LEN], payloadLen, data->bcData.payload, payloadLen) != EOK) {
-        CLOGE("copy adv payload failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "copy adv payload failed");
         SoftBusFree(advData);
         return NULL;
     }
@@ -359,7 +360,7 @@ uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen)
     *dataLen = payloadLen + RSP_HEAD_LEN;
     uint8_t *rspData = (uint8_t *)SoftBusCalloc(*dataLen);
     if (rspData == NULL) {
-        CLOGE("malloc adv data failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "malloc adv data failed");
         return NULL;
     }
     rspData[IDX_RSP_PACKET_LEN] = *dataLen - IDX_RSP_PACKET_LEN - 1;
@@ -369,7 +370,7 @@ uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen)
     rspData[IDX_RSP_UUID + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
 
     if (memcpy_s(&rspData[RSP_HEAD_LEN], payloadLen, data->payload, payloadLen) != EOK) {
-        CLOGE("copy adv payload failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "copy adv payload failed");
         SoftBusFree(rspData);
         return NULL;
     }
@@ -383,7 +384,7 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
     while (index <= advLen) {
         uint8_t len = advData[index];
         if (index + len >= advLen) {
-            CLOGE("invalid len, index: %u, len: %u", index, len);
+            DISC_LOGE(DISC_BLE_ADAPTER, "invalid len, index: %u, len: %u", index, len);
             break;
         }
         uint8_t type = advData[++index];
@@ -392,7 +393,7 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
             dst->data.isSupportFlag = true;
         } else if (type == SHORTENED_LOCAL_NAME_BC_TYPE || type == LOCAL_NAME_BC_TYPE) {
             if(memcpy_s(dst->localName, len - 1, &advData[index + 1], len - 1) != EOK) {
-                CLOGE("copy local name failed");
+                DISC_LOGE(DISC_BLE_ADAPTER, "copy local name failed");
             }
         } else {
             if (type != SERVICE_BC_TYPE && type != MANUFACTURE_BC_TYPE) {
@@ -403,7 +404,7 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
             uint8_t *payload = (uint8_t *)SoftBusCalloc(len -3);
             if (payload == NULL) {
                 index += len;
-                CLOGE("malloc payload failed");
+                DISC_LOGE(DISC_BLE_ADAPTER, "malloc payload failed");
                 continue;
             }
             SoftbusBroadcastPayload *data;
@@ -418,7 +419,7 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
             data->payloadLen = len -3;
             data->payload = payload;
             if(memcpy_s(data->payload, data->payloadLen, &advData[index + 3], data->payloadLen) != EOK) {
-                CLOGE("copy payload failed");
+                DISC_LOGE(DISC_BLE_ADAPTER, "copy payload failed");
             }
         }
         index += len;
-- 
Gitee


From 74aac5cae026d8f6267338d1b1a8b2666ee5597a Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Thu, 14 Dec 2023 09:31:18 +0000
Subject: [PATCH 55/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 376 +++++++++++++-----
 1 file changed, 273 insertions(+), 103 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 77ab283f09..61b3b5f5bc 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -15,17 +15,22 @@
 
 #include "softbus_ble_gatt.h"
 #include "c_header/ohos_bt_gatt.h"
-#include "softbus_error_code.h"
-#include "softbus_log_old.h"
-#include "softbus_utils.h"
-#include "softbus_ble_utils.h"
 #include "softbus_adapter_thread.h"
 #include "softbus_adapter_mem.h"
 #include "softbus_broadcast_type.h"
+#include "softbus_error_code.h"
+#include "softbus_utils.h"
+#include "softbus_ble_utils.h"
+#include "disc_log.h"
+#include "softbus_log_old.h"
 #include <stdatomic.h>
+#include <string.h>
 
 #define GATT_ADV_MAX_NUM 9
 #define GATT_SCAN_MAX_NUM 9
+#define LP_BT_UUID "43d4a49f-604d-45b5-9302-4ddbbfd538fd"
+#define LP_DELIVERY_MODE_REPLY 0xF0 // Lpdevice delivery mode: reply adv when filter matched
+#define LP_ADV_DURATION_MS 0
 
 static atomic_bool g_init = false;
 static SoftBusMutex g_advLock = {0};
@@ -51,19 +56,19 @@ static ScanChannel g_scanChannel[GATT_SCAN_MAX_NUM];
 static int32_t Init(void)
 {
     if (g_init) {
-        CLOGI("already init");
+        DISC_LOGI(DISC_BLE_ADAPTER, "already init");
         return SOFTBUS_OK;
     }
     g_init = true;
     if (SoftBusMutexInit(&g_advLock, NULL) != SOFTBUS_OK) {
         g_init = false;
-        CLOGE("g_advLock init failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "g_advLock init failed");
         return SOFTBUS_ERR;
     }
     if (SoftBusMutexInit(&g_scannerLock, NULL) != SOFTBUS_OK) {
         SoftBusMutexDestroy(&g_advLock);
         g_init = false;
-        CLOGE("g_scannerLock init failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "g_scannerLock init failed");
         return SOFTBUS_ERR;
     }
     g_init = true;
@@ -73,7 +78,7 @@ static int32_t Init(void)
 static int32_t DeInit(void)
 {
     if (!g_init) {
-        CLOGI("already deInit");
+        DISC_LOGI(DISC_BLE_ADAPTER, "already deInit");
         return SOFTBUS_OK;
     }
     g_init = false;
@@ -87,7 +92,7 @@ static void WrapperAdvEnableCallback(int advId, int status)
     int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-            CLOGW("lock adv failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed");
             continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
@@ -95,7 +100,7 @@ static void WrapperAdvEnableCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        CLOGI("start adv callback, adv: %u, bt-advId: %d, status: %d", channelId, advId, st);
+        DISC_LOGI(DISC_BLE_ADAPTER, "start adv callback, adv: %u, bt-advId: %d, status: %d", channelId, advId, st);
         advChannel->isAdvertising = (st == SOFTBUS_BC_STATUS_SUCCESS);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnStartBroadcastingCallback != NULL) {
             advChannel->advCallback->OnStartBroadcastingCallback(channelId, st);
@@ -110,7 +115,7 @@ static void WrapperAdvDisableCallback(int advId, int status)
     int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-            CLOGW("lock adv failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed");
             continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
@@ -118,7 +123,7 @@ static void WrapperAdvDisableCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        CLOGI("stop adv callback, adv: %u, bt-advId: %d, status: %d", channelId, advId, st);
+        DISC_LOGI(DISC_BLE_ADAPTER, "stop adv callback, advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
         advChannel->isAdvertising = (st == SOFTBUS_BC_STATUS_SUCCESS);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnStopBroadcastingCallback != NULL) {
             advChannel->advCallback->OnStopBroadcastingCallback(channelId, st);
@@ -128,19 +133,65 @@ static void WrapperAdvDisableCallback(int advId, int status)
     }
 }
 
+static void WrapperAdvSetDataCallback(int advId, int status)
+{
+    int32_t st = BtStatusToSoftBus((BtStatus)status);
+    for (uint32_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
+        if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed");
+            continue;
+        }
+        AdvChannel *advChannel = &g_advChannel[channelId];
+        if (advChannel->advId != advId || !advChannel->isUsed) {
+            SoftBusMutexUnlock(&g_advLock);
+            continue;
+        }
+        DISC_LOGI(DISC_BLE_ADAPTER, "set adv data callback, advId: %d, bt-advId: %d, status: %d", channelId, advId, st);
+        if (advChannel->advCallback != NULL && advChannel->advCallback->OnSetBroadcastingCallback != NULL) {
+            advChannel->advCallback->OnSetBroadcastingCallback(channelId, st);
+        }
+        SoftBusMutexUnlock(&g_advLock);
+        break;
+    }
+}
+
+static void WrapperAdvUpdateDataCallback(int advId, int status)
+{
+    int32_t st = BtStatusToSoftBus((BtStatus)status);
+    for (uint32_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
+        if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed");
+            continue;
+        }
+        AdvChannel *advChannel = &g_advChannel[channelId];
+        if (advChannel->advId != advId || !advChannel->isUsed) {
+            SoftBusMutexUnlock(&g_advLock);
+            continue;
+        }
+        DISC_LOGI(DISC_BLE_ADAPTER, "update adv data callback, advId: %d, bt-advId: %d, status: %d", channelId, advId, st);
+        if (advChannel->advCallback != NULL && advChannel->advCallback->OnSetBroadcastingCallback != NULL) {
+            advChannel->advCallback->OnUpdateBroadcastingCallback(channelId, st);
+        }
+        SoftBusMutexUnlock(&g_advLock);
+        break;
+    }
+}
+
 static BtGattCallbacks g_softbusGattCb = {
     .advEnableCb = WrapperAdvEnableCallback,
-    .advDisableCb = WrapperAdvDisableCallback
+    .advDisableCb = WrapperAdvDisableCallback,
+    .advDataCb = WrapperAdvSetDataCallback,
+    .advUpdateCb = WrapperAdvUpdateDataCallback,
 };
 
-static int32_t RegisterBroadcaster(int32_t *advId, const SoftbusBroadcastCallback *cb)
+static int32_t RegisterAdvCallback(int32_t *advId, const SoftbusBroadcastCallback *cb)
 {
     if (advId == NULL || cb == NULL) {
-        CLOGE("invalid param");
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid param");
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-        CLOGE("lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
@@ -148,7 +199,7 @@ static int32_t RegisterBroadcaster(int32_t *advId, const SoftbusBroadcastCallbac
             continue;
         }
         if (BleGattRegisterCallbacks(&g_softbusGattCb) != OHOS_BT_STATUS_SUCCESS) {
-            CLOGE("register adv cb failed: %u", channelId);
+            DISC_LOGE(DISC_BLE_ADAPTER, "register adv cb failed: %u", channelId);
             SoftBusMutexUnlock(&g_advLock);
             return SOFTBUS_ERR;
         }
@@ -160,23 +211,24 @@ static int32_t RegisterBroadcaster(int32_t *advId, const SoftbusBroadcastCallbac
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_OK;
     }
-    CLOGE("no available adv channel");
+    DISC_LOGE(DISC_BLE_ADAPTER, "no available adv channel");
     SoftBusMutexUnlock(&g_advLock);
     return SOFTBUS_ERR;
 }
 
-static int32_t UnRegisterBroadcaster(int32_t advId)
+static int32_t UnRegisterAdvCallback(int32_t advId)
 {
     if (advId < 0 || advId >= GATT_ADV_MAX_NUM) {
-        CLOGE("invalid advId: %d", advId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid advId: %d", advId);
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-        CLOGE("lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!g_advChannel[advId].isUsed) {
         SoftBusMutexUnlock(&g_advLock);
+        DISC_LOGE(DISC_BLE_ADAPTER, "adv %d callback already unregistered", advId);
         return SOFTBUS_OK;
     }
     g_advChannel[advId].advId = -1;
@@ -190,15 +242,15 @@ static int32_t UnRegisterBroadcaster(int32_t advId)
 static void WrapperScanResultCallback(BtScanResultData *data)
 {
     if (data == NULL) {
-        CLOGE("scan result data is invalid: %p", data);
+        DISC_LOGE(DISC_BLE_ADAPTER, "scan result data is null");
         return;
     }
     SoftBusBcScanResult sr;
-    ConvertScanResult(data, &sr);
+    BtScanResultToSoftbus(data, &sr);
     ParseScanResult(data->advData, data->advLen, &sr);
     for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-            CLOGW("lock scan failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock scan failed");
             continue;
         }
         ScanChannel *scanChannel = &g_scanChannel[channelId];
@@ -217,10 +269,9 @@ static void WrapperScanResultCallback(BtScanResultData *data)
 
 static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
 {
-    int32_t st = BtStatusToSoftBus((BtStatus)resultCode);
     for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-            CLOGW("lock scan failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock scan failed");
             continue;
         }
         ScanChannel *scanChannel = &g_scanChannel[channelId];
@@ -228,36 +279,52 @@ static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
             SoftBusMutexUnlock(&g_scannerLock);
             continue;
         }
-        if (isStartScan && scanChannel->scanCallback != NULL &&
-            scanChannel->scanCallback->OnStartScanCallback != NULL) {
-            scanChannel->scanCallback->OnStartScanCallback(channelId, st);
+        if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnScanStateChanged != NULL) {
+            scanChannel->scanCallback->OnScanStateChanged(resultCode, isStartScan);
         }
-        if (!isStartScan && scanChannel->scanCallback != NULL &&
-            scanChannel->scanCallback->OnStopScanCallback != NULL) {
-            scanChannel->scanCallback->OnStopScanCallback(channelId, st);
+        scanChannel->isScanning = isStartScan ? (resultCode == 0) : !(resultCode == 0);
+        SoftBusMutexUnlock(&g_scannerLock);
+        break;
+    }
+}
+
+static void WrapperLpDeviceInfoCallback(BtUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
+{
+    for (uint32_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
+        if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock scan failed");
+            continue;
+        }
+        ScanChannel *scanChannel = &g_scanChannel[channelId];
+        if (!scanChannel->isUsed) {
+            SoftBusMutexUnlock(&g_scannerLock);
+            continue;
         }
-        if (isStartScan) {
-            scanChannel->isScanning = (st == SOFTBUS_BC_STATUS_SUCCESS);
-        } else {
-            scanChannel->isScanning = !(st == SOFTBUS_BC_STATUS_SUCCESS);
+        if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnReportScanDataCallback != NULL) {
+            SoftbusBroadcastUuid bcUuid;
+            bcUuid.uuid = (uint8_t *)uuid->uuid;
+            bcUuid.uuidLen = (uint8_t)uuid->uuidLen;
+            scanChannel->scanCallback->OnLpDeviceInfoCallback(&bcUuid, type, data, dataSize);
         }
         SoftBusMutexUnlock(&g_scannerLock);
+        break;
     }
 }
 
 static BleScanCallbacks g_softbusBleScanCb = {
     .scanResultCb = WrapperScanResultCallback,
-    .scanStateChangeCb = WrapperScanStateChangeCallback
+    .scanStateChangeCb = WrapperScanStateChangeCallback,
+    .lpDeviceInfoCb = WrapperLpDeviceInfoCallback,
 };
 
-static int32_t RegisterScanListener(int32_t *scannerId, const SoftbusScanCallback *cb)
+static int32_t RegisterScanCallback(int32_t *scannerId, const SoftbusScanCallback *cb)
 {
     if (scannerId == NULL || cb == NULL) {
-        CLOGE("invalid param");
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid param");
         return SOFTBUS_ERR;
     }
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-        CLOGE("lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
@@ -266,7 +333,7 @@ static int32_t RegisterScanListener(int32_t *scannerId, const SoftbusScanCallbac
         }
         if (BleRegisterScanCallbacks(&g_softbusBleScanCb,
             &g_scanChannel[channelId].scannerId) !=OHOS_BT_STATUS_SUCCESS) {
-            CLOGE("register ble scan callback failed");
+            DISC_LOGE(DISC_BLE_ADAPTER, "register ble scan callback failed");
             SoftBusMutexUnlock(&g_scannerLock);
             return SOFTBUS_ERR;
         }
@@ -277,19 +344,19 @@ static int32_t RegisterScanListener(int32_t *scannerId, const SoftbusScanCallbac
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_OK;
     }
-    CLOGE("no available scan channel");
+    DISC_LOGE(DISC_BLE_ADAPTER, "no available scan channel");
     SoftBusMutexUnlock(&g_scannerLock);
     return SOFTBUS_ERR;
 }
 
-static int32_t UnRegisterScanListener(int32_t scannerId)
+static int32_t UnRegisterScanCallback(int32_t scannerId)
 {
     if (scannerId < 0 || scannerId >= GATT_SCAN_MAX_NUM) {
-        CLOGE("invalid scannerId: %d", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid scannerId: %d", scannerId);
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-        CLOGE("lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!g_scanChannel[scannerId].isUsed) {
@@ -306,24 +373,24 @@ static int32_t UnRegisterScanListener(int32_t scannerId)
 static bool CheckAdvChannelInUsed(int32_t advId)
 {
     if (advId < 0 || advId >= GATT_ADV_MAX_NUM) {
-        CLOGE("invalid advId: %d", advId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid advId: %d", advId);
         return false;
     }
     if (!g_advChannel[advId].isUsed) {
-        CLOGE("adv %d is not in used", advId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "adv %d is not in used", advId);
         return false;
     }
     return true;
 }
 
-static int32_t StartBroadcasting(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
+static int32_t StartAdv(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
 {
     if (param == NULL || data == NULL || data->bcData.payloadLen == 0 || data->bcData.payload == NULL) {
-        CLOGE("invalid param");
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid param");
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-        CLOGE("lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
@@ -335,37 +402,31 @@ static int32_t StartBroadcasting(int32_t advId, const SoftbusBroadcastParam *par
         return SOFTBUS_OK;
     }
     // 组装广播报文
-    uint16_t advDataLen;
-    uint8_t *advData = AssembleAdvData(data, &advDataLen);
-    uint16_t rspDataLen = 0;
-    uint8_t *rspData = NULL;
+    BleAdvParams advParam;
+    SoftbusAdvParamToBt(param, &advParam);
+    StartAdvRawData advRawData;
+    advRawData.advData = AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
+    advRawData.rspDataLen = 0;
+    advRawData.rspData = NULL;
     if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
-        rspData = AssembleRspData(&data->rspData, &rspDataLen);
+        advRawData.rspData = AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
     }
-    BleAdvParams advParam;
-    ConvertAdvParam(param, &advParam);
-    StartAdvRawData advRawData = {
-        .advDataLen = advDataLen,
-        .advData = advData,
-        .rspDataLen = rspDataLen,
-        .rspData = rspData,
-    };
     int32_t ret = BleStartAdvEx(&g_advChannel[advId].advId, advRawData, advParam);
-    SoftBusFree(advData);
-    SoftBusFree(rspData);
+    SoftBusFree(advRawData.advData);
+    SoftBusFree(advRawData.rspData);
     g_advChannel[advId].isAdvertising = (ret != OHOS_BT_STATUS_SUCCESS);
     SoftBusMutexUnlock(&g_advLock);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
-        CLOGI("start adv failed");
+        DISC_LOGI(DISC_BLE_ADAPTER, "start adv failed");
         return SOFTBUS_ERR;
     }
     return SOFTBUS_OK;
 }
 
-static int32_t StopBroadcasting(int32_t advId)
+static int32_t StopAdv(int32_t advId)
 {
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-        CLOGE("lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
@@ -375,21 +436,62 @@ static int32_t StopBroadcasting(int32_t advId)
     g_advChannel[advId].isAdvertising = false;
     if (BleStopAdv(g_advChannel[advId].advId) != OHOS_BT_STATUS_SUCCESS) {
         SoftBusMutexUnlock(&g_advLock);
-        CLOGI("adv: %d, stop adv failed", advId);
+        DISC_LOGI(DISC_BLE_ADAPTER, "adv: %d, stop adv failed", advId);
         return SOFTBUS_ERR;
     }
     SoftBusMutexUnlock(&g_advLock);
     return SOFTBUS_OK;
 }
 
+static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
+{
+    if (data == NULL) {
+        return SOFTBUS_INVALID_PARAM;
+    }
+    if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed");
+        return SOFTBUS_LOCK_ERR;
+    }
+    if (!CheckAdvChannelInUsed(advId)) {
+        SoftBusMutexUnlock(&g_advLock);
+        return SOFTBUS_ERR;
+    }
+    if (!g_advChannel[advId].isAdvertising) {
+        SoftBusMutexUnlock(&g_advLock);
+        DISC_LOGE(DISC_BLE_ADAPTER, "adv %d is not advertising", advId);
+        return SOFTBUS_ERR;
+    }
+    DISC_LOGI(DISC_BLE_ADAPTER, "BleSetAdvData, advId: %d, btadvId: %d", advId, g_advChannel[advId].advId);
+    StartAdvRawData advRawData;
+    advRawData.advData = AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
+    advRawData.rspDataLen = 0;
+    advRawData.rspData = NULL;
+    if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
+        advRawData.rspData = AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
+    }
+    int32_t ret = BtStatusToSoftBus(BleSetAdvData(g_advChannel[advId].advId, advRawData));
+    SoftBusFree(advRawData.advData);
+    SoftBusFree(advRawData.rspData);
+    SoftBusMutexUnlock(&g_advLock);
+    return ret;
+}
+
+static int32_t UpdateAdvData(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
+{
+    (void)advId;
+    (void)param;
+    (void)data;
+    return SOFTBUS_ERR;
+}
+
 static bool CheckScanChannelInUsed(int32_t scannerId)
 {
     if (scannerId < 0 || scannerId >= GATT_SCAN_MAX_NUM) {
-        CLOGE("invalid scannerId: %d", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid scannerId: %d", scannerId);
         return false;
     }
     if (!g_scanChannel[scannerId].isUsed) {
-        CLOGE("scanner %d is not in used", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "scanner %d is not in used", scannerId);
         return false;
     }
     return true;
@@ -399,11 +501,11 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     uint8_t filterSize)
 {
     if (param == NULL || scanFilter == NULL || filterSize == 0) {
-        CLOGE("invalid param");
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid param");
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-        CLOGE("lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
@@ -411,6 +513,10 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
         return SOFTBUS_ERR;
     }
     if (g_scanChannel[scannerId].isScanning) {
+        if (g_scanChannel[scannerId].scanCallback != NULL &&
+            g_scanChannel[scannerId].scanCallback->OnStartScanCallback != NULL) {
+            g_scanChannel[scannerId].scanCallback->OnStartScanCallback(scannerId, SOFTBUS_BC_STATUS_SUCCESS);
+        }
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_OK;
     }
@@ -418,23 +524,27 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
         (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * filterSize);
     if (nativeFilter == NULL) {
         SoftBusMutexUnlock(&g_scannerLock);
-        CLOGE("scan %d malloc native filter failed", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "scan %d malloc native filter failed", scannerId);
         return SOFTBUS_MALLOC_ERR;
     }
-    ConvertFilter(nativeFilter, scanFilter, filterSize);
+    SoftbusFilterToBt(nativeFilter, scanFilter, filterSize);
     DumpBleScanFilter(nativeFilter, filterSize);
     BleScanConfigs scanConfig = {
-        .scanMode = GetScanMode(param->scanInterval, param->scanWindow),
+        .scanMode = GetBtScanMode(param->scanInterval, param->scanWindow),
         .phy = (int)param->scanPhy
     };
     if (BleStartScanEx(g_scanChannel[scannerId].scannerId, &scanConfig, nativeFilter,
         filterSize) != OHOS_BT_STATUS_SUCCESS) {
         SoftBusFree(nativeFilter);
         SoftBusMutexUnlock(&g_scannerLock);
-        CLOGE("scan %d, start scan failed", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "scan %d, start scan failed", scannerId);
         return SOFTBUS_ERR;
     }
     g_scanChannel[scannerId].isScanning = true;
+    if (g_scanChannel[scannerId].scanCallback != NULL &&
+            g_scanChannel[scannerId].scanCallback->OnStartScanCallback != NULL) {
+        g_scanChannel[scannerId].scanCallback->OnStartScanCallback(scannerId, SOFTBUS_BC_STATUS_SUCCESS);
+    }
     SoftBusFree(nativeFilter);
     SoftBusMutexUnlock(&g_scannerLock);
     return SOFTBUS_OK;
@@ -443,7 +553,7 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
 static int32_t StopScan(int32_t scannerId)
 {
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-        CLOGE("lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
@@ -453,51 +563,83 @@ static int32_t StopScan(int32_t scannerId)
     g_scanChannel[scannerId].isScanning = false;
     if (BleStopScan(g_scanChannel[scannerId].scannerId) != OHOS_BT_STATUS_SUCCESS) {
         SoftBusMutexUnlock(&g_scannerLock);
-        CLOGE("scan %d, stop scan failed", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "scan %d, stop scan failed", scannerId);
         return SOFTBUS_ERR;
     }
+    if (g_scanChannel[scannerId].scanCallback != NULL &&
+            g_scanChannel[scannerId].scanCallback->OnStopScanCallback != NULL) {
+        g_scanChannel[scannerId].scanCallback->OnStopScanCallback(scannerId, SOFTBUS_BC_STATUS_SUCCESS);
+    }
     SoftBusMutexUnlock(&g_scannerLock);
     return SOFTBUS_OK;
 }
 
-void SoftbusBleAdapterInit()
+static bool IsLpAvailable(void)
 {
-    static SoftbusBroadcastMediumInterface interface = {
-        .Init = Init,
-        .DeInit = DeInit,
-        .RegisterBroadcaster = RegisterBroadcaster,
-        .UnRegisterBroadcaster = UnRegisterBroadcaster,
-        .RegisterScanListener = RegisterScanListener,
-        .UnRegisterScanListener = UnRegisterScanListener,
-        .StartBroadcasting = StartBroadcasting,
-        .StopBroadcasting = StopBroadcasting,
-        .StartScan = StartScan,
-        .StopScan = StopScan
-    };
-    if (RegisterBroadcastMediumFunction(BROADCAST_MEDIUM_TYPE_BLE, &interface) != 0) {
-        CLOGW("Register gatt interface failed.");
+    return IsLpDeviceAvailable();
+}
+
+static bool SetLpParam(SoftBusLpBroadcastParam *bcParam, SoftBusLpScanParam *scanParam)
+{
+    BleScanConfigs scanConfig;
+    scanConfig.scanMode = GetBtScanMode(scanParam->scanParam.scanInterval, scanParam->scanParam.scanWindow);
+    BtLpDeviceParam btLpDeviceParam;
+    btLpDeviceParam.scanConfig = &scanConfig;
+    SoftbusFilterToBt(btLpDeviceParam.filter, scanParam->filter, scanParam->filterSize);
+    btLpDeviceParam.filterSize = (unsigned int)scanParam->filterSize;
+    SoftbusAdvParamToBt(&bcParam->bcParam, &btLpDeviceParam.advParam);
+    btLpDeviceParam.rawData.advData = AssembleAdvData(&bcParam->advData,
+        (uint16_t *)&btLpDeviceParam.rawData.advDataLen);
+    btLpDeviceParam.rawData.rspData = AssembleRspData(&bcParam->advData.rspData,
+        (uint16_t *)&btLpDeviceParam.rawData.rspDataLen);
+    BtUuid btUuid;
+    btUuid.uuid = LP_BT_UUID;
+    btUuid.uuidLen = (unsigned char)strlen(LP_BT_UUID);
+    btLpDeviceParam.uuid = btUuid;
+    btLpDeviceParam.activeDeviceInfo = NULL;
+    btLpDeviceParam.activeDeviceSize = 0;
+    btLpDeviceParam.deliveryMode = LP_DELIVERY_MODE_REPLY;
+    btLpDeviceParam.advHandle = bcParam->advHandle;
+    btLpDeviceParam.duration = LP_ADV_DURATION_MS;
+    int32_t ret = SetLpDeviceParam(&btLpDeviceParam);
+    SoftBusFree(btLpDeviceParam.rawData.advData);
+    SoftBusFree(btLpDeviceParam.rawData.rspData);
+    if (ret != OHOS_BT_STATUS_SUCCESS) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "SetLpDeviceParam failed");
+        return false;
     }
+    return true;
 }
 
-bool SoftBusBcIsLpDeviceAvailable(void)
+static int32_t GetBroadcastHandle(int32_t advId, int32_t *bcHandle)
 {
-    return IsLpDeviceAvailable();
+    if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed");
+        return SOFTBUS_LOCK_ERR;
+    }
+    if (!CheckAdvChannelInUsed(advId)) {
+        SoftBusMutexUnlock(&g_advLock);
+        return SOFTBUS_ERR;
+    }
+    int32_t ret = GetAdvHandle(g_advChannel[advId].advId, bcHandle);
+    SoftBusMutexUnlock(&g_advLock);
+    return ret;
 }
 
-int32_t SoftBusBcEnableSyncDataToLpDevice(void)
+static int32_t EnableSyncDataToLp(void)
 {
     return EnableSyncDataToLpDevice();
 }
 
-int32_t SoftBusBcDisableSyncDataToLpDevice(void)
+static int32_t DisableSyncDataToLp(void)
 {
     return DisableSyncDataToLpDevice();
 }
 
-int32_t SoftBusBcSetScanReportChannelToLpDevice(int scannerId, bool enable)
+static int32_t SetScanReportChannelToLp(int32_t scannerId, bool enable)
 {
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-        CLOGE("lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
@@ -509,8 +651,36 @@ int32_t SoftBusBcSetScanReportChannelToLpDevice(int scannerId, bool enable)
     return ret;
 }
 
-int32_t SoftBusBcSetLpDeviceParam(int duration, int maxExtAdvEvents, int window,
-    int interval, int advHandle)
+static int32_t SetLpAdvParam(int32_t duration, int32_t maxExtAdvEvents, int32_t window,
+    int32_t interval, int32_t bcHandle)
+{
+    return SetLpDeviceAdvParam(duration, maxExtAdvEvents, window, interval, bcHandle);
+}
+
+void SoftbusBleAdapterInit(void)
 {
-    return SetLpDeviceAdvParam(duration, maxExtAdvEvents, window, interval, advHandle);
+    static SoftbusBroadcastMediumInterface interface = {
+        .Init = Init,
+        .DeInit = DeInit,
+        .RegisterBroadcaster = RegisterAdvCallback,
+        .UnRegisterBroadcaster = UnRegisterAdvCallback,
+        .RegisterScanListener = RegisterScanCallback,
+        .UnRegisterScanListener = UnRegisterScanCallback,
+        .StartBroadcasting = StartAdv,
+        .StopBroadcasting = StopAdv,
+        .SetBroadcastingData = SetAdvData,
+        .UpdateBroadcasting = UpdateAdvData,
+        .StartScan = StartScan,
+        .StopScan = StopScan,
+        .IsLpDeviceAvailable = IsLpAvailable,
+        .SetAdvFilterParam = SetLpParam,
+        .GetBroadcastHandle = GetBroadcastHandle,
+        .EnableSyncDataToLpDevice  = EnableSyncDataToLp,
+        .DisableSyncDataToLpDevice = DisableSyncDataToLp,
+        .SetScanReportChannelToLpDevice = SetScanReportChannelToLp,
+        .SetLpDeviceParam = SetLpAdvParam,
+    };
+    if (RegisterBroadcastMediumFunction(BROADCAST_MEDIUM_TYPE_BLE, &interface) != 0) {
+        DISC_LOGW(DISC_BLE_ADAPTER, "Register gatt interface failed.");
+    }
 }
\ No newline at end of file
-- 
Gitee


From af955ed89b7edcb910c4ca840f82953c5018e94c Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Thu, 14 Dec 2023 09:32:40 +0000
Subject: [PATCH 56/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/include/softbus=5Fbroadcast=5Fadapter=5Finterfac?=
 =?UTF-8?q?e.h.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5?=
 =?UTF-8?q?=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1?=
 =?UTF-8?q?=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/include/softbus_broadcast_adapter_interface.h       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
index 098dc53f0d..8a91701dda 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/include/softbus_broadcast_adapter_interface.h
@@ -63,7 +63,7 @@ typedef struct {
  * @since 4.1
  * @version 1.0
  */
-typedef struct {
+typedef struct{
     int32_t (*Init)(void);
     int32_t (*DeInit)(void);
     int32_t (*RegisterBroadcaster)(int32_t *advId, const SoftbusBroadcastCallback *cb);
-- 
Gitee


From c2e47c508e1e6395392c94a55a70934284256696 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Thu, 14 Dec 2023 09:33:44 +0000
Subject: [PATCH 57/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/interface/softbus=5Fbroadcast=5Ftype.h.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/interface/softbus_broadcast_type.h    | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
index 2c9bd520d2..402f0502a5 100644
--- a/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
+++ b/adapter/common/net/bluetooth/broadcast/interface/softbus_broadcast_type.h
@@ -37,7 +37,6 @@ extern "C"{
  * @version 1.0
  */
 #define BC_ADDR_MAC_LEN 6
-
 // Bluetooth scan duty cycle, unit: ms
 #define SOFTBUS_BC_SCAN_INTERVAL_P2 3000
 #define SOFTBUS_BC_SCAN_INTERVAL_P10 600
@@ -141,7 +140,7 @@ typedef enum {
     SOFTBUS_BC_DATA_COMPLETE = 0x00,
     SOFTBUS_BC_DATA_INCOMPLETE_MORE_TO_COME = 0x01,
     SOFTBUS_BC_DATA_INCOMPLETE_TRUNCATED = 0x02,
-} SoftBusBcScanResultDataStatus;
+} SoftBusScanResultDataStatus;
 
 typedef enum {
     SOFTBUS_BC_BT_STATE_TURNING_ON = 0x0,
@@ -153,7 +152,6 @@ typedef enum {
     SOFTBUS_BC_BR_STATE_TURNING_OFF,
     SOFTBUS_BC_BR_STATE_TURN_OFF
 } SoftBusBcStackState;
-
 /**
  * @brief Defines the broadcast data information
  *
-- 
Gitee


From 29b3ff748be08ff047dc22695cbf30035d546f6d Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 15 Dec 2023 02:27:31 +0000
Subject: [PATCH 58/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Futils.h.=20gatt=20ad?=
 =?UTF-8?q?apter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
index a8ae773617..f0d755b3cd 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
@@ -41,6 +41,8 @@ void BtScanResultToSoftbus(const BtScanResultData *src, SoftBusBcScanResult *dst
 
 void SoftbusFilterToBt(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFilter *filter, uint8_t filterSize);
 
+void FreeBtFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize);
+
 void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize);
 
 int GetBtScanMode(uint16_t scanInterval, uint16_t scanWindow);
-- 
Gitee


From ea22fea15a6106270c19dd66bc7fc344e2b7e525 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 15 Dec 2023 02:40:25 +0000
Subject: [PATCH 59/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/net?=
 =?UTF-8?q?=5Fbluetooth.gni.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91?=
 =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4?=
 =?UTF-8?q?=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 adapter/common/net/bluetooth/net_bluetooth.gni | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/adapter/common/net/bluetooth/net_bluetooth.gni b/adapter/common/net/bluetooth/net_bluetooth.gni
index ea5c540875..249e3d0b69 100644
--- a/adapter/common/net/bluetooth/net_bluetooth.gni
+++ b/adapter/common/net/bluetooth/net_bluetooth.gni
@@ -18,9 +18,6 @@ adapter_ble_inc = [
   "$dsoftbus_root_path/core/common/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common",
-  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/interface",
-  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/include",
-  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/include",
 ]
 adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/ble/softbus_adapter_ble_gatt.c",
@@ -28,9 +25,6 @@ adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/ble/softbus_adapter_ble_gatt_server.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/adapter_bt_utils.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c",
-  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c",
-  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c",
-  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c",
 ]
 adapter_net_br_src = [ "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c" ]
 adapter_ble_external_deps = [ "bluetooth:btframework" ]
-- 
Gitee


From 9b545423c5a8626581ec111927164a9f2bbe1cc4 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 15 Dec 2023 03:18:58 +0000
Subject: [PATCH 60/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_utils.c       | 54 +++++++++++--------
 1 file changed, 33 insertions(+), 21 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index 915d11fa00..cca9dddd70 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -251,40 +251,50 @@ void SoftbusFilterToBt(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFil
         (nativeFilter + filterSize)->manufactureDataMask = (unsigned char *)(filter + filterSize)->manufactureDataMask;
         (nativeFilter + filterSize)->manufactureId = (unsigned short)(filter + filterSize)->manufactureId;
 
+        if ((filter + filterSize)->serviceData == NULL || (filter + filterSize)->serviceDataMask) {
+            continue;
+        }
+
         // serviceData = uuid + serviceData, serviceDataMask = 0xFFFF + serviceDataMask
         uint16_t serviceUuid = (filter + filterSize)->serviceUuid;
         uint16_t serviceDataLen = (filter + filterSize)->serviceDataLength + 2;
         uint8_t *serviceData = (uint8_t *)SoftBusCalloc(serviceDataLen);
-        if (serviceData != NULL) {
-            serviceData[0] = serviceUuid & BC_BYTE_MASK;
-            serviceData[1] = (serviceUuid >> BC_SHIFT_BIT) & BC_BYTE_MASK;
-            if(memcpy_s(serviceData + 2, serviceDataLen - 2, (filter + filterSize)->serviceData,
-                serviceDataLen - 2) != EOK) {
-                DISC_LOGW(DISC_BLE_ADAPTER, "copy service data failed");
-            }
-        } else {
+        if (serviceData == NULL) {
             DISC_LOGW(DISC_BLE_ADAPTER, "malloc service data failed");
             continue;
         }
+        serviceData[0] = serviceUuid & BC_BYTE_MASK;
+        serviceData[1] = (serviceUuid >> BC_SHIFT_BIT) & BC_BYTE_MASK;
+        if(memcpy_s(serviceData + 2, serviceDataLen - 2, (filter + filterSize)->serviceData,
+            serviceDataLen - 2) != EOK) {
+            DISC_LOGW(DISC_BLE_ADAPTER, "copy service data failed");
+        }
         uint8_t *serviceDataMask = (uint8_t *)SoftBusCalloc(serviceDataLen);
-        if (serviceDataMask != NULL) {
-            serviceDataMask[0] = BC_BYTE_MASK;
-            serviceDataMask[1] = BC_BYTE_MASK;
-            if(memcpy_s(serviceDataMask + 2, serviceDataLen - 2, (filter + filterSize)->serviceDataMask,
-                serviceDataLen - 2) != EOK) {
-                DISC_LOGW(DISC_BLE_ADAPTER, "copy service data mask failed");
-            }
-        } else {
+        if (serviceDataMask == NULL) {
             SoftBusFree(serviceData);
             DISC_LOGW(DISC_BLE_ADAPTER, "malloc service data mask failed");
             continue;
         }
+        serviceDataMask[0] = BC_BYTE_MASK;
+        serviceDataMask[1] = BC_BYTE_MASK;
+        if(memcpy_s(serviceDataMask + 2, serviceDataLen - 2, (filter + filterSize)->serviceDataMask,
+            serviceDataLen - 2) != EOK) {
+            DISC_LOGW(DISC_BLE_ADAPTER, "copy service data mask failed");
+        }
         (nativeFilter + filterSize)->serviceData = (unsigned char *)serviceData;
         (nativeFilter + filterSize)->serviceDataLength = (unsigned int)serviceDataLen;
         (nativeFilter + filterSize)->serviceDataMask = (unsigned char *)serviceDataMask;
     }
 }
 
+void FreeBtFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
+{
+    while (filterSize-- > 0) {
+        SoftBusFree((nativeFilter + filterSize)->serviceData);
+        SoftBusFree((nativeFilter + filterSize)->serviceDataMask);
+    }
+}
+
 void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
 {
     while (filterSize-- > 0) {
@@ -335,18 +345,20 @@ uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen)
         DISC_LOGE(DISC_BLE_ADAPTER, "malloc adv data failed");
         return NULL;
     }
+    int8_t offset = -BC_FLAG_LEN;
     if (data->isSupportFlag) {
         advData[IDX_BC_FLAG_BYTE_LEN] = BC_FLAG_BYTE_LEN;
         advData[IDX_BC_FLAG_AD_TYPE] = BC_FLAG_AD_TYPE;
         advData[IDX_BC_FLAG_AD_DATA] = data->flag;
+        offset += BC_FLAG_LEN;
     }
-    advData[IDX_PACKET_LEN] = *dataLen - IDX_PACKET_LEN - 1;
-    advData[IDX_BC_TYPE] = SoftbusAdvTypeToBt(data->bcData.type);
+    advData[IDX_PACKET_LEN + offset] = *dataLen - IDX_PACKET_LEN - 1;
+    advData[IDX_BC_TYPE + offset] = SoftbusAdvTypeToBt(data->bcData.type);
     uint16_t payloadId = data->bcData.id;
-    advData[IDX_BC_UUID] = (uint8_t)(payloadId & BC_BYTE_MASK);
-    advData[IDX_BC_UUID + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
+    advData[IDX_BC_UUID + offset] = (uint8_t)(payloadId & BC_BYTE_MASK);
+    advData[IDX_BC_UUID + offset + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
 
-    if (memcpy_s(&advData[BC_HEAD_LEN], payloadLen, data->bcData.payload, payloadLen) != EOK) {
+    if (memcpy_s(&advData[BC_HEAD_LEN + offset], payloadLen, data->bcData.payload, payloadLen) != EOK) {
         DISC_LOGE(DISC_BLE_ADAPTER, "copy adv payload failed");
         SoftBusFree(advData);
         return NULL;
-- 
Gitee


From 3a1dc57ea74b14665940930dd16906daaf0cd3f1 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 15 Dec 2023 03:19:22 +0000
Subject: [PATCH 61/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 44 +++++++++++--------
 1 file changed, 26 insertions(+), 18 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 61b3b5f5bc..2a788719ee 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -545,6 +545,7 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
             g_scanChannel[scannerId].scanCallback->OnStartScanCallback != NULL) {
         g_scanChannel[scannerId].scanCallback->OnStartScanCallback(scannerId, SOFTBUS_BC_STATUS_SUCCESS);
     }
+    FreeBtFilter(nativeFilter, filterSize);
     SoftBusFree(nativeFilter);
     SoftBusMutexUnlock(&g_scannerLock);
     return SOFTBUS_OK;
@@ -583,27 +584,34 @@ static bool SetLpParam(SoftBusLpBroadcastParam *bcParam, SoftBusLpScanParam *sca
 {
     BleScanConfigs scanConfig;
     scanConfig.scanMode = GetBtScanMode(scanParam->scanParam.scanInterval, scanParam->scanParam.scanWindow);
-    BtLpDeviceParam btLpDeviceParam;
-    btLpDeviceParam.scanConfig = &scanConfig;
-    SoftbusFilterToBt(btLpDeviceParam.filter, scanParam->filter, scanParam->filterSize);
-    btLpDeviceParam.filterSize = (unsigned int)scanParam->filterSize;
-    SoftbusAdvParamToBt(&bcParam->bcParam, &btLpDeviceParam.advParam);
-    btLpDeviceParam.rawData.advData = AssembleAdvData(&bcParam->advData,
-        (uint16_t *)&btLpDeviceParam.rawData.advDataLen);
-    btLpDeviceParam.rawData.rspData = AssembleRspData(&bcParam->advData.rspData,
-        (uint16_t *)&btLpDeviceParam.rawData.rspDataLen);
+    BtLpDeviceParam lpParam;
+    lpParam.scanConfig = &scanConfig;
+    lpParam.filter = (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * scanParam->filterSize);
+    if (lpParam.filter == NULL) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "malloc native filter failed");
+        return SOFTBUS_MALLOC_ERR;
+    }
+    SoftbusFilterToBt(lpParam.filter, scanParam->filter, scanParam->filterSize);
+    lpParam.filterSize = (unsigned int)scanParam->filterSize;
+    SoftbusAdvParamToBt(&bcParam->bcParam, &lpParam.advParam);
+    lpParam.rawData.advData = AssembleAdvData(&bcParam->advData,
+        (uint16_t *)&lpParam.rawData.advDataLen);
+    lpParam.rawData.rspData = AssembleRspData(&bcParam->advData.rspData,
+        (uint16_t *)&lpParam.rawData.rspDataLen);
     BtUuid btUuid;
     btUuid.uuid = LP_BT_UUID;
     btUuid.uuidLen = (unsigned char)strlen(LP_BT_UUID);
-    btLpDeviceParam.uuid = btUuid;
-    btLpDeviceParam.activeDeviceInfo = NULL;
-    btLpDeviceParam.activeDeviceSize = 0;
-    btLpDeviceParam.deliveryMode = LP_DELIVERY_MODE_REPLY;
-    btLpDeviceParam.advHandle = bcParam->advHandle;
-    btLpDeviceParam.duration = LP_ADV_DURATION_MS;
-    int32_t ret = SetLpDeviceParam(&btLpDeviceParam);
-    SoftBusFree(btLpDeviceParam.rawData.advData);
-    SoftBusFree(btLpDeviceParam.rawData.rspData);
+    lpParam.uuid = btUuid;
+    lpParam.activeDeviceInfo = NULL;
+    lpParam.activeDeviceSize = 0;
+    lpParam.deliveryMode = LP_DELIVERY_MODE_REPLY;
+    lpParam.advHandle = bcParam->advHandle;
+    lpParam.duration = LP_ADV_DURATION_MS;
+    int32_t ret = SetLpDeviceParam(&lpParam);
+    FreeBtFilter(lpParam.filter, scanParam->filterSize);
+    SoftBusFree(lpParam.filter);
+    SoftBusFree(lpParam.rawData.advData);
+    SoftBusFree(lpParam.rawData.rspData);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
         DISC_LOGE(DISC_BLE_ADAPTER, "SetLpDeviceParam failed");
         return false;
-- 
Gitee


From 55aef4536831d248603b7ed1df1ea0f5ed241b58 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 15 Dec 2023 03:30:27 +0000
Subject: [PATCH 62/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 2a788719ee..3021dea514 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -362,6 +362,9 @@ static int32_t UnRegisterScanCallback(int32_t scannerId)
     if (!g_scanChannel[scannerId].isUsed) {
         return SOFTBUS_OK;
     }
+    if (BleDeregisterScanCallbacks(g_scanChannel[scannerId].scannerId) != OHOS_BT_STATUS_SUCCESS) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "unregister ble scan callback failed");
+    }
     g_scanChannel[scannerId].scannerId = -1;
     g_scanChannel[scannerId].isUsed = false;
     g_scanChannel[scannerId].isScanning = false;
-- 
Gitee


From cea177005a9b006e96219cfa16c72b99d01d13d0 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 15 Dec 2023 03:36:31 +0000
Subject: [PATCH 63/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/ble/src/softbus_ble_gatt.c          | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 3021dea514..a14215472f 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -481,10 +481,10 @@ static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
 
 static int32_t UpdateAdvData(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
 {
-    (void)advId;
-    (void)param;
-    (void)data;
-    return SOFTBUS_ERR;
+    if (StopAdv(advId) != SOFTBUS_OK) {
+        return SOFTBUS_ERR;
+    }
+    return StartAdv(advId, param, data);
 }
 
 static bool CheckScanChannelInUsed(int32_t scannerId)
-- 
Gitee


From 84e1e45b23cbfa8a5c482be49c27143d00c26aac Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 15 Dec 2023 07:00:18 +0000
Subject: [PATCH 64/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index a14215472f..4990e04a9d 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -596,7 +596,7 @@ static bool SetLpParam(SoftBusLpBroadcastParam *bcParam, SoftBusLpScanParam *sca
     }
     SoftbusFilterToBt(lpParam.filter, scanParam->filter, scanParam->filterSize);
     lpParam.filterSize = (unsigned int)scanParam->filterSize;
-    SoftbusAdvParamToBt(&bcParam->bcParam, &lpParam.advParam);
+    SoftbusAdvParamToBt(&bcParam->advParam, &lpParam.advParam);
     lpParam.rawData.advData = AssembleAdvData(&bcParam->advData,
         (uint16_t *)&lpParam.rawData.advDataLen);
     lpParam.rawData.rspData = AssembleRspData(&bcParam->advData.rspData,
-- 
Gitee


From 5e6d6d2df5b5c7f7f5947819b5a4bf3a64a15150 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 18 Dec 2023 07:42:58 +0000
Subject: [PATCH 65/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 40 ++++++++++---------
 1 file changed, 21 insertions(+), 19 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 4990e04a9d..4a30d77ae2 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -14,22 +14,19 @@
  */
 
 #include "softbus_ble_gatt.h"
-#include "c_header/ohos_bt_gatt.h"
 #include "softbus_adapter_thread.h"
 #include "softbus_adapter_mem.h"
 #include "softbus_broadcast_type.h"
 #include "softbus_error_code.h"
-#include "softbus_utils.h"
 #include "softbus_ble_utils.h"
 #include "disc_log.h"
-#include "softbus_log_old.h"
 #include <stdatomic.h>
 #include <string.h>
 
 #define GATT_ADV_MAX_NUM 9
 #define GATT_SCAN_MAX_NUM 9
 #define LP_BT_UUID "43d4a49f-604d-45b5-9302-4ddbbfd538fd"
-#define LP_DELIVERY_MODE_REPLY 0xF0 // Lpdevice delivery mode: reply adv when filter matched
+#define LP_DELIVERY_MODE_REPLY 0xF0
 #define LP_ADV_DURATION_MS 0
 
 static atomic_bool g_init = false;
@@ -386,6 +383,23 @@ static bool CheckAdvChannelInUsed(int32_t advId)
     return true;
 }
 
+static int32_t StartBleAdv(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
+{
+    BleAdvParams advParam;
+    SoftbusAdvParamToBt(param, &advParam);
+    StartAdvRawData advRawData;
+    advRawData.advData = AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
+    advRawData.rspDataLen = 0;
+    advRawData.rspData = NULL;
+    if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
+        advRawData.rspData = AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
+    }
+    int32_t ret = BleStartAdvEx(&g_advChannel[advId].advId, advRawData, advParam);
+    SoftBusFree(advRawData.advData);
+    SoftBusFree(advRawData.rspData);
+    return ret == OHOS_BT_STATUS_SUCCESS ? SOFTBUS_OK : SOFTBUS_ERR;
+}
+
 static int32_t StartAdv(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
 {
     if (param == NULL || data == NULL || data->bcData.payloadLen == 0 || data->bcData.payload == NULL) {
@@ -404,22 +418,10 @@ static int32_t StartAdv(int32_t advId, const SoftbusBroadcastParam *param, const
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_OK;
     }
-    // 组装广播报文
-    BleAdvParams advParam;
-    SoftbusAdvParamToBt(param, &advParam);
-    StartAdvRawData advRawData;
-    advRawData.advData = AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
-    advRawData.rspDataLen = 0;
-    advRawData.rspData = NULL;
-    if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
-        advRawData.rspData = AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
-    }
-    int32_t ret = BleStartAdvEx(&g_advChannel[advId].advId, advRawData, advParam);
-    SoftBusFree(advRawData.advData);
-    SoftBusFree(advRawData.rspData);
-    g_advChannel[advId].isAdvertising = (ret != OHOS_BT_STATUS_SUCCESS);
+    int32_t ret = StartBleAdv(advId, param, data);
+    g_advChannel[advId].isAdvertising = (ret != SOFTBUS_OK);
     SoftBusMutexUnlock(&g_advLock);
-    if (ret != OHOS_BT_STATUS_SUCCESS) {
+    if (ret != SOFTBUS_OK) {
         DISC_LOGI(DISC_BLE_ADAPTER, "start adv failed");
         return SOFTBUS_ERR;
     }
-- 
Gitee


From bcd8fa03978a11235c24a2a5230098138804cd31 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 18 Dec 2023 07:44:02 +0000
Subject: [PATCH 66/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_utils.c       | 41 ++++++++++---------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index cca9dddd70..56c77c037e 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -19,7 +19,6 @@
 #include "softbus_utils.h"
 #include "softbus_broadcast_utils.h"
 #include "disc_log.h"
-#include "softbus_log_old.h"
 #include <securec.h>
 
 int32_t BtStatusToSoftBus(BtStatus btStatus)
@@ -69,7 +68,7 @@ int32_t BtStatusToSoftBus(BtStatus btStatus)
     return status;
 }
 
-static uint16_t SoftbusAdvTypeToBt(uint16_t advType)
+static uint16_t SoftbusAdvDataTypeToBt(uint16_t advType)
 {
     switch (advType) {
         case BC_DATA_TYPE_SERVICE:
@@ -93,7 +92,7 @@ static uint16_t BtAdvTypeToSoftbus(uint16_t advType)
     }
 }
 
-static BleAdvFilter ConvertAdvFilter(uint8_t advFilter)
+static BleAdvFilter SoftbusAdvFilterToBt(uint8_t advFilter)
 {
     switch (advFilter) {
         case SOFTBUS_BC_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY:
@@ -109,7 +108,7 @@ static BleAdvFilter ConvertAdvFilter(uint8_t advFilter)
     }
 }
 
-static BleAdvType ConvertAdvParamType(uint8_t advType)
+static BleAdvType SoftbusAdvTypeToBt(uint8_t advType)
 {
     switch (advType) {
         case SOFTBUS_BC_ADV_IND:
@@ -134,16 +133,16 @@ void SoftbusAdvParamToBt(const SoftbusBroadcastParam *src, BleAdvParams *dst)
     }
     dst->minInterval = src->minInterval;
     dst->maxInterval = src->maxInterval;
-    dst->advType = ConvertAdvParamType(src->advType);
+    dst->advType = SoftbusAdvTypeToBt(src->advType);
     dst->ownAddrType = (unsigned char)src->ownAddrType;
     dst->peerAddrType = (unsigned char)src->peerAddrType;
     dst->channelMap = src->channelMap;
-    dst->advFilterPolicy = ConvertAdvFilter(src->advFilterPolicy);
+    dst->advFilterPolicy = SoftbusAdvFilterToBt(src->advFilterPolicy);
     dst->txPower = src->txPower;
     dst->duration = src->duration;
 }
 
-static uint8_t ConvertScanEventType(unsigned char eventType)
+static uint8_t BtScanEventTypeToSoftbus(unsigned char eventType)
 {
     switch (eventType) {
         case OHOS_BLE_EVT_NON_CONNECTABLE_NON_SCANNABLE:
@@ -175,7 +174,7 @@ static uint8_t ConvertScanEventType(unsigned char eventType)
     }
 }
 
-static uint8_t ConvertScanDataStatus(unsigned char dataStatus)
+static uint8_t BtScanDataStatusToSoftbus(unsigned char dataStatus)
 {
     switch (dataStatus) {
         case OHOS_BLE_DATA_COMPLETE:
@@ -189,7 +188,7 @@ static uint8_t ConvertScanDataStatus(unsigned char dataStatus)
     }
 }
 
-static uint8_t ConvertScanAddrType(unsigned char addrType)
+static uint8_t BtScanAddrTypeToSoftbus(unsigned char addrType)
 {
     switch (addrType) {
         case OHOS_BLE_PUBLIC_DEVICE_ADDRESS:
@@ -209,7 +208,7 @@ static uint8_t ConvertScanAddrType(unsigned char addrType)
     }
 }
 
-static uint8_t ConvertScanPhyType(unsigned char phyType)
+static uint8_t BtScanPhyTypeToSoftbus(unsigned char phyType)
 {
     switch (phyType) {
         case OHOS_BLE_SCAN_PHY_NO_PACKET:
@@ -227,14 +226,14 @@ static uint8_t ConvertScanPhyType(unsigned char phyType)
 
 void BtScanResultToSoftbus(const BtScanResultData *src, SoftBusBcScanResult *dst)
 {
-    dst->eventType = ConvertScanEventType(src->eventType);
-    dst->dataStatus = ConvertScanDataStatus(src->dataStatus);
-    dst->addrType = ConvertScanAddrType(src->addrType);
+    dst->eventType = BtScanEventTypeToSoftbus(src->eventType);
+    dst->dataStatus = BtScanDataStatusToSoftbus(src->dataStatus);
+    dst->addrType = BtScanAddrTypeToSoftbus(src->addrType);
     if (memcpy_s(dst->addr.addr, SOFTBUS_ADDR_MAC_LEN, src->addr.addr, SOFTBUS_ADDR_MAC_LEN) != EOK) {
         DISC_LOGW(DISC_BLE_ADAPTER, "copy addr failed");
     }
-    dst->primaryPhy = ConvertScanPhyType(src->primaryPhy);
-    dst->secondaryPhy = ConvertScanPhyType(src->secondaryPhy);
+    dst->primaryPhy = BtScanPhyTypeToSoftbus(src->primaryPhy);
+    dst->secondaryPhy = BtScanPhyTypeToSoftbus(src->secondaryPhy);
     dst->advSid = (uint8_t)src->advSid;
     dst->txPower = (int8_t)src->txPower;
     dst->rssi = (int8_t)src->rssi;
@@ -304,10 +303,12 @@ void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
         }
         uint32_t hexLen = HEXIFY_LEN(len);
         char *serviceData = (char *)SoftBusCalloc(sizeof(char) * hexLen);
+        if (serviceData == NULL) {
+            continue;
+        }
         char *serviceDataMask = (char *)SoftBusCalloc(sizeof(char) * hexLen);
-        if (serviceData == NULL || serviceDataMask == NULL) {
+        if (serviceDataMask == NULL) {
             SoftBusFree(serviceData);
-            SoftBusFree(serviceDataMask);
             continue;
         }
         (void)ConvertBytesToHexString(serviceData, hexLen, (nativeFilter + filterSize)->serviceData, len);
@@ -353,7 +354,7 @@ uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen)
         offset += BC_FLAG_LEN;
     }
     advData[IDX_PACKET_LEN + offset] = *dataLen - IDX_PACKET_LEN - 1;
-    advData[IDX_BC_TYPE + offset] = SoftbusAdvTypeToBt(data->bcData.type);
+    advData[IDX_BC_TYPE + offset] = SoftbusAdvDataTypeToBt(data->bcData.type);
     uint16_t payloadId = data->bcData.id;
     advData[IDX_BC_UUID + offset] = (uint8_t)(payloadId & BC_BYTE_MASK);
     advData[IDX_BC_UUID + offset + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
@@ -376,7 +377,7 @@ uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen)
         return NULL;
     }
     rspData[IDX_RSP_PACKET_LEN] = *dataLen - IDX_RSP_PACKET_LEN - 1;
-    rspData[IDX_RSP_TYPE] = SoftbusAdvTypeToBt(data->type);
+    rspData[IDX_RSP_TYPE] = SoftbusAdvDataTypeToBt(data->type);
     uint16_t payloadId = data->id;
     rspData[IDX_RSP_UUID] = (uint8_t)(payloadId & BC_BYTE_MASK);
     rspData[IDX_RSP_UUID + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
@@ -410,7 +411,7 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
         } else {
             if (type != SERVICE_BC_TYPE && type != MANUFACTURE_BC_TYPE) {
                 index += len;
-                CLOGD("unsupported adv type: %u", type);
+                DISC_LOGI(DISC_BLE_ADAPTER, "unsupported adv type: %u", type);
                 continue;
             }
             uint8_t *payload = (uint8_t *)SoftBusCalloc(len -3);
-- 
Gitee


From 808285589266e2990de5d35a0a187e9faaa1e8fd Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 18 Dec 2023 07:44:40 +0000
Subject: [PATCH 67/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/net?=
 =?UTF-8?q?=5Fbluetooth.gni.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91?=
 =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4?=
 =?UTF-8?q?=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../common/net/bluetooth/net_bluetooth.gni    | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/adapter/common/net/bluetooth/net_bluetooth.gni b/adapter/common/net/bluetooth/net_bluetooth.gni
index 249e3d0b69..be827bea49 100644
--- a/adapter/common/net/bluetooth/net_bluetooth.gni
+++ b/adapter/common/net/bluetooth/net_bluetooth.gni
@@ -18,6 +18,9 @@ adapter_ble_inc = [
   "$dsoftbus_root_path/core/common/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/include",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/interface",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/include",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/include",
 ]
 adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/ble/softbus_adapter_ble_gatt.c",
@@ -25,7 +28,24 @@ adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/ble/softbus_adapter_ble_gatt_server.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/adapter_bt_utils.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c",
 ]
+
+if (dsoftbus_feature_ex_kits) {
+  adapter_ble_inc += [
+    "$dsoftbus_root_path/dsoftbus_enhance/adapter/common/net/bluetooth/broadcast/adapter/ble/include",
+  ]
+  adapter_ble_src += [
+    "$dsoftbus_root_path/dsoftbus_enhance/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_enhance_ble_utils.c",
+    "$dsoftbus_root_path/dsoftbus_enhance/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c",
+  ]
+} else {
+  adapter_ble_src += [
+    "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c",
+  ]
+}
+
 adapter_net_br_src = [ "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c" ]
 adapter_ble_external_deps = [ "bluetooth:btframework" ]
 if (defined(ohos_lite)) {
-- 
Gitee


From dbce84a2fce811577f19c7493559bca323e58372 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 18 Dec 2023 11:23:21 +0000
Subject: [PATCH 68/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 25 +++++++++----------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 4a30d77ae2..d89c8aa603 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -165,7 +165,8 @@ static void WrapperAdvUpdateDataCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "update adv data callback, advId: %d, bt-advId: %d, status: %d", channelId, advId, st);
+        DISC_LOGI(DISC_BLE_ADAPTER, "update adv data callback, advId: %d, bt-advId: %d, status: %d",
+            channelId, advId, st);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnSetBroadcastingCallback != NULL) {
             advChannel->advCallback->OnUpdateBroadcastingCallback(channelId, st);
         }
@@ -534,24 +535,22 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     }
     SoftbusFilterToBt(nativeFilter, scanFilter, filterSize);
     DumpBleScanFilter(nativeFilter, filterSize);
-    BleScanConfigs scanConfig = {
-        .scanMode = GetBtScanMode(param->scanInterval, param->scanWindow),
-        .phy = (int)param->scanPhy
-    };
-    if (BleStartScanEx(g_scanChannel[scannerId].scannerId, &scanConfig, nativeFilter,
-        filterSize) != OHOS_BT_STATUS_SUCCESS) {
-        SoftBusFree(nativeFilter);
+    BleScanConfigs scanConfig;
+    scanConfig.scanMode = GetBtScanMode(param->scanInterval, param->scanWindow);
+    scanConfig.phy = (int)param->scanPhy;
+    int32_t ret = BleStartScanEx(g_scanChannel[scannerId].scannerId, &scanConfig, nativeFilter, filterSize);
+    FreeBtFilter(nativeFilter, filterSize);
+    SoftBusFree(nativeFilter);
+    g_scanChannel[scannerId].isScanning = (ret != OHOS_BT_STATUS_SUCCESS);
+    if (ret != OHOS_BT_STATUS_SUCCESS) {
         SoftBusMutexUnlock(&g_scannerLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "scan %d, start scan failed", scannerId);
         return SOFTBUS_ERR;
     }
-    g_scanChannel[scannerId].isScanning = true;
     if (g_scanChannel[scannerId].scanCallback != NULL &&
             g_scanChannel[scannerId].scanCallback->OnStartScanCallback != NULL) {
         g_scanChannel[scannerId].scanCallback->OnStartScanCallback(scannerId, SOFTBUS_BC_STATUS_SUCCESS);
     }
-    FreeBtFilter(nativeFilter, filterSize);
-    SoftBusFree(nativeFilter);
     SoftBusMutexUnlock(&g_scannerLock);
     return SOFTBUS_OK;
 }
@@ -585,7 +584,7 @@ static bool IsLpAvailable(void)
     return IsLpDeviceAvailable();
 }
 
-static bool SetLpParam(SoftBusLpBroadcastParam *bcParam, SoftBusLpScanParam *scanParam)
+static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpScanParam *scanParam)
 {
     BleScanConfigs scanConfig;
     scanConfig.scanMode = GetBtScanMode(scanParam->scanParam.scanInterval, scanParam->scanParam.scanWindow);
-- 
Gitee


From b751f7abadcb9e781021374a630fe313276197e5 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Mon, 18 Dec 2023 11:23:44 +0000
Subject: [PATCH 69/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index 56c77c037e..ee8648f4f3 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
-- 
Gitee


From 485e59aad57b7053a9fe381f4e4425a836916cc4 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Tue, 19 Dec 2023 08:36:30 +0000
Subject: [PATCH 70/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index d89c8aa603..6a2b757a88 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -420,7 +420,7 @@ static int32_t StartAdv(int32_t advId, const SoftbusBroadcastParam *param, const
         return SOFTBUS_OK;
     }
     int32_t ret = StartBleAdv(advId, param, data);
-    g_advChannel[advId].isAdvertising = (ret != SOFTBUS_OK);
+    g_advChannel[advId].isAdvertising = (ret == SOFTBUS_OK);
     SoftBusMutexUnlock(&g_advLock);
     if (ret != SOFTBUS_OK) {
         DISC_LOGI(DISC_BLE_ADAPTER, "start adv failed");
@@ -541,7 +541,7 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     int32_t ret = BleStartScanEx(g_scanChannel[scannerId].scannerId, &scanConfig, nativeFilter, filterSize);
     FreeBtFilter(nativeFilter, filterSize);
     SoftBusFree(nativeFilter);
-    g_scanChannel[scannerId].isScanning = (ret != OHOS_BT_STATUS_SUCCESS);
+    g_scanChannel[scannerId].isScanning = (ret == OHOS_BT_STATUS_SUCCESS);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
         SoftBusMutexUnlock(&g_scannerLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "scan %d, start scan failed", scannerId);
-- 
Gitee


From 7ff22aa9e82e6a2ec466a7790812b4d3236440db Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Tue, 19 Dec 2023 13:04:21 +0000
Subject: [PATCH 71/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 104 ++++++++++--------
 1 file changed, 61 insertions(+), 43 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 6a2b757a88..7d983f25c3 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -53,7 +53,7 @@ static ScanChannel g_scanChannel[GATT_SCAN_MAX_NUM];
 static int32_t Init(void)
 {
     if (g_init) {
-        DISC_LOGI(DISC_BLE_ADAPTER, "already init");
+        DISC_LOGI(DISC_BLE_ADAPTER, "already inited");
         return SOFTBUS_OK;
     }
     g_init = true;
@@ -68,6 +68,7 @@ static int32_t Init(void)
         DISC_LOGE(DISC_BLE_ADAPTER, "g_scannerLock init failed");
         return SOFTBUS_ERR;
     }
+    DISC_LOGI(DISC_BLE_ADAPTER, "init success");
     g_init = true;
     return SOFTBUS_OK;
 }
@@ -75,9 +76,10 @@ static int32_t Init(void)
 static int32_t DeInit(void)
 {
     if (!g_init) {
-        DISC_LOGI(DISC_BLE_ADAPTER, "already deInit");
+        DISC_LOGI(DISC_BLE_ADAPTER, "already deInited");
         return SOFTBUS_OK;
     }
+    DISC_LOGI(DISC_BLE_ADAPTER, "deinit success");
     g_init = false;
     SoftBusMutexDestroy(&g_advLock);
     SoftBusMutexDestroy(&g_scannerLock);
@@ -97,7 +99,7 @@ static void WrapperAdvEnableCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "start adv callback, adv: %u, bt-advId: %d, status: %d", channelId, advId, st);
+        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
         advChannel->isAdvertising = (st == SOFTBUS_BC_STATUS_SUCCESS);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnStartBroadcastingCallback != NULL) {
             advChannel->advCallback->OnStartBroadcastingCallback(channelId, st);
@@ -120,8 +122,8 @@ static void WrapperAdvDisableCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "stop adv callback, advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
-        advChannel->isAdvertising = (st == SOFTBUS_BC_STATUS_SUCCESS);
+        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
+        advChannel->isAdvertising = false;
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnStopBroadcastingCallback != NULL) {
             advChannel->advCallback->OnStopBroadcastingCallback(channelId, st);
         }
@@ -143,7 +145,7 @@ static void WrapperAdvSetDataCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "set adv data callback, advId: %d, bt-advId: %d, status: %d", channelId, advId, st);
+        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnSetBroadcastingCallback != NULL) {
             advChannel->advCallback->OnSetBroadcastingCallback(channelId, st);
         }
@@ -165,8 +167,7 @@ static void WrapperAdvUpdateDataCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "update adv data callback, advId: %d, bt-advId: %d, status: %d",
-            channelId, advId, st);
+        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnSetBroadcastingCallback != NULL) {
             advChannel->advCallback->OnUpdateBroadcastingCallback(channelId, st);
         }
@@ -185,7 +186,7 @@ static BtGattCallbacks g_softbusGattCb = {
 static int32_t RegisterAdvCallback(int32_t *advId, const SoftbusBroadcastCallback *cb)
 {
     if (advId == NULL || cb == NULL) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "invalid param");
+        DISC_LOGE(DISC_BLE_ADAPTER, "adv param is null");
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
@@ -197,7 +198,7 @@ static int32_t RegisterAdvCallback(int32_t *advId, const SoftbusBroadcastCallbac
             continue;
         }
         if (BleGattRegisterCallbacks(&g_softbusGattCb) != OHOS_BT_STATUS_SUCCESS) {
-            DISC_LOGE(DISC_BLE_ADAPTER, "register adv cb failed: %u", channelId);
+            DISC_LOGE(DISC_BLE_ADAPTER, "register failed, advId: %u", channelId);
             SoftBusMutexUnlock(&g_advLock);
             return SOFTBUS_ERR;
         }
@@ -206,6 +207,7 @@ static int32_t RegisterAdvCallback(int32_t *advId, const SoftbusBroadcastCallbac
         g_advChannel[channelId].isAdvertising = false;
         g_advChannel[channelId].advCallback = (SoftbusBroadcastCallback *)cb;
         *advId = channelId;
+        DISC_LOGI(DISC_BLE_ADAPTER, "register success, advId: %u", channelId);
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_OK;
     }
@@ -226,9 +228,10 @@ static int32_t UnRegisterAdvCallback(int32_t advId)
     }
     if (!g_advChannel[advId].isUsed) {
         SoftBusMutexUnlock(&g_advLock);
-        DISC_LOGE(DISC_BLE_ADAPTER, "adv %d callback already unregistered", advId);
+        DISC_LOGI(DISC_BLE_ADAPTER, "already unregistered, advId: %d", advId);
         return SOFTBUS_OK;
     }
+    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
     g_advChannel[advId].advId = -1;
     g_advChannel[advId].isUsed = false;
     g_advChannel[advId].isAdvertising = false;
@@ -277,10 +280,11 @@ static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
             SoftBusMutexUnlock(&g_scannerLock);
             continue;
         }
+        DISC_LOGI(DISC_BLE_ADAPTER, "resultCode: %d, isStartScan: %d", resultCode, isStartScan);
         if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnScanStateChanged != NULL) {
             scanChannel->scanCallback->OnScanStateChanged(resultCode, isStartScan);
         }
-        scanChannel->isScanning = isStartScan ? (resultCode == 0) : !(resultCode == 0);
+        scanChannel->isScanning = isStartScan ? (resultCode == 0) : false;
         SoftBusMutexUnlock(&g_scannerLock);
         break;
     }
@@ -318,7 +322,7 @@ static BleScanCallbacks g_softbusBleScanCb = {
 static int32_t RegisterScanCallback(int32_t *scannerId, const SoftbusScanCallback *cb)
 {
     if (scannerId == NULL || cb == NULL) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "invalid param");
+        DISC_LOGE(DISC_BLE_ADAPTER, "scan param is null");
         return SOFTBUS_ERR;
     }
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
@@ -331,7 +335,7 @@ static int32_t RegisterScanCallback(int32_t *scannerId, const SoftbusScanCallbac
         }
         if (BleRegisterScanCallbacks(&g_softbusBleScanCb,
             &g_scanChannel[channelId].scannerId) !=OHOS_BT_STATUS_SUCCESS) {
-            DISC_LOGE(DISC_BLE_ADAPTER, "register ble scan callback failed");
+            DISC_LOGE(DISC_BLE_ADAPTER, "register callback failed");
             SoftBusMutexUnlock(&g_scannerLock);
             return SOFTBUS_ERR;
         }
@@ -339,6 +343,7 @@ static int32_t RegisterScanCallback(int32_t *scannerId, const SoftbusScanCallbac
         g_scanChannel[channelId].isScanning = false;
         g_scanChannel[channelId].scanCallback = (SoftbusScanCallback *)cb;
         *scannerId = channelId;
+        DISC_LOGI(DISC_BLE_ADAPTER, "scannerId: %u, bt-scannerId: %d", channelId, g_scanChannel[channelId].scannerId);
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_OK;
     }
@@ -350,7 +355,7 @@ static int32_t RegisterScanCallback(int32_t *scannerId, const SoftbusScanCallbac
 static int32_t UnRegisterScanCallback(int32_t scannerId)
 {
     if (scannerId < 0 || scannerId >= GATT_SCAN_MAX_NUM) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "invalid scannerId: %d", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "scannerId is invalid: %d", scannerId);
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
@@ -358,11 +363,13 @@ static int32_t UnRegisterScanCallback(int32_t scannerId)
         return SOFTBUS_LOCK_ERR;
     }
     if (!g_scanChannel[scannerId].isUsed) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "already unregistered, scannerId: %d, bt-scannerId: %d",
+            scannerId, g_scanChannel[scannerId].scannerId);
         return SOFTBUS_OK;
     }
-    if (BleDeregisterScanCallbacks(g_scanChannel[scannerId].scannerId) != OHOS_BT_STATUS_SUCCESS) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "unregister ble scan callback failed");
-    }
+    int32_t ret = BleDeregisterScanCallbacks(g_scanChannel[scannerId].scannerId);
+    DISC_LOGI(DISC_BLE_ADAPTER, "scannerId: %d, bt-scannerId: %d, result: %d",
+        scannerId, g_scanChannel[scannerId].scannerId, ret);
     g_scanChannel[scannerId].scannerId = -1;
     g_scanChannel[scannerId].isUsed = false;
     g_scanChannel[scannerId].isScanning = false;
@@ -378,7 +385,7 @@ static bool CheckAdvChannelInUsed(int32_t advId)
         return false;
     }
     if (!g_advChannel[advId].isUsed) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "adv %d is not in used", advId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
         return false;
     }
     return true;
@@ -404,7 +411,7 @@ static int32_t StartBleAdv(int32_t advId, const SoftbusBroadcastParam *param, co
 static int32_t StartAdv(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
 {
     if (param == NULL || data == NULL || data->bcData.payloadLen == 0 || data->bcData.payload == NULL) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "invalid param");
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid adv param");
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
@@ -416,14 +423,16 @@ static int32_t StartAdv(int32_t advId, const SoftbusBroadcastParam *param, const
         return SOFTBUS_ERR;
     }
     if (g_advChannel[advId].isAdvertising) {
+        DISC_LOGI(DISC_BLE_ADAPTER, "already started, advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_OK;
     }
     int32_t ret = StartBleAdv(advId, param, data);
+    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
     g_advChannel[advId].isAdvertising = (ret == SOFTBUS_OK);
     SoftBusMutexUnlock(&g_advLock);
     if (ret != SOFTBUS_OK) {
-        DISC_LOGI(DISC_BLE_ADAPTER, "start adv failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "start adv failed");
         return SOFTBUS_ERR;
     }
     return SOFTBUS_OK;
@@ -442,9 +451,10 @@ static int32_t StopAdv(int32_t advId)
     g_advChannel[advId].isAdvertising = false;
     if (BleStopAdv(g_advChannel[advId].advId) != OHOS_BT_STATUS_SUCCESS) {
         SoftBusMutexUnlock(&g_advLock);
-        DISC_LOGI(DISC_BLE_ADAPTER, "adv: %d, stop adv failed", advId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "stop adv failed, advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
         return SOFTBUS_ERR;
     }
+    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
     SoftBusMutexUnlock(&g_advLock);
     return SOFTBUS_OK;
 }
@@ -467,7 +477,6 @@ static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
         DISC_LOGE(DISC_BLE_ADAPTER, "adv %d is not advertising", advId);
         return SOFTBUS_ERR;
     }
-    DISC_LOGI(DISC_BLE_ADAPTER, "BleSetAdvData, advId: %d, btadvId: %d", advId, g_advChannel[advId].advId);
     StartAdvRawData advRawData;
     advRawData.advData = AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
     advRawData.rspDataLen = 0;
@@ -476,6 +485,7 @@ static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
         advRawData.rspData = AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
     }
     int32_t ret = BtStatusToSoftBus(BleSetAdvData(g_advChannel[advId].advId, advRawData));
+    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
     SoftBusFree(advRawData.advData);
     SoftBusFree(advRawData.rspData);
     SoftBusMutexUnlock(&g_advLock);
@@ -484,6 +494,7 @@ static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
 
 static int32_t UpdateAdvData(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
 {
+    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d", advId);
     if (StopAdv(advId) != SOFTBUS_OK) {
         return SOFTBUS_ERR;
     }
@@ -493,11 +504,11 @@ static int32_t UpdateAdvData(int32_t advId, const SoftbusBroadcastParam *param,
 static bool CheckScanChannelInUsed(int32_t scannerId)
 {
     if (scannerId < 0 || scannerId >= GATT_SCAN_MAX_NUM) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "invalid scannerId: %d", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid scannerId");
         return false;
     }
     if (!g_scanChannel[scannerId].isUsed) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "scanner %d is not in used", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "scannerId: %d, bt-scannerId: %d", scannerId, g_scanChannel[scannerId].scannerId);
         return false;
     }
     return true;
@@ -515,14 +526,13 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used");
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_ERR;
     }
     if (g_scanChannel[scannerId].isScanning) {
-        if (g_scanChannel[scannerId].scanCallback != NULL &&
-            g_scanChannel[scannerId].scanCallback->OnStartScanCallback != NULL) {
-            g_scanChannel[scannerId].scanCallback->OnStartScanCallback(scannerId, SOFTBUS_BC_STATUS_SUCCESS);
-        }
+        DISC_LOGE(DISC_BLE_ADAPTER, "already scanning, scannerId: %d, bt-scannerId: %d",
+            scannerId, g_scanChannel[scannerId].scannerId);
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_OK;
     }
@@ -539,19 +549,16 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     scanConfig.scanMode = GetBtScanMode(param->scanInterval, param->scanWindow);
     scanConfig.phy = (int)param->scanPhy;
     int32_t ret = BleStartScanEx(g_scanChannel[scannerId].scannerId, &scanConfig, nativeFilter, filterSize);
+    DISC_LOGI(DISC_BLE_ADAPTER, "start scan, scannerId: %d, bt-scannerId: %d, ret: %d",
+        scannerId, g_scanChannel[scannerId].scannerId, ret);
     FreeBtFilter(nativeFilter, filterSize);
     SoftBusFree(nativeFilter);
     g_scanChannel[scannerId].isScanning = (ret == OHOS_BT_STATUS_SUCCESS);
+    SoftBusMutexUnlock(&g_scannerLock);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
-        SoftBusMutexUnlock(&g_scannerLock);
-        DISC_LOGE(DISC_BLE_ADAPTER, "scan %d, start scan failed", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "start scan failed, scannerId: %d", scannerId);
         return SOFTBUS_ERR;
     }
-    if (g_scanChannel[scannerId].scanCallback != NULL &&
-            g_scanChannel[scannerId].scanCallback->OnStartScanCallback != NULL) {
-        g_scanChannel[scannerId].scanCallback->OnStartScanCallback(scannerId, SOFTBUS_BC_STATUS_SUCCESS);
-    }
-    SoftBusMutexUnlock(&g_scannerLock);
     return SOFTBUS_OK;
 }
 
@@ -562,19 +569,19 @@ static int32_t StopScan(int32_t scannerId)
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used");
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_ERR;
     }
     g_scanChannel[scannerId].isScanning = false;
     if (BleStopScan(g_scanChannel[scannerId].scannerId) != OHOS_BT_STATUS_SUCCESS) {
         SoftBusMutexUnlock(&g_scannerLock);
-        DISC_LOGE(DISC_BLE_ADAPTER, "scan %d, stop scan failed", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "stop scan failed, scannerId: %d, bt-scannerId: %d",
+            scannerId, g_scanChannel[scannerId].scannerId);
         return SOFTBUS_ERR;
     }
-    if (g_scanChannel[scannerId].scanCallback != NULL &&
-            g_scanChannel[scannerId].scanCallback->OnStopScanCallback != NULL) {
-        g_scanChannel[scannerId].scanCallback->OnStopScanCallback(scannerId, SOFTBUS_BC_STATUS_SUCCESS);
-    }
+    DISC_LOGI(DISC_BLE_ADAPTER, "stop scan, scannerId: %d, bt-scannerId: %d",
+        scannerId, g_scanChannel[scannerId].scannerId);
     SoftBusMutexUnlock(&g_scannerLock);
     return SOFTBUS_OK;
 }
@@ -592,7 +599,7 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
     lpParam.scanConfig = &scanConfig;
     lpParam.filter = (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * scanParam->filterSize);
     if (lpParam.filter == NULL) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "malloc native filter failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "set lp param %d, malloc native filter failed", bcParam->advHandle);
         return SOFTBUS_MALLOC_ERR;
     }
     SoftbusFilterToBt(lpParam.filter, scanParam->filter, scanParam->filterSize);
@@ -617,9 +624,10 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
     SoftBusFree(lpParam.rawData.advData);
     SoftBusFree(lpParam.rawData.rspData);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "SetLpDeviceParam failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "set lp param %d failed", bcParam->advHandle);
         return false;
     }
+    DISC_LOGI(DISC_BLE_ADAPTER, "set lp param %d", bcParam->advHandle);
     return true;
 }
 
@@ -630,21 +638,26 @@ static int32_t GetBroadcastHandle(int32_t advId, int32_t *bcHandle)
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used");
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
     int32_t ret = GetAdvHandle(g_advChannel[advId].advId, bcHandle);
+    DISC_LOGI(DISC_BLE_ADAPTER, "get broadcast handle, advId: %d, bt-advId: %d, ret: %d",
+        advId, g_advChannel[advId].advId, ret);
     SoftBusMutexUnlock(&g_advLock);
     return ret;
 }
 
 static int32_t EnableSyncDataToLp(void)
 {
+    DISC_LOGI(DISC_BLE_ADAPTER, "enable sync data to lp");
     return EnableSyncDataToLpDevice();
 }
 
 static int32_t DisableSyncDataToLp(void)
 {
+    DISC_LOGI(DISC_BLE_ADAPTER, "disable sync data to lp");
     return DisableSyncDataToLpDevice();
 }
 
@@ -655,10 +668,13 @@ static int32_t SetScanReportChannelToLp(int32_t scannerId, bool enable)
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used");
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_ERR;
     }
     int32_t ret = SetScanReportChannelToLpDevice(g_scanChannel[scannerId].scannerId, enable);
+    DISC_LOGI(DISC_BLE_ADAPTER, "set scan report channel to lp, scannerId: %d, bt-scannerId: %d, ret: %d",
+        scannerId, g_scanChannel[scannerId].scannerId, ret);
     SoftBusMutexUnlock(&g_scannerLock);
     return ret;
 }
@@ -666,11 +682,13 @@ static int32_t SetScanReportChannelToLp(int32_t scannerId, bool enable)
 static int32_t SetLpAdvParam(int32_t duration, int32_t maxExtAdvEvents, int32_t window,
     int32_t interval, int32_t bcHandle)
 {
+    DISC_LOGI(DISC_BLE_ADAPTER, "set lp adv param, handleId: %d", bcHandle);
     return SetLpDeviceAdvParam(duration, maxExtAdvEvents, window, interval, bcHandle);
 }
 
 void SoftbusBleAdapterInit(void)
 {
+    DISC_LOGI(DISC_BLE_ADAPTER, "SoftbusBleAdapterInit");
     static SoftbusBroadcastMediumInterface interface = {
         .Init = Init,
         .DeInit = DeInit,
-- 
Gitee


From 64302a73d1438d02b4685a0fa68ffcc7829d6cba Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 20 Dec 2023 09:29:35 +0000
Subject: [PATCH 72/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Fgatt.h.=20gatt=20ada?=
 =?UTF-8?q?pter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
index 675f07b3df..0329266c3a 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_gatt.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
-- 
Gitee


From 8bf34f67b01d8a87771ff365debe4219cd5b784b Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 20 Dec 2023 09:30:10 +0000
Subject: [PATCH 73/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Futils.h.=20gatt=20ad?=
 =?UTF-8?q?apter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/ble/include/softbus_ble_utils.h       | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
index f0d755b3cd..2a8eefc239 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023 Huawei Device Co., Ltd.
+ * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -47,9 +47,9 @@ void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize);
 
 int GetBtScanMode(uint16_t scanInterval, uint16_t scanWindow);
 
-uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen);
+int32_t AssembleAdvData(const SoftbusBroadcastData *data, uint8_t *advData);
 
-uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen);
+int32_t AssembleRspData(const SoftbusBroadcastPayload *data, uint8_t *rspData);
 
 void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult *dst);
 
-- 
Gitee


From 6bc56f4b0d39b9d56636d9125f2a9bf522121ff9 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 20 Dec 2023 09:30:38 +0000
Subject: [PATCH 74/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 89 +++++++++++++------
 1 file changed, 62 insertions(+), 27 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 7d983f25c3..40b5b3da0e 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -363,6 +363,7 @@ static int32_t UnRegisterScanCallback(int32_t scannerId)
         return SOFTBUS_LOCK_ERR;
     }
     if (!g_scanChannel[scannerId].isUsed) {
+        SoftBusMutexUnlock(&g_scannerLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "already unregistered, scannerId: %d, bt-scannerId: %d",
             scannerId, g_scanChannel[scannerId].scannerId);
         return SOFTBUS_OK;
@@ -396,13 +397,24 @@ static int32_t StartBleAdv(int32_t advId, const SoftbusBroadcastParam *param, co
     BleAdvParams advParam;
     SoftbusAdvParamToBt(param, &advParam);
     StartAdvRawData advRawData;
-    advRawData.advData = AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
+    int32_t ret = AssembleAdvData(data, (uint8_t *)advRawData.advData);
+    if (ret == SOFTBUS_ERR) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed");
+        return SOFTBUS_ERR;
+    }
+    advRawData.advDataLen = (unsigned int)ret;
     advRawData.rspDataLen = 0;
     advRawData.rspData = NULL;
     if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
-        advRawData.rspData = AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
+        ret = AssembleRspData(&data->rspData, (uint8_t *)advRawData.rspData);
+        if (ret == SOFTBUS_ERR) {
+            SoftBusFree(advRawData.advData);
+            DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed");
+            return SOFTBUS_ERR;
+        }
+        advRawData.rspDataLen = (unsigned int)ret;
     }
-    int32_t ret = BleStartAdvEx(&g_advChannel[advId].advId, advRawData, advParam);
+    ret = BleStartAdvEx(&g_advChannel[advId].advId, advRawData, advParam);
     SoftBusFree(advRawData.advData);
     SoftBusFree(advRawData.rspData);
     return ret == OHOS_BT_STATUS_SUCCESS ? SOFTBUS_OK : SOFTBUS_ERR;
@@ -425,10 +437,10 @@ static int32_t StartAdv(int32_t advId, const SoftbusBroadcastParam *param, const
     if (g_advChannel[advId].isAdvertising) {
         DISC_LOGI(DISC_BLE_ADAPTER, "already started, advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
         SoftBusMutexUnlock(&g_advLock);
-        return SOFTBUS_OK;
+        return SOFTBUS_ERR;
     }
     int32_t ret = StartBleAdv(advId, param, data);
-    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
+    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
     g_advChannel[advId].isAdvertising = (ret == SOFTBUS_OK);
     SoftBusMutexUnlock(&g_advLock);
     if (ret != SOFTBUS_OK) {
@@ -449,13 +461,12 @@ static int32_t StopAdv(int32_t advId)
         return SOFTBUS_ERR;
     }
     g_advChannel[advId].isAdvertising = false;
-    if (BleStopAdv(g_advChannel[advId].advId) != OHOS_BT_STATUS_SUCCESS) {
-        SoftBusMutexUnlock(&g_advLock);
-        DISC_LOGE(DISC_BLE_ADAPTER, "stop adv failed, advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
+    int32_t ret = BleStopAdv(g_advChannel[advId].advId);
+    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
+    SoftBusMutexUnlock(&g_advLock);
+    if (ret != OHOS_BT_STATUS_SUCCESS) {
         return SOFTBUS_ERR;
     }
-    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
-    SoftBusMutexUnlock(&g_advLock);
     return SOFTBUS_OK;
 }
 
@@ -478,13 +489,26 @@ static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
         return SOFTBUS_ERR;
     }
     StartAdvRawData advRawData;
-    advRawData.advData = AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
+    int32_t ret = AssembleAdvData(data, (uint8_t *)advRawData.advData);
+    if (advRawData.advDataLen == SOFTBUS_ERR) {
+        SoftBusMutexUnlock(&g_advLock);
+        DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed");
+        return SOFTBUS_ERR;
+    }
+    advRawData.advDataLen = (unsigned int)ret;
     advRawData.rspDataLen = 0;
     advRawData.rspData = NULL;
     if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
-        advRawData.rspData = AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
+        ret = AssembleRspData(&data->rspData, (uint8_t *)advRawData.rspData);
+        if (ret == SOFTBUS_ERR) {
+            SoftBusFree(advRawData.advData);
+            SoftBusMutexUnlock(&g_advLock);
+            DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed");
+            return SOFTBUS_ERR;
+        }
+        advRawData.rspDataLen = (unsigned int)ret;
     }
-    int32_t ret = BtStatusToSoftBus(BleSetAdvData(g_advChannel[advId].advId, advRawData));
+    ret = BtStatusToSoftBus(BleSetAdvData(g_advChannel[advId].advId, advRawData));
     DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
     SoftBusFree(advRawData.advData);
     SoftBusFree(advRawData.rspData);
@@ -534,7 +558,7 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
         DISC_LOGE(DISC_BLE_ADAPTER, "already scanning, scannerId: %d, bt-scannerId: %d",
             scannerId, g_scanChannel[scannerId].scannerId);
         SoftBusMutexUnlock(&g_scannerLock);
-        return SOFTBUS_OK;
+        return SOFTBUS_ERR;
     }
     BleScanNativeFilter *nativeFilter =
         (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * filterSize);
@@ -549,11 +573,11 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     scanConfig.scanMode = GetBtScanMode(param->scanInterval, param->scanWindow);
     scanConfig.phy = (int)param->scanPhy;
     int32_t ret = BleStartScanEx(g_scanChannel[scannerId].scannerId, &scanConfig, nativeFilter, filterSize);
+    g_scanChannel[scannerId].isScanning = (ret == OHOS_BT_STATUS_SUCCESS);
     DISC_LOGI(DISC_BLE_ADAPTER, "start scan, scannerId: %d, bt-scannerId: %d, ret: %d",
         scannerId, g_scanChannel[scannerId].scannerId, ret);
     FreeBtFilter(nativeFilter, filterSize);
     SoftBusFree(nativeFilter);
-    g_scanChannel[scannerId].isScanning = (ret == OHOS_BT_STATUS_SUCCESS);
     SoftBusMutexUnlock(&g_scannerLock);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
         DISC_LOGE(DISC_BLE_ADAPTER, "start scan failed, scannerId: %d", scannerId);
@@ -574,15 +598,13 @@ static int32_t StopScan(int32_t scannerId)
         return SOFTBUS_ERR;
     }
     g_scanChannel[scannerId].isScanning = false;
-    if (BleStopScan(g_scanChannel[scannerId].scannerId) != OHOS_BT_STATUS_SUCCESS) {
-        SoftBusMutexUnlock(&g_scannerLock);
-        DISC_LOGE(DISC_BLE_ADAPTER, "stop scan failed, scannerId: %d, bt-scannerId: %d",
-            scannerId, g_scanChannel[scannerId].scannerId);
+    int32_t ret = BleStopScan(g_scanChannel[scannerId].scannerId);
+    DISC_LOGI(DISC_BLE_ADAPTER, "stop scan, scannerId: %d, bt-scannerId: %d, ret: %d",
+        scannerId, g_scanChannel[scannerId].scannerId, ret);
+    SoftBusMutexUnlock(&g_scannerLock);
+    if (ret != OHOS_BT_STATUS_SUCCESS) {
         return SOFTBUS_ERR;
     }
-    DISC_LOGI(DISC_BLE_ADAPTER, "stop scan, scannerId: %d, bt-scannerId: %d",
-        scannerId, g_scanChannel[scannerId].scannerId);
-    SoftBusMutexUnlock(&g_scannerLock);
     return SOFTBUS_OK;
 }
 
@@ -597,18 +619,31 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
     scanConfig.scanMode = GetBtScanMode(scanParam->scanParam.scanInterval, scanParam->scanParam.scanWindow);
     BtLpDeviceParam lpParam;
     lpParam.scanConfig = &scanConfig;
+    int32_t ret = AssembleAdvData(&bcParam->advData, (uint8_t *)lpParam.rawData.advData);
+    if (ret == SOFTBUS_ERR) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed");
+        return SOFTBUS_ERR;
+    }
+    lpParam.rawData.advDataLen = (unsigned int)ret;
+    if (bcParam->advData.rspData.payloadLen > 0 && bcParam->advData.rspData.payload != NULL) {
+        ret = AssembleRspData(&bcParam->advData.rspData, (uint8_t *)lpParam.rawData.rspData);
+        if (ret == SOFTBUS_ERR) {
+            SoftBusFree(lpParam.rawData.advData);
+            DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed");
+            return SOFTBUS_ERR;
+        }
+        lpParam.rawData.rspDataLen = (unsigned int)ret;
+    }
     lpParam.filter = (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * scanParam->filterSize);
     if (lpParam.filter == NULL) {
+        SoftBusFree(lpParam.rawData.advData);
+        SoftBusFree(lpParam.rawData.rspData);
         DISC_LOGE(DISC_BLE_ADAPTER, "set lp param %d, malloc native filter failed", bcParam->advHandle);
         return SOFTBUS_MALLOC_ERR;
     }
     SoftbusFilterToBt(lpParam.filter, scanParam->filter, scanParam->filterSize);
     lpParam.filterSize = (unsigned int)scanParam->filterSize;
     SoftbusAdvParamToBt(&bcParam->advParam, &lpParam.advParam);
-    lpParam.rawData.advData = AssembleAdvData(&bcParam->advData,
-        (uint16_t *)&lpParam.rawData.advDataLen);
-    lpParam.rawData.rspData = AssembleRspData(&bcParam->advData.rspData,
-        (uint16_t *)&lpParam.rawData.rspDataLen);
     BtUuid btUuid;
     btUuid.uuid = LP_BT_UUID;
     btUuid.uuidLen = (unsigned char)strlen(LP_BT_UUID);
@@ -618,7 +653,7 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
     lpParam.deliveryMode = LP_DELIVERY_MODE_REPLY;
     lpParam.advHandle = bcParam->advHandle;
     lpParam.duration = LP_ADV_DURATION_MS;
-    int32_t ret = SetLpDeviceParam(&lpParam);
+    ret = SetLpDeviceParam(&lpParam);
     FreeBtFilter(lpParam.filter, scanParam->filterSize);
     SoftBusFree(lpParam.filter);
     SoftBusFree(lpParam.rawData.advData);
-- 
Gitee


From 21025a64d1204bc7c9062b9b26356e0b96e153e5 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Wed, 20 Dec 2023 09:30:57 +0000
Subject: [PATCH 75/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_utils.c       | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index ee8648f4f3..5f7b854e95 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -16,6 +16,7 @@
 #include "softbus_ble_utils.h"
 #include "softbus_adapter_mem.h"
 #include "softbus_broadcast_type.h"
+#include "softbus_error_code.h"
 #include "softbus_utils.h"
 #include "softbus_broadcast_utils.h"
 #include "disc_log.h"
@@ -337,14 +338,14 @@ int GetBtScanMode(uint16_t scanInterval, uint16_t scanWindow)
     return OHOS_BLE_SCAN_MODE_LOW_POWER;
 }
 
-uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen)
+int32_t AssembleAdvData(const SoftbusBroadcastData *data, uint8_t *advData)
 {
     uint16_t payloadLen = (data->bcData.payloadLen > BC_DATA_MAX_LEN) ? BC_DATA_MAX_LEN : data->bcData.payloadLen;
-    *dataLen = payloadLen + BC_HEAD_LEN;
-    uint8_t *advData = (uint8_t *)SoftBusCalloc(*dataLen);
+    uint16_t dataLen = data->isSupportFlag ? payloadLen + BC_HEAD_LEN : payloadLen + BC_HEAD_LEN - BC_FLAG_LEN;
+    advData = (uint8_t *)SoftBusCalloc(dataLen);
     if (advData == NULL) {
         DISC_LOGE(DISC_BLE_ADAPTER, "malloc adv data failed");
-        return NULL;
+        return SOFTBUS_ERR;
     }
     int8_t offset = -BC_FLAG_LEN;
     if (data->isSupportFlag) {
@@ -353,7 +354,7 @@ uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen)
         advData[IDX_BC_FLAG_AD_DATA] = data->flag;
         offset += BC_FLAG_LEN;
     }
-    advData[IDX_PACKET_LEN + offset] = *dataLen - IDX_PACKET_LEN - 1;
+    advData[IDX_PACKET_LEN + offset] = payloadLen + BC_HEAD_LEN - BC_FLAG_LEN - 1;
     advData[IDX_BC_TYPE + offset] = SoftbusAdvDataTypeToBt(data->bcData.type);
     uint16_t payloadId = data->bcData.id;
     advData[IDX_BC_UUID + offset] = (uint8_t)(payloadId & BC_BYTE_MASK);
@@ -362,21 +363,21 @@ uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen)
     if (memcpy_s(&advData[BC_HEAD_LEN + offset], payloadLen, data->bcData.payload, payloadLen) != EOK) {
         DISC_LOGE(DISC_BLE_ADAPTER, "copy adv payload failed");
         SoftBusFree(advData);
-        return NULL;
+        return SOFTBUS_ERR;
     }
-    return advData;
+    return dataLen;
 }
 
-uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen)
+int32_t AssembleRspData(const SoftbusBroadcastPayload *data, uint8_t *rspData)
 {
     uint16_t payloadLen = (data->payloadLen > RSP_DATA_MAX_LEN) ? RSP_DATA_MAX_LEN : data->payloadLen;
-    *dataLen = payloadLen + RSP_HEAD_LEN;
-    uint8_t *rspData = (uint8_t *)SoftBusCalloc(*dataLen);
+    uint16_t dataLen = payloadLen + RSP_HEAD_LEN;
+    rspData = (uint8_t *)SoftBusCalloc(dataLen);
     if (rspData == NULL) {
         DISC_LOGE(DISC_BLE_ADAPTER, "malloc adv data failed");
-        return NULL;
+        return SOFTBUS_ERR;
     }
-    rspData[IDX_RSP_PACKET_LEN] = *dataLen - IDX_RSP_PACKET_LEN - 1;
+    rspData[IDX_RSP_PACKET_LEN] = dataLen - IDX_RSP_PACKET_LEN - 1;
     rspData[IDX_RSP_TYPE] = SoftbusAdvDataTypeToBt(data->type);
     uint16_t payloadId = data->id;
     rspData[IDX_RSP_UUID] = (uint8_t)(payloadId & BC_BYTE_MASK);
@@ -385,9 +386,9 @@ uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen)
     if (memcpy_s(&rspData[RSP_HEAD_LEN], payloadLen, data->payload, payloadLen) != EOK) {
         DISC_LOGE(DISC_BLE_ADAPTER, "copy adv payload failed");
         SoftBusFree(rspData);
-        return NULL;
+        return SOFTBUS_ERR;
     }
-    return rspData;
+    return dataLen;
 }
 
 void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult *dst)
@@ -397,7 +398,6 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
     while (index <= advLen) {
         uint8_t len = advData[index];
         if (index + len >= advLen) {
-            DISC_LOGE(DISC_BLE_ADAPTER, "invalid len, index: %u, len: %u", index, len);
             break;
         }
         uint8_t type = advData[++index];
-- 
Gitee


From fd45693381e8cfd2823c1cdf2bd057843c551441 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Thu, 21 Dec 2023 11:03:08 +0000
Subject: [PATCH 76/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_utils.c       | 33 ++++++++++---------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index 5f7b854e95..69aeb107fc 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -16,7 +16,6 @@
 #include "softbus_ble_utils.h"
 #include "softbus_adapter_mem.h"
 #include "softbus_broadcast_type.h"
-#include "softbus_error_code.h"
 #include "softbus_utils.h"
 #include "softbus_broadcast_utils.h"
 #include "disc_log.h"
@@ -338,14 +337,14 @@ int GetBtScanMode(uint16_t scanInterval, uint16_t scanWindow)
     return OHOS_BLE_SCAN_MODE_LOW_POWER;
 }
 
-int32_t AssembleAdvData(const SoftbusBroadcastData *data, uint8_t *advData)
+uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen)
 {
     uint16_t payloadLen = (data->bcData.payloadLen > BC_DATA_MAX_LEN) ? BC_DATA_MAX_LEN : data->bcData.payloadLen;
-    uint16_t dataLen = data->isSupportFlag ? payloadLen + BC_HEAD_LEN : payloadLen + BC_HEAD_LEN - BC_FLAG_LEN;
-    advData = (uint8_t *)SoftBusCalloc(dataLen);
+    uint16_t len = data->isSupportFlag ? payloadLen + BC_HEAD_LEN : payloadLen + BC_HEAD_LEN - BC_FLAG_LEN;
+    uint8_t *advData = (uint8_t *)SoftBusCalloc(len);
     if (advData == NULL) {
         DISC_LOGE(DISC_BLE_ADAPTER, "malloc adv data failed");
-        return SOFTBUS_ERR;
+        return NULL;
     }
     int8_t offset = -BC_FLAG_LEN;
     if (data->isSupportFlag) {
@@ -363,32 +362,34 @@ int32_t AssembleAdvData(const SoftbusBroadcastData *data, uint8_t *advData)
     if (memcpy_s(&advData[BC_HEAD_LEN + offset], payloadLen, data->bcData.payload, payloadLen) != EOK) {
         DISC_LOGE(DISC_BLE_ADAPTER, "copy adv payload failed");
         SoftBusFree(advData);
-        return SOFTBUS_ERR;
+        return NULL;
     }
-    return dataLen;
+    *dataLen = len;
+    return advData;
 }
 
-int32_t AssembleRspData(const SoftbusBroadcastPayload *data, uint8_t *rspData)
+uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen)
 {
     uint16_t payloadLen = (data->payloadLen > RSP_DATA_MAX_LEN) ? RSP_DATA_MAX_LEN : data->payloadLen;
-    uint16_t dataLen = payloadLen + RSP_HEAD_LEN;
-    rspData = (uint8_t *)SoftBusCalloc(dataLen);
+    uint16_t len = payloadLen + RSP_HEAD_LEN;
+    uint8_t *rspData = (uint8_t *)SoftBusCalloc(len);
     if (rspData == NULL) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "malloc adv data failed");
-        return SOFTBUS_ERR;
+        DISC_LOGE(DISC_BLE_ADAPTER, "malloc rsp data failed");
+        return NULL;
     }
-    rspData[IDX_RSP_PACKET_LEN] = dataLen - IDX_RSP_PACKET_LEN - 1;
+    rspData[IDX_RSP_PACKET_LEN] = payloadLen + RSP_HEAD_LEN - 1;
     rspData[IDX_RSP_TYPE] = SoftbusAdvDataTypeToBt(data->type);
     uint16_t payloadId = data->id;
     rspData[IDX_RSP_UUID] = (uint8_t)(payloadId & BC_BYTE_MASK);
     rspData[IDX_RSP_UUID + 1] = (uint8_t)((payloadId >> BC_SHIFT_BIT) & BC_BYTE_MASK);
 
     if (memcpy_s(&rspData[RSP_HEAD_LEN], payloadLen, data->payload, payloadLen) != EOK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "copy adv payload failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "copy rsp payload failed");
         SoftBusFree(rspData);
-        return SOFTBUS_ERR;
+        return NULL;
     }
-    return dataLen;
+    *dataLen = len;
+    return rspData;
 }
 
 void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult *dst)
-- 
Gitee


From 3a0acc948f60b28c865672a760694f7b601f91ab Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Thu, 21 Dec 2023 11:03:42 +0000
Subject: [PATCH 77/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 156 +++++++++---------
 1 file changed, 80 insertions(+), 76 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 40b5b3da0e..6da4204ad8 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -76,13 +76,13 @@ static int32_t Init(void)
 static int32_t DeInit(void)
 {
     if (!g_init) {
-        DISC_LOGI(DISC_BLE_ADAPTER, "already deInited");
+        DISC_LOGI(DISC_BLE_ADAPTER, "already deinited");
         return SOFTBUS_OK;
     }
-    DISC_LOGI(DISC_BLE_ADAPTER, "deinit success");
     g_init = false;
     SoftBusMutexDestroy(&g_advLock);
     SoftBusMutexDestroy(&g_scannerLock);
+    DISC_LOGI(DISC_BLE_ADAPTER, "deinit success");
     return SOFTBUS_OK;
 }
 
@@ -91,7 +91,7 @@ static void WrapperAdvEnableCallback(int advId, int status)
     int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u", channelId);
             continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
@@ -114,7 +114,7 @@ static void WrapperAdvDisableCallback(int advId, int status)
     int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u", channelId);
             continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
@@ -137,7 +137,7 @@ static void WrapperAdvSetDataCallback(int advId, int status)
     int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint32_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u", channelId);
             continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
@@ -159,7 +159,7 @@ static void WrapperAdvUpdateDataCallback(int advId, int status)
     int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint32_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u", channelId);
             continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
@@ -198,8 +198,8 @@ static int32_t RegisterAdvCallback(int32_t *advId, const SoftbusBroadcastCallbac
             continue;
         }
         if (BleGattRegisterCallbacks(&g_softbusGattCb) != OHOS_BT_STATUS_SUCCESS) {
-            DISC_LOGE(DISC_BLE_ADAPTER, "register failed, advId: %u", channelId);
             SoftBusMutexUnlock(&g_advLock);
+            DISC_LOGE(DISC_BLE_ADAPTER, "register failed, advId: %u", channelId);
             return SOFTBUS_ERR;
         }
         g_advChannel[channelId].advId = -1;
@@ -207,12 +207,12 @@ static int32_t RegisterAdvCallback(int32_t *advId, const SoftbusBroadcastCallbac
         g_advChannel[channelId].isAdvertising = false;
         g_advChannel[channelId].advCallback = (SoftbusBroadcastCallback *)cb;
         *advId = channelId;
-        DISC_LOGI(DISC_BLE_ADAPTER, "register success, advId: %u", channelId);
         SoftBusMutexUnlock(&g_advLock);
+        DISC_LOGI(DISC_BLE_ADAPTER, "register success, advId: %u", channelId);
         return SOFTBUS_OK;
     }
-    DISC_LOGE(DISC_BLE_ADAPTER, "no available adv channel");
     SoftBusMutexUnlock(&g_advLock);
+    DISC_LOGE(DISC_BLE_ADAPTER, "no available adv channel");
     return SOFTBUS_ERR;
 }
 
@@ -223,12 +223,12 @@ static int32_t UnRegisterAdvCallback(int32_t advId)
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, advId: %d", advId);
         return SOFTBUS_LOCK_ERR;
     }
     if (!g_advChannel[advId].isUsed) {
+        DISC_LOGI(DISC_BLE_ADAPTER, "already unregistered, advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
         SoftBusMutexUnlock(&g_advLock);
-        DISC_LOGI(DISC_BLE_ADAPTER, "already unregistered, advId: %d", advId);
         return SOFTBUS_OK;
     }
     DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
@@ -251,7 +251,7 @@ static void WrapperScanResultCallback(BtScanResultData *data)
     ParseScanResult(data->advData, data->advLen, &sr);
     for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock scan failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock failed, scannerId: %u", channelId);
             continue;
         }
         ScanChannel *scanChannel = &g_scanChannel[channelId];
@@ -272,7 +272,7 @@ static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
 {
     for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock scan failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock failed, scannerId: %u", channelId);
             continue;
         }
         ScanChannel *scanChannel = &g_scanChannel[channelId];
@@ -280,11 +280,11 @@ static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
             SoftBusMutexUnlock(&g_scannerLock);
             continue;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "resultCode: %d, isStartScan: %d", resultCode, isStartScan);
+        DISC_LOGI(DISC_BLE_ADAPTER, "scannerId: %d, bt-scannerId: %d, resultCode: %d, isStartScan: %d",
+            channelId, scanChannel->scannerId, resultCode, isStartScan);
         if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnScanStateChanged != NULL) {
             scanChannel->scanCallback->OnScanStateChanged(resultCode, isStartScan);
         }
-        scanChannel->isScanning = isStartScan ? (resultCode == 0) : false;
         SoftBusMutexUnlock(&g_scannerLock);
         break;
     }
@@ -294,7 +294,7 @@ static void WrapperLpDeviceInfoCallback(BtUuid *uuid, int32_t type, uint8_t *dat
 {
     for (uint32_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock scan failed");
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock failed, scannerId: %u", channelId);
             continue;
         }
         ScanChannel *scanChannel = &g_scanChannel[channelId];
@@ -334,9 +334,9 @@ static int32_t RegisterScanCallback(int32_t *scannerId, const SoftbusScanCallbac
             continue;
         }
         if (BleRegisterScanCallbacks(&g_softbusBleScanCb,
-            &g_scanChannel[channelId].scannerId) !=OHOS_BT_STATUS_SUCCESS) {
-            DISC_LOGE(DISC_BLE_ADAPTER, "register callback failed");
+            &g_scanChannel[channelId].scannerId) != OHOS_BT_STATUS_SUCCESS) {
             SoftBusMutexUnlock(&g_scannerLock);
+            DISC_LOGE(DISC_BLE_ADAPTER, "register callback failed, scannerId: %u", channelId);
             return SOFTBUS_ERR;
         }
         g_scanChannel[channelId].isUsed = true;
@@ -347,8 +347,8 @@ static int32_t RegisterScanCallback(int32_t *scannerId, const SoftbusScanCallbac
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_OK;
     }
-    DISC_LOGE(DISC_BLE_ADAPTER, "no available scan channel");
     SoftBusMutexUnlock(&g_scannerLock);
+    DISC_LOGE(DISC_BLE_ADAPTER, "no available scan channel");
     return SOFTBUS_ERR;
 }
 
@@ -359,13 +359,13 @@ static int32_t UnRegisterScanCallback(int32_t scannerId)
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId: %u", scannerId);
         return SOFTBUS_LOCK_ERR;
     }
     if (!g_scanChannel[scannerId].isUsed) {
-        SoftBusMutexUnlock(&g_scannerLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "already unregistered, scannerId: %d, bt-scannerId: %d",
             scannerId, g_scanChannel[scannerId].scannerId);
+        SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_OK;
     }
     int32_t ret = BleDeregisterScanCallbacks(g_scanChannel[scannerId].scannerId);
@@ -397,54 +397,54 @@ static int32_t StartBleAdv(int32_t advId, const SoftbusBroadcastParam *param, co
     BleAdvParams advParam;
     SoftbusAdvParamToBt(param, &advParam);
     StartAdvRawData advRawData;
-    int32_t ret = AssembleAdvData(data, (uint8_t *)advRawData.advData);
-    if (ret == SOFTBUS_ERR) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed");
+    advRawData.advData = (unsigned char *)AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
+    if (advRawData.advData == NULL) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed, advId: %d, bt-advId: %d",
+            advId, g_advChannel[advId].advId);
         return SOFTBUS_ERR;
     }
-    advRawData.advDataLen = (unsigned int)ret;
     advRawData.rspDataLen = 0;
     advRawData.rspData = NULL;
     if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
-        ret = AssembleRspData(&data->rspData, (uint8_t *)advRawData.rspData);
-        if (ret == SOFTBUS_ERR) {
+        advRawData.rspData = (unsigned char *)AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
+        if (advRawData.rspData == NULL) {
             SoftBusFree(advRawData.advData);
-            DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed");
+            DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed, advId: %d, bt-advId: %d",
+                advId, g_advChannel[advId].advId);
             return SOFTBUS_ERR;
         }
-        advRawData.rspDataLen = (unsigned int)ret;
     }
-    ret = BleStartAdvEx(&g_advChannel[advId].advId, advRawData, advParam);
+    int32_t ret = BleStartAdvEx(&g_advChannel[advId].advId, advRawData, advParam);
     SoftBusFree(advRawData.advData);
     SoftBusFree(advRawData.rspData);
-    return ret == OHOS_BT_STATUS_SUCCESS ? SOFTBUS_OK : SOFTBUS_ERR;
+    return (ret == OHOS_BT_STATUS_SUCCESS) ? SOFTBUS_OK : SOFTBUS_ERR;
 }
 
 static int32_t StartAdv(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
 {
     if (param == NULL || data == NULL || data->bcData.payloadLen == 0 || data->bcData.payload == NULL) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "invalid adv param");
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid adv param, advId: %d", advId);
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, advId: %d", advId);
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
         SoftBusMutexUnlock(&g_advLock);
+        DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used, advId: %d", advId);
         return SOFTBUS_ERR;
     }
     if (g_advChannel[advId].isAdvertising) {
-        DISC_LOGI(DISC_BLE_ADAPTER, "already started, advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "already started, advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
     int32_t ret = StartBleAdv(advId, param, data);
-    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
     g_advChannel[advId].isAdvertising = (ret == SOFTBUS_OK);
+    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
     SoftBusMutexUnlock(&g_advLock);
     if (ret != SOFTBUS_OK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "start adv failed");
         return SOFTBUS_ERR;
     }
     return SOFTBUS_OK;
@@ -453,11 +453,12 @@ static int32_t StartAdv(int32_t advId, const SoftbusBroadcastParam *param, const
 static int32_t StopAdv(int32_t advId)
 {
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed, advId: %d", advId);
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
         SoftBusMutexUnlock(&g_advLock);
+        DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used, advId: %d", advId);
         return SOFTBUS_ERR;
     }
     g_advChannel[advId].isAdvertising = false;
@@ -473,42 +474,45 @@ static int32_t StopAdv(int32_t advId)
 static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
 {
     if (data == NULL) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "data is null, advId: %d", advId);
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed, advId: %d", advId);
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
         SoftBusMutexUnlock(&g_advLock);
+        DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used, advId: %d", advId);
         return SOFTBUS_ERR;
     }
     if (!g_advChannel[advId].isAdvertising) {
         SoftBusMutexUnlock(&g_advLock);
-        DISC_LOGE(DISC_BLE_ADAPTER, "adv %d is not advertising", advId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "adv is not advertising, advId: %d, bt-advId: %d",
+            advId, g_advChannel[advId].advId);
         return SOFTBUS_ERR;
     }
     StartAdvRawData advRawData;
-    int32_t ret = AssembleAdvData(data, (uint8_t *)advRawData.advData);
-    if (advRawData.advDataLen == SOFTBUS_ERR) {
+    advRawData.advData = (unsigned char *)AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
+    if (advRawData.advData == NULL) {
         SoftBusMutexUnlock(&g_advLock);
-        DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed, advId: %d, bt-advId: %d",
+            advId, g_advChannel[advId].advId);
         return SOFTBUS_ERR;
     }
-    advRawData.advDataLen = (unsigned int)ret;
     advRawData.rspDataLen = 0;
     advRawData.rspData = NULL;
     if (data->rspData.payloadLen > 0 && data->rspData.payload != NULL) {
-        ret = AssembleRspData(&data->rspData, (uint8_t *)advRawData.rspData);
-        if (ret == SOFTBUS_ERR) {
+        advRawData.rspData = (unsigned char *)AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
+        if (advRawData.rspData == NULL) {
             SoftBusFree(advRawData.advData);
             SoftBusMutexUnlock(&g_advLock);
-            DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed");
+            DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed, advId: %d, bt-advId: %d",
+                advId, g_advChannel[advId].advId);
             return SOFTBUS_ERR;
         }
-        advRawData.rspDataLen = (unsigned int)ret;
     }
-    ret = BtStatusToSoftBus(BleSetAdvData(g_advChannel[advId].advId, advRawData));
+    int32_t ret = BtStatusToSoftBus(BleSetAdvData(g_advChannel[advId].advId, advRawData));
     DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
     SoftBusFree(advRawData.advData);
     SoftBusFree(advRawData.rspData);
@@ -518,17 +522,18 @@ static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
 
 static int32_t UpdateAdvData(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
 {
-    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d", advId);
     if (StopAdv(advId) != SOFTBUS_OK) {
+        DISC_LOGI(DISC_BLE_ADAPTER, "update adv data failed: %d", advId);
         return SOFTBUS_ERR;
     }
+    DISC_LOGI(DISC_BLE_ADAPTER, "update adv data success: %d", advId);
     return StartAdv(advId, param, data);
 }
 
 static bool CheckScanChannelInUsed(int32_t scannerId)
 {
     if (scannerId < 0 || scannerId >= GATT_SCAN_MAX_NUM) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "invalid scannerId");
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid scannerId: %d", scannerId);
         return false;
     }
     if (!g_scanChannel[scannerId].isUsed) {
@@ -542,16 +547,16 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     uint8_t filterSize)
 {
     if (param == NULL || scanFilter == NULL || filterSize == 0) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "invalid param");
+        DISC_LOGE(DISC_BLE_ADAPTER, "invalid param, scannerId: %d", scannerId);
         return SOFTBUS_INVALID_PARAM;
     }
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId: %d", scannerId);
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used");
         SoftBusMutexUnlock(&g_scannerLock);
+        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used, scannerId: %d", scannerId);
         return SOFTBUS_ERR;
     }
     if (g_scanChannel[scannerId].isScanning) {
@@ -564,7 +569,8 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
         (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * filterSize);
     if (nativeFilter == NULL) {
         SoftBusMutexUnlock(&g_scannerLock);
-        DISC_LOGE(DISC_BLE_ADAPTER, "scan %d malloc native filter failed", scannerId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "malloc native filter failed, scannerId: %d, bt-scannerId: %d",
+            scannerId, g_scanChannel[scannerId].scannerId);
         return SOFTBUS_MALLOC_ERR;
     }
     SoftbusFilterToBt(nativeFilter, scanFilter, filterSize);
@@ -574,13 +580,12 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     scanConfig.phy = (int)param->scanPhy;
     int32_t ret = BleStartScanEx(g_scanChannel[scannerId].scannerId, &scanConfig, nativeFilter, filterSize);
     g_scanChannel[scannerId].isScanning = (ret == OHOS_BT_STATUS_SUCCESS);
-    DISC_LOGI(DISC_BLE_ADAPTER, "start scan, scannerId: %d, bt-scannerId: %d, ret: %d",
+    DISC_LOGI(DISC_BLE_ADAPTER, "scannerId: %d, bt-scannerId: %d, ret: %d",
         scannerId, g_scanChannel[scannerId].scannerId, ret);
     FreeBtFilter(nativeFilter, filterSize);
     SoftBusFree(nativeFilter);
     SoftBusMutexUnlock(&g_scannerLock);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "start scan failed, scannerId: %d", scannerId);
         return SOFTBUS_ERR;
     }
     return SOFTBUS_OK;
@@ -589,12 +594,12 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
 static int32_t StopScan(int32_t scannerId)
 {
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId: %d", scannerId);
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used");
         SoftBusMutexUnlock(&g_scannerLock);
+        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used: %d", scannerId);
         return SOFTBUS_ERR;
     }
     g_scanChannel[scannerId].isScanning = false;
@@ -610,6 +615,7 @@ static int32_t StopScan(int32_t scannerId)
 
 static bool IsLpAvailable(void)
 {
+    DISC_LOGI(DISC_BLE_ADAPTER, "is lp available");
     return IsLpDeviceAvailable();
 }
 
@@ -619,26 +625,26 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
     scanConfig.scanMode = GetBtScanMode(scanParam->scanParam.scanInterval, scanParam->scanParam.scanWindow);
     BtLpDeviceParam lpParam;
     lpParam.scanConfig = &scanConfig;
-    int32_t ret = AssembleAdvData(&bcParam->advData, (uint8_t *)lpParam.rawData.advData);
-    if (ret == SOFTBUS_ERR) {
+    lpParam.rawData.advData = (unsigned char *)AssembleAdvData(&bcParam->advData,
+        (uint16_t *)&lpParam.rawData.advDataLen);
+    if (lpParam.rawData.advData == NULL) {
         DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed");
         return SOFTBUS_ERR;
     }
-    lpParam.rawData.advDataLen = (unsigned int)ret;
     if (bcParam->advData.rspData.payloadLen > 0 && bcParam->advData.rspData.payload != NULL) {
-        ret = AssembleRspData(&bcParam->advData.rspData, (uint8_t *)lpParam.rawData.rspData);
-        if (ret == SOFTBUS_ERR) {
+        lpParam.rawData.rspData = (unsigned char *)AssembleRspData(&bcParam->advData.rspData,
+            (uint16_t *)&lpParam.rawData.rspDataLen);
+        if (lpParam.rawData.rspData == NULL) {
             SoftBusFree(lpParam.rawData.advData);
             DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed");
             return SOFTBUS_ERR;
         }
-        lpParam.rawData.rspDataLen = (unsigned int)ret;
     }
     lpParam.filter = (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * scanParam->filterSize);
     if (lpParam.filter == NULL) {
         SoftBusFree(lpParam.rawData.advData);
         SoftBusFree(lpParam.rawData.rspData);
-        DISC_LOGE(DISC_BLE_ADAPTER, "set lp param %d, malloc native filter failed", bcParam->advHandle);
+        DISC_LOGE(DISC_BLE_ADAPTER, "malloc native filter failed: %d", bcParam->advHandle);
         return SOFTBUS_MALLOC_ERR;
     }
     SoftbusFilterToBt(lpParam.filter, scanParam->filter, scanParam->filterSize);
@@ -653,33 +659,31 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
     lpParam.deliveryMode = LP_DELIVERY_MODE_REPLY;
     lpParam.advHandle = bcParam->advHandle;
     lpParam.duration = LP_ADV_DURATION_MS;
-    ret = SetLpDeviceParam(&lpParam);
+    int32_t ret = SetLpDeviceParam(&lpParam);
     FreeBtFilter(lpParam.filter, scanParam->filterSize);
     SoftBusFree(lpParam.filter);
     SoftBusFree(lpParam.rawData.advData);
     SoftBusFree(lpParam.rawData.rspData);
+    DISC_LOGI(DISC_BLE_ADAPTER, "advHandle: %d, ret: %d", bcParam->advHandle, ret);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "set lp param %d failed", bcParam->advHandle);
         return false;
     }
-    DISC_LOGI(DISC_BLE_ADAPTER, "set lp param %d", bcParam->advHandle);
     return true;
 }
 
 static int32_t GetBroadcastHandle(int32_t advId, int32_t *bcHandle)
 {
     if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock adv failed, advId: %d", advId);
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used");
         SoftBusMutexUnlock(&g_advLock);
+        DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used: %d", advId);
         return SOFTBUS_ERR;
     }
     int32_t ret = GetAdvHandle(g_advChannel[advId].advId, bcHandle);
-    DISC_LOGI(DISC_BLE_ADAPTER, "get broadcast handle, advId: %d, bt-advId: %d, ret: %d",
-        advId, g_advChannel[advId].advId, ret);
+    DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
     SoftBusMutexUnlock(&g_advLock);
     return ret;
 }
@@ -699,16 +703,16 @@ static int32_t DisableSyncDataToLp(void)
 static int32_t SetScanReportChannelToLp(int32_t scannerId, bool enable)
 {
     if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId: %d", scannerId);
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used");
         SoftBusMutexUnlock(&g_scannerLock);
+        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used: %d", scannerId);
         return SOFTBUS_ERR;
     }
     int32_t ret = SetScanReportChannelToLpDevice(g_scanChannel[scannerId].scannerId, enable);
-    DISC_LOGI(DISC_BLE_ADAPTER, "set scan report channel to lp, scannerId: %d, bt-scannerId: %d, ret: %d",
+    DISC_LOGI(DISC_BLE_ADAPTER, "scannerId: %d, bt-scannerId: %d, ret: %d",
         scannerId, g_scanChannel[scannerId].scannerId, ret);
     SoftBusMutexUnlock(&g_scannerLock);
     return ret;
@@ -717,7 +721,7 @@ static int32_t SetScanReportChannelToLp(int32_t scannerId, bool enable)
 static int32_t SetLpAdvParam(int32_t duration, int32_t maxExtAdvEvents, int32_t window,
     int32_t interval, int32_t bcHandle)
 {
-    DISC_LOGI(DISC_BLE_ADAPTER, "set lp adv param, handleId: %d", bcHandle);
+    DISC_LOGI(DISC_BLE_ADAPTER, "advHandle: %d", bcHandle);
     return SetLpDeviceAdvParam(duration, maxExtAdvEvents, window, interval, bcHandle);
 }
 
-- 
Gitee


From 4b3dce7590ad35c09b893a737e1878c4563bcda5 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Thu, 21 Dec 2023 11:04:45 +0000
Subject: [PATCH 78/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Futils.h.=20gatt=20ad?=
 =?UTF-8?q?apter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/ble/include/softbus_ble_utils.h         | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
index 2a8eefc239..72bcbe1459 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
@@ -47,9 +47,9 @@ void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize);
 
 int GetBtScanMode(uint16_t scanInterval, uint16_t scanWindow);
 
-int32_t AssembleAdvData(const SoftbusBroadcastData *data, uint8_t *advData);
+uint8_t *AssembleAdvData(const SoftbusBroadcastData *data, uint16_t *dataLen);
 
-int32_t AssembleRspData(const SoftbusBroadcastPayload *data, uint8_t *rspData);
+uint8_t *AssembleRspData(const SoftbusBroadcastPayload *data, uint16_t *dataLen);
 
 void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult *dst);
 
-- 
Gitee


From b55cf2af2db6586760dae02fea726956c2262126 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 22 Dec 2023 06:31:27 +0000
Subject: [PATCH 79/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 237 +++++++++++-------
 1 file changed, 148 insertions(+), 89 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 6da4204ad8..477acf0798 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -24,10 +24,12 @@
 #include <string.h>
 
 #define GATT_ADV_MAX_NUM 9
-#define GATT_SCAN_MAX_NUM 9
+#define GATT_SCAN_MAX_NUM 2
 #define LP_BT_UUID "43d4a49f-604d-45b5-9302-4ddbbfd538fd"
 #define LP_DELIVERY_MODE_REPLY 0xF0
 #define LP_ADV_DURATION_MS 0
+#define SCAN_CHANNEL_0 0
+#define SCAN_CHANNEL_1 1
 
 static atomic_bool g_init = false;
 static SoftBusMutex g_advLock = {0};
@@ -91,7 +93,7 @@ static void WrapperAdvEnableCallback(int advId, int status)
     int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u", channelId);
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u, bt-advId: %d", channelId, advId);
             continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
@@ -99,8 +101,11 @@ static void WrapperAdvEnableCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
         advChannel->isAdvertising = (st == SOFTBUS_BC_STATUS_SUCCESS);
+        if (!advChannel->isAdvertising) {
+            advChannel->advId = -1;
+        }
+        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnStartBroadcastingCallback != NULL) {
             advChannel->advCallback->OnStartBroadcastingCallback(channelId, st);
         }
@@ -114,7 +119,7 @@ static void WrapperAdvDisableCallback(int advId, int status)
     int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u", channelId);
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u, bt-advId: %d", channelId, advId);
             continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
@@ -122,8 +127,9 @@ static void WrapperAdvDisableCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
         advChannel->isAdvertising = false;
+        advChannel->advId = -1;
+        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnStopBroadcastingCallback != NULL) {
             advChannel->advCallback->OnStopBroadcastingCallback(channelId, st);
         }
@@ -137,7 +143,7 @@ static void WrapperAdvSetDataCallback(int advId, int status)
     int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint32_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u", channelId);
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u, bt-advId: %d", channelId, advId);
             continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
@@ -159,7 +165,7 @@ static void WrapperAdvUpdateDataCallback(int advId, int status)
     int32_t st = BtStatusToSoftBus((BtStatus)status);
     for (uint32_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u", channelId);
+            DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u, bt-advId: %d", channelId, advId);
             continue;
         }
         AdvChannel *advChannel = &g_advChannel[channelId];
@@ -168,7 +174,7 @@ static void WrapperAdvUpdateDataCallback(int advId, int status)
             continue;
         }
         DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
-        if (advChannel->advCallback != NULL && advChannel->advCallback->OnSetBroadcastingCallback != NULL) {
+        if (advChannel->advCallback != NULL && advChannel->advCallback->OnUpdateBroadcastingCallback != NULL) {
             advChannel->advCallback->OnUpdateBroadcastingCallback(channelId, st);
         }
         SoftBusMutexUnlock(&g_advLock);
@@ -198,8 +204,8 @@ static int32_t RegisterAdvCallback(int32_t *advId, const SoftbusBroadcastCallbac
             continue;
         }
         if (BleGattRegisterCallbacks(&g_softbusGattCb) != OHOS_BT_STATUS_SUCCESS) {
-            SoftBusMutexUnlock(&g_advLock);
             DISC_LOGE(DISC_BLE_ADAPTER, "register failed, advId: %u", channelId);
+            SoftBusMutexUnlock(&g_advLock);
             return SOFTBUS_ERR;
         }
         g_advChannel[channelId].advId = -1;
@@ -207,12 +213,12 @@ static int32_t RegisterAdvCallback(int32_t *advId, const SoftbusBroadcastCallbac
         g_advChannel[channelId].isAdvertising = false;
         g_advChannel[channelId].advCallback = (SoftbusBroadcastCallback *)cb;
         *advId = channelId;
-        SoftBusMutexUnlock(&g_advLock);
         DISC_LOGI(DISC_BLE_ADAPTER, "register success, advId: %u", channelId);
+        SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_OK;
     }
-    SoftBusMutexUnlock(&g_advLock);
     DISC_LOGE(DISC_BLE_ADAPTER, "no available adv channel");
+    SoftBusMutexUnlock(&g_advLock);
     return SOFTBUS_ERR;
 }
 
@@ -240,85 +246,126 @@ static int32_t UnRegisterAdvCallback(int32_t advId)
     return SOFTBUS_OK;
 }
 
-static void WrapperScanResultCallback(BtScanResultData *data)
+static void WrapperScanResultCallback(uint8_t channelId, BtScanResultData *data)
 {
     if (data == NULL) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "scan result data is null");
+        DISC_LOGE(DISC_BLE_ADAPTER, "scan result data is null, scannerId: %u", channelId);
+        return;
+    }
+    if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId: %u", channelId);
+        return;
+    }
+    ScanChannel *scanChannel = &g_scanChannel[channelId];
+    if (!scanChannel->isUsed || !scanChannel->isScanning) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used, scannerId: %u, bt-scannerId: %d",
+            channelId, scanChannel->scannerId);
+        SoftBusMutexUnlock(&g_scannerLock);
         return;
     }
     SoftBusBcScanResult sr;
     BtScanResultToSoftbus(data, &sr);
     ParseScanResult(data->advData, data->advLen, &sr);
-    for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
-        if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock failed, scannerId: %u", channelId);
-            continue;
-        }
-        ScanChannel *scanChannel = &g_scanChannel[channelId];
-        if (!scanChannel->isUsed || !scanChannel->isScanning) {
-            SoftBusMutexUnlock(&g_scannerLock);
-            continue;
-        }
-        if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnReportScanDataCallback != NULL) {
-            scanChannel->scanCallback->OnReportScanDataCallback(channelId, &sr);
-        }
-        SoftBusMutexUnlock(&g_scannerLock);
+    if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnReportScanDataCallback != NULL) {
+        scanChannel->scanCallback->OnReportScanDataCallback(channelId, &sr);
     }
     SoftBusFree(sr.data.bcData.payload);
     SoftBusFree(sr.data.rspData.payload);
+    SoftBusMutexUnlock(&g_scannerLock);
 }
 
-static void WrapperScanStateChangeCallback(int32_t resultCode, bool isStartScan)
+static void WrapperScanStateChangeCallback(uint8_t channelId, int32_t resultCode, bool isStartScan)
 {
-    for (uint8_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
-        if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock failed, scannerId: %u", channelId);
-            continue;
-        }
-        ScanChannel *scanChannel = &g_scanChannel[channelId];
-        if (!scanChannel->isUsed || !scanChannel->isScanning) {
-            SoftBusMutexUnlock(&g_scannerLock);
-            continue;
-        }
-        DISC_LOGI(DISC_BLE_ADAPTER, "scannerId: %d, bt-scannerId: %d, resultCode: %d, isStartScan: %d",
-            channelId, scanChannel->scannerId, resultCode, isStartScan);
-        if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnScanStateChanged != NULL) {
-            scanChannel->scanCallback->OnScanStateChanged(resultCode, isStartScan);
-        }
+    if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId: %u", channelId);
+        return;
+    }
+    ScanChannel *scanChannel = &g_scanChannel[channelId];
+    if (!scanChannel->isUsed || !scanChannel->isScanning) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used, scannerId: %u, bt-scannerId: %d",
+            channelId, scanChannel->scannerId);
         SoftBusMutexUnlock(&g_scannerLock);
-        break;
+        return;
     }
+    scanChannel->isScanning = isStartScan ? (resultCode == 0) : false;
+    DISC_LOGI(DISC_BLE_ADAPTER, "scannerId: %d, bt-scannerId: %d, resultCode: %d, isStartScan: %d",
+        channelId, scanChannel->scannerId, resultCode, isStartScan);
+    if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnScanStateChanged != NULL) {
+        scanChannel->scanCallback->OnScanStateChanged(resultCode, isStartScan);
+    }
+    SoftBusMutexUnlock(&g_scannerLock);
 }
 
-static void WrapperLpDeviceInfoCallback(BtUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
+static void WrapperLpDeviceInfoCallback(uint8_t channelId, BtUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
 {
-    for (uint32_t channelId = 0; channelId < GATT_SCAN_MAX_NUM; channelId++) {
-        if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
-            DISC_LOGW(DISC_BLE_ADAPTER, "lock failed, scannerId: %u", channelId);
-            continue;
-        }
-        ScanChannel *scanChannel = &g_scanChannel[channelId];
-        if (!scanChannel->isUsed) {
-            SoftBusMutexUnlock(&g_scannerLock);
-            continue;
-        }
-        if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnReportScanDataCallback != NULL) {
-            SoftbusBroadcastUuid bcUuid;
-            bcUuid.uuid = (uint8_t *)uuid->uuid;
-            bcUuid.uuidLen = (uint8_t)uuid->uuidLen;
-            scanChannel->scanCallback->OnLpDeviceInfoCallback(&bcUuid, type, data, dataSize);
-        }
+    if (SoftBusMutexLock(&g_scannerLock) != SOFTBUS_OK) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "lock failed, scannerId: %u", channelId);
+        return;
+    }
+    ScanChannel *scanChannel = &g_scanChannel[channelId];
+    if (!scanChannel->isUsed) {
+        DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used, scannerId: %u, bt-scannerId: %d",
+            channelId, scanChannel->scannerId);
         SoftBusMutexUnlock(&g_scannerLock);
-        break;
+        return;
+    }
+    if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnLpDeviceInfoCallback != NULL) {
+        SoftbusBroadcastUuid bcUuid;
+        bcUuid.uuid = (uint8_t *)uuid->uuid;
+        bcUuid.uuidLen = (uint8_t)uuid->uuidLen;
+        scanChannel->scanCallback->OnLpDeviceInfoCallback(&bcUuid, type, data, dataSize);
     }
+    SoftBusMutexUnlock(&g_scannerLock);
 }
 
-static BleScanCallbacks g_softbusBleScanCb = {
-    .scanResultCb = WrapperScanResultCallback,
-    .scanStateChangeCb = WrapperScanStateChangeCallback,
-    .lpDeviceInfoCb = WrapperLpDeviceInfoCallback,
+static void WrapperScanResultCallback0(BtScanResultData *data)
+{
+    WrapperScanResultCallback(SCAN_CHANNEL_0, data);
+}
+
+static void WrapperScanResultCallback1(BtScanResultData *data)
+{
+    WrapperScanResultCallback(SCAN_CHANNEL_1, data);
+}
+
+static void WrapperScanStateChangeCallback0(int32_t resultCode, bool isStartScan)
+{
+    WrapperScanStateChangeCallback(SCAN_CHANNEL_0, resultCode, isStartScan);
+}
+
+static void WrapperScanStateChangeCallback1(int32_t resultCode, bool isStartScan)
+{
+    WrapperScanStateChangeCallback(SCAN_CHANNEL_1, resultCode, isStartScan);
+}
+
+static void WrapperLpDeviceInfoCallback0(BtUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
+{
+    WrapperLpDeviceInfoCallback(SCAN_CHANNEL_0, uuid, type, data, dataSize);
+}
+
+static void WrapperLpDeviceInfoCallback1(BtUuid *uuid, int32_t type, uint8_t *data, uint32_t dataSize)
+{
+    WrapperLpDeviceInfoCallback(SCAN_CHANNEL_1, uuid, type, data, dataSize);
+}
+
+static BleScanCallbacks g_softbusBleScanCb[GATT_SCAN_MAX_NUM] = {
+    {
+        .scanResultCb = WrapperScanResultCallback0,
+        .scanStateChangeCb = WrapperScanStateChangeCallback0,
+        .lpDeviceInfoCb = WrapperLpDeviceInfoCallback0,
+    },
+    {
+        .scanResultCb = WrapperScanResultCallback1,
+        .scanStateChangeCb = WrapperScanStateChangeCallback1,
+        .lpDeviceInfoCb = WrapperLpDeviceInfoCallback1,
+    }
 };
 
+static BleScanCallbacks *GetAdapterScanCallback(uint8_t channelId)
+{
+    return &g_softbusBleScanCb[channelId];
+}
+
 static int32_t RegisterScanCallback(int32_t *scannerId, const SoftbusScanCallback *cb)
 {
     if (scannerId == NULL || cb == NULL) {
@@ -333,10 +380,10 @@ static int32_t RegisterScanCallback(int32_t *scannerId, const SoftbusScanCallbac
         if (g_scanChannel[channelId].isUsed) {
             continue;
         }
-        if (BleRegisterScanCallbacks(&g_softbusBleScanCb,
+        if (BleRegisterScanCallbacks(GetAdapterScanCallback(channelId),
             &g_scanChannel[channelId].scannerId) != OHOS_BT_STATUS_SUCCESS) {
-            SoftBusMutexUnlock(&g_scannerLock);
             DISC_LOGE(DISC_BLE_ADAPTER, "register callback failed, scannerId: %u", channelId);
+            SoftBusMutexUnlock(&g_scannerLock);
             return SOFTBUS_ERR;
         }
         g_scanChannel[channelId].isUsed = true;
@@ -347,8 +394,8 @@ static int32_t RegisterScanCallback(int32_t *scannerId, const SoftbusScanCallbac
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_OK;
     }
-    SoftBusMutexUnlock(&g_scannerLock);
     DISC_LOGE(DISC_BLE_ADAPTER, "no available scan channel");
+    SoftBusMutexUnlock(&g_scannerLock);
     return SOFTBUS_ERR;
 }
 
@@ -363,7 +410,7 @@ static int32_t UnRegisterScanCallback(int32_t scannerId)
         return SOFTBUS_LOCK_ERR;
     }
     if (!g_scanChannel[scannerId].isUsed) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "already unregistered, scannerId: %d, bt-scannerId: %d",
+        DISC_LOGI(DISC_BLE_ADAPTER, "already unregistered, scannerId: %d, bt-scannerId: %d",
             scannerId, g_scanChannel[scannerId].scannerId);
         SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_OK;
@@ -431,8 +478,8 @@ static int32_t StartAdv(int32_t advId, const SoftbusBroadcastParam *param, const
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
-        SoftBusMutexUnlock(&g_advLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used, advId: %d", advId);
+        SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
     if (g_advChannel[advId].isAdvertising) {
@@ -457,13 +504,19 @@ static int32_t StopAdv(int32_t advId)
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
-        SoftBusMutexUnlock(&g_advLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used, advId: %d", advId);
+        SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
-    g_advChannel[advId].isAdvertising = false;
+    if (!g_advChannel[advId].isAdvertising) {
+        DISC_LOGI(DISC_BLE_ADAPTER, "already stopped, advId: %d, bt-advId: %d", advId, g_advChannel[advId].advId);
+        SoftBusMutexUnlock(&g_advLock);
+        return SOFTBUS_OK;
+    }
     int32_t ret = BleStopAdv(g_advChannel[advId].advId);
     DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
+    g_advChannel[advId].isAdvertising = false;
+    g_advChannel[advId].advId = -1;
     SoftBusMutexUnlock(&g_advLock);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
         return SOFTBUS_ERR;
@@ -482,22 +535,22 @@ static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
-        SoftBusMutexUnlock(&g_advLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used, advId: %d", advId);
+        SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
     if (!g_advChannel[advId].isAdvertising) {
-        SoftBusMutexUnlock(&g_advLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "adv is not advertising, advId: %d, bt-advId: %d",
             advId, g_advChannel[advId].advId);
+        SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
     StartAdvRawData advRawData;
     advRawData.advData = (unsigned char *)AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
     if (advRawData.advData == NULL) {
-        SoftBusMutexUnlock(&g_advLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed, advId: %d, bt-advId: %d",
             advId, g_advChannel[advId].advId);
+        SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
     advRawData.rspDataLen = 0;
@@ -506,9 +559,9 @@ static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
         advRawData.rspData = (unsigned char *)AssembleRspData(&data->rspData, (uint16_t *)&advRawData.rspDataLen);
         if (advRawData.rspData == NULL) {
             SoftBusFree(advRawData.advData);
-            SoftBusMutexUnlock(&g_advLock);
             DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed, advId: %d, bt-advId: %d",
                 advId, g_advChannel[advId].advId);
+            SoftBusMutexUnlock(&g_advLock);
             return SOFTBUS_ERR;
         }
     }
@@ -523,10 +576,10 @@ static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
 static int32_t UpdateAdvData(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
 {
     if (StopAdv(advId) != SOFTBUS_OK) {
-        DISC_LOGI(DISC_BLE_ADAPTER, "update adv data failed: %d", advId);
+        DISC_LOGE(DISC_BLE_ADAPTER, "update adv data failed, advId: %d", advId);
         return SOFTBUS_ERR;
     }
-    DISC_LOGI(DISC_BLE_ADAPTER, "update adv data success: %d", advId);
+    DISC_LOGI(DISC_BLE_ADAPTER, "update adv data, advId: %d", advId);
     return StartAdv(advId, param, data);
 }
 
@@ -555,8 +608,8 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
-        SoftBusMutexUnlock(&g_scannerLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used, scannerId: %d", scannerId);
+        SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_ERR;
     }
     if (g_scanChannel[scannerId].isScanning) {
@@ -568,9 +621,9 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     BleScanNativeFilter *nativeFilter =
         (BleScanNativeFilter *)SoftBusCalloc(sizeof(BleScanNativeFilter) * filterSize);
     if (nativeFilter == NULL) {
-        SoftBusMutexUnlock(&g_scannerLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "malloc native filter failed, scannerId: %d, bt-scannerId: %d",
             scannerId, g_scanChannel[scannerId].scannerId);
+        SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_MALLOC_ERR;
     }
     SoftbusFilterToBt(nativeFilter, scanFilter, filterSize);
@@ -598,14 +651,20 @@ static int32_t StopScan(int32_t scannerId)
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
-        SoftBusMutexUnlock(&g_scannerLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used: %d", scannerId);
+        SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_ERR;
     }
-    g_scanChannel[scannerId].isScanning = false;
+    if (!g_scanChannel[scannerId].isScanning) {
+        DISC_LOGI(DISC_BLE_ADAPTER, "already stopped, scannerId: %d, bt-scannerId: %d",
+            scannerId, g_scanChannel[scannerId].scannerId);
+        SoftBusMutexUnlock(&g_scannerLock);
+        return SOFTBUS_OK;
+    }
     int32_t ret = BleStopScan(g_scanChannel[scannerId].scannerId);
     DISC_LOGI(DISC_BLE_ADAPTER, "stop scan, scannerId: %d, bt-scannerId: %d, ret: %d",
         scannerId, g_scanChannel[scannerId].scannerId, ret);
+    g_scanChannel[scannerId].isScanning = false;
     SoftBusMutexUnlock(&g_scannerLock);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
         return SOFTBUS_ERR;
@@ -628,7 +687,7 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
     lpParam.rawData.advData = (unsigned char *)AssembleAdvData(&bcParam->advData,
         (uint16_t *)&lpParam.rawData.advDataLen);
     if (lpParam.rawData.advData == NULL) {
-        DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed");
+        DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed, advHandle: %d", bcParam->advHandle);
         return SOFTBUS_ERR;
     }
     if (bcParam->advData.rspData.payloadLen > 0 && bcParam->advData.rspData.payload != NULL) {
@@ -636,7 +695,7 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
             (uint16_t *)&lpParam.rawData.rspDataLen);
         if (lpParam.rawData.rspData == NULL) {
             SoftBusFree(lpParam.rawData.advData);
-            DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed");
+            DISC_LOGE(DISC_BLE_ADAPTER, "assemble rsp data failed, advHandle: %d", bcParam->advHandle);
             return SOFTBUS_ERR;
         }
     }
@@ -644,7 +703,7 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
     if (lpParam.filter == NULL) {
         SoftBusFree(lpParam.rawData.advData);
         SoftBusFree(lpParam.rawData.rspData);
-        DISC_LOGE(DISC_BLE_ADAPTER, "malloc native filter failed: %d", bcParam->advHandle);
+        DISC_LOGE(DISC_BLE_ADAPTER, "malloc native filter failed, advHandle: %d", bcParam->advHandle);
         return SOFTBUS_MALLOC_ERR;
     }
     SoftbusFilterToBt(lpParam.filter, scanParam->filter, scanParam->filterSize);
@@ -678,8 +737,8 @@ static int32_t GetBroadcastHandle(int32_t advId, int32_t *bcHandle)
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckAdvChannelInUsed(advId)) {
-        SoftBusMutexUnlock(&g_advLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "adv is not in used: %d", advId);
+        SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
     int32_t ret = GetAdvHandle(g_advChannel[advId].advId, bcHandle);
@@ -707,8 +766,8 @@ static int32_t SetScanReportChannelToLp(int32_t scannerId, bool enable)
         return SOFTBUS_LOCK_ERR;
     }
     if (!CheckScanChannelInUsed(scannerId)) {
-        SoftBusMutexUnlock(&g_scannerLock);
         DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used: %d", scannerId);
+        SoftBusMutexUnlock(&g_scannerLock);
         return SOFTBUS_ERR;
     }
     int32_t ret = SetScanReportChannelToLpDevice(g_scanChannel[scannerId].scannerId, enable);
@@ -750,6 +809,6 @@ void SoftbusBleAdapterInit(void)
         .SetLpDeviceParam = SetLpAdvParam,
     };
     if (RegisterBroadcastMediumFunction(BROADCAST_MEDIUM_TYPE_BLE, &interface) != 0) {
-        DISC_LOGW(DISC_BLE_ADAPTER, "Register gatt interface failed.");
+        DISC_LOGE(DISC_BLE_ADAPTER, "Register gatt interface failed.");
     }
 }
\ No newline at end of file
-- 
Gitee


From 61d2a8b042cdb3fb34394b9de657dfb8fabc92c0 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 22 Dec 2023 07:52:15 +0000
Subject: [PATCH 80/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/include/softbus=5Fble=5Futils.h.=20gatt=20ad?=
 =?UTF-8?q?apter=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../broadcast/adapter/ble/include/softbus_ble_utils.h          | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
index 72bcbe1459..a9d740eaca 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/include/softbus_ble_utils.h
@@ -17,7 +17,7 @@
  * @file softbus_ble_utils.h
  * @brief ble utils
  *
- * @since 1.0
+ * @since 4.1
  * @version 1.0
  */
 
@@ -27,7 +27,6 @@
 #include "softbus_broadcast_adapter_interface.h"
 #include "c_header/ohos_bt_gatt.h"
 #include "c_header/ohos_bt_def.h"
-#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C"{
-- 
Gitee


From 0b717be18fa8577acff962c0e8008dc406dceabe Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 22 Dec 2023 07:52:34 +0000
Subject: [PATCH 81/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c  | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index 69aeb107fc..951106e5d6 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -250,7 +250,7 @@ void SoftbusFilterToBt(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFil
         (nativeFilter + filterSize)->manufactureDataMask = (unsigned char *)(filter + filterSize)->manufactureDataMask;
         (nativeFilter + filterSize)->manufactureId = (unsigned short)(filter + filterSize)->manufactureId;
 
-        if ((filter + filterSize)->serviceData == NULL || (filter + filterSize)->serviceDataMask) {
+        if ((filter + filterSize)->serviceData == NULL || (filter + filterSize)->serviceDataMask == NULL) {
             continue;
         }
 
@@ -292,6 +292,7 @@ void FreeBtFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
         SoftBusFree((nativeFilter + filterSize)->serviceData);
         SoftBusFree((nativeFilter + filterSize)->serviceDataMask);
     }
+    SoftBusFree(nativeFilter);
 }
 
 void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
@@ -313,7 +314,7 @@ void DumpBleScanFilter(BleScanNativeFilter *nativeFilter, uint8_t filterSize)
         }
         (void)ConvertBytesToHexString(serviceData, hexLen, (nativeFilter + filterSize)->serviceData, len);
         (void)ConvertBytesToHexString(serviceDataMask, hexLen, (nativeFilter + filterSize)->serviceDataMask, len);
-        DISC_LOGI(DISC_BLE_ADAPTER, "BLE Scan Filter size:%u [serviceData:%s, serviceDataMask:%s]",
+        DISC_LOGI(DISC_BLE_ADAPTER, "BLE Scan Filter size:%hhu [serviceData:%s, serviceDataMask:%s]",
             filterSize, serviceData, serviceDataMask);
         SoftBusFree(serviceData);
         SoftBusFree(serviceDataMask);
-- 
Gitee


From 1f276e9dd4ad93bfc7264a04ba2d363c6db63d2a Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Fri, 22 Dec 2023 07:52:51 +0000
Subject: [PATCH 82/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_gatt.c        | 53 +++++++++----------
 1 file changed, 26 insertions(+), 27 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index 477acf0798..c08bb1dcbf 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -71,7 +71,6 @@ static int32_t Init(void)
         return SOFTBUS_ERR;
     }
     DISC_LOGI(DISC_BLE_ADAPTER, "init success");
-    g_init = true;
     return SOFTBUS_OK;
 }
 
@@ -90,7 +89,7 @@ static int32_t DeInit(void)
 
 static void WrapperAdvEnableCallback(int advId, int status)
 {
-    int32_t st = BtStatusToSoftBus((BtStatus)status);
+    int32_t ret = BtStatusToSoftBus((BtStatus)status);
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u, bt-advId: %d", channelId, advId);
@@ -101,13 +100,13 @@ static void WrapperAdvEnableCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        advChannel->isAdvertising = (st == SOFTBUS_BC_STATUS_SUCCESS);
+        advChannel->isAdvertising = (ret == SOFTBUS_BC_STATUS_SUCCESS);
         if (!advChannel->isAdvertising) {
             advChannel->advId = -1;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
+        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, ret);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnStartBroadcastingCallback != NULL) {
-            advChannel->advCallback->OnStartBroadcastingCallback(channelId, st);
+            advChannel->advCallback->OnStartBroadcastingCallback(channelId, ret);
         }
         SoftBusMutexUnlock(&g_advLock);
         break;
@@ -116,7 +115,7 @@ static void WrapperAdvEnableCallback(int advId, int status)
 
 static void WrapperAdvDisableCallback(int advId, int status)
 {
-    int32_t st = BtStatusToSoftBus((BtStatus)status);
+    int32_t ret = BtStatusToSoftBus((BtStatus)status);
     for (uint8_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u, bt-advId: %d", channelId, advId);
@@ -129,9 +128,9 @@ static void WrapperAdvDisableCallback(int advId, int status)
         }
         advChannel->isAdvertising = false;
         advChannel->advId = -1;
-        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
+        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, ret);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnStopBroadcastingCallback != NULL) {
-            advChannel->advCallback->OnStopBroadcastingCallback(channelId, st);
+            advChannel->advCallback->OnStopBroadcastingCallback(channelId, ret);
         }
         SoftBusMutexUnlock(&g_advLock);
         break;
@@ -140,7 +139,7 @@ static void WrapperAdvDisableCallback(int advId, int status)
 
 static void WrapperAdvSetDataCallback(int advId, int status)
 {
-    int32_t st = BtStatusToSoftBus((BtStatus)status);
+    int32_t ret = BtStatusToSoftBus((BtStatus)status);
     for (uint32_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u, bt-advId: %d", channelId, advId);
@@ -151,9 +150,9 @@ static void WrapperAdvSetDataCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
+        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, ret);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnSetBroadcastingCallback != NULL) {
-            advChannel->advCallback->OnSetBroadcastingCallback(channelId, st);
+            advChannel->advCallback->OnSetBroadcastingCallback(channelId, ret);
         }
         SoftBusMutexUnlock(&g_advLock);
         break;
@@ -162,7 +161,7 @@ static void WrapperAdvSetDataCallback(int advId, int status)
 
 static void WrapperAdvUpdateDataCallback(int advId, int status)
 {
-    int32_t st = BtStatusToSoftBus((BtStatus)status);
+    int32_t ret = BtStatusToSoftBus((BtStatus)status);
     for (uint32_t channelId = 0; channelId < GATT_ADV_MAX_NUM; channelId++) {
         if (SoftBusMutexLock(&g_advLock) != SOFTBUS_OK) {
             DISC_LOGW(DISC_BLE_ADAPTER, "lock adv failed, advId: %u, bt-advId: %d", channelId, advId);
@@ -173,9 +172,9 @@ static void WrapperAdvUpdateDataCallback(int advId, int status)
             SoftBusMutexUnlock(&g_advLock);
             continue;
         }
-        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, st);
+        DISC_LOGI(DISC_BLE_ADAPTER, "advId: %u, bt-advId: %d, status: %d", channelId, advId, ret);
         if (advChannel->advCallback != NULL && advChannel->advCallback->OnUpdateBroadcastingCallback != NULL) {
-            advChannel->advCallback->OnUpdateBroadcastingCallback(channelId, st);
+            advChannel->advCallback->OnUpdateBroadcastingCallback(channelId, ret);
         }
         SoftBusMutexUnlock(&g_advLock);
         break;
@@ -263,14 +262,14 @@ static void WrapperScanResultCallback(uint8_t channelId, BtScanResultData *data)
         SoftBusMutexUnlock(&g_scannerLock);
         return;
     }
-    SoftBusBcScanResult sr;
-    BtScanResultToSoftbus(data, &sr);
-    ParseScanResult(data->advData, data->advLen, &sr);
+    SoftBusBcScanResult scanResult = {};
+    BtScanResultToSoftbus(data, &scanResult);
+    ParseScanResult(data->advData, data->advLen, &scanResult);
     if (scanChannel->scanCallback != NULL && scanChannel->scanCallback->OnReportScanDataCallback != NULL) {
-        scanChannel->scanCallback->OnReportScanDataCallback(channelId, &sr);
+        scanChannel->scanCallback->OnReportScanDataCallback(channelId, &scanResult);
     }
-    SoftBusFree(sr.data.bcData.payload);
-    SoftBusFree(sr.data.rspData.payload);
+    SoftBusFree(scanResult.data.bcData.payload);
+    SoftBusFree(scanResult.data.rspData.payload);
     SoftBusMutexUnlock(&g_scannerLock);
 }
 
@@ -441,9 +440,9 @@ static bool CheckAdvChannelInUsed(int32_t advId)
 
 static int32_t StartBleAdv(int32_t advId, const SoftbusBroadcastParam *param, const SoftbusBroadcastData *data)
 {
-    BleAdvParams advParam;
+    BleAdvParams advParam = {};
     SoftbusAdvParamToBt(param, &advParam);
-    StartAdvRawData advRawData;
+    StartAdvRawData advRawData = {};
     advRawData.advData = (unsigned char *)AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
     if (advRawData.advData == NULL) {
         DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed, advId: %d, bt-advId: %d",
@@ -545,7 +544,7 @@ static int32_t SetAdvData(int32_t advId, const SoftbusBroadcastData *data)
         SoftBusMutexUnlock(&g_advLock);
         return SOFTBUS_ERR;
     }
-    StartAdvRawData advRawData;
+    StartAdvRawData advRawData = {};
     advRawData.advData = (unsigned char *)AssembleAdvData(data, (uint16_t *)&advRawData.advDataLen);
     if (advRawData.advData == NULL) {
         DISC_LOGE(DISC_BLE_ADAPTER, "assemble adv data failed, advId: %d, bt-advId: %d",
@@ -628,7 +627,7 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     }
     SoftbusFilterToBt(nativeFilter, scanFilter, filterSize);
     DumpBleScanFilter(nativeFilter, filterSize);
-    BleScanConfigs scanConfig;
+    BleScanConfigs scanConfig = {};
     scanConfig.scanMode = GetBtScanMode(param->scanInterval, param->scanWindow);
     scanConfig.phy = (int)param->scanPhy;
     int32_t ret = BleStartScanEx(g_scanChannel[scannerId].scannerId, &scanConfig, nativeFilter, filterSize);
@@ -680,9 +679,9 @@ static bool IsLpAvailable(void)
 
 static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpScanParam *scanParam)
 {
-    BleScanConfigs scanConfig;
+    BleScanConfigs scanConfig = {};
     scanConfig.scanMode = GetBtScanMode(scanParam->scanParam.scanInterval, scanParam->scanParam.scanWindow);
-    BtLpDeviceParam lpParam;
+    BtLpDeviceParam lpParam = {};
     lpParam.scanConfig = &scanConfig;
     lpParam.rawData.advData = (unsigned char *)AssembleAdvData(&bcParam->advData,
         (uint16_t *)&lpParam.rawData.advDataLen);
@@ -709,7 +708,7 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
     SoftbusFilterToBt(lpParam.filter, scanParam->filter, scanParam->filterSize);
     lpParam.filterSize = (unsigned int)scanParam->filterSize;
     SoftbusAdvParamToBt(&bcParam->advParam, &lpParam.advParam);
-    BtUuid btUuid;
+    BtUuid btUuid = {};
     btUuid.uuid = LP_BT_UUID;
     btUuid.uuidLen = (unsigned char)strlen(LP_BT_UUID);
     lpParam.uuid = btUuid;
-- 
Gitee


From df5b4e1472cdb3db403188e0d77157a38e23dd12 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Sat, 23 Dec 2023 01:33:45 +0000
Subject: [PATCH 83/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/net?=
 =?UTF-8?q?=5Fbluetooth.gni.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91?=
 =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4?=
 =?UTF-8?q?=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 adapter/common/net/bluetooth/net_bluetooth.gni | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/adapter/common/net/bluetooth/net_bluetooth.gni b/adapter/common/net/bluetooth/net_bluetooth.gni
index be827bea49..6ea504e210 100644
--- a/adapter/common/net/bluetooth/net_bluetooth.gni
+++ b/adapter/common/net/bluetooth/net_bluetooth.gni
@@ -29,17 +29,12 @@ adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/adapter_bt_utils.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c",
-  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c",
 ]
 
 if (dsoftbus_feature_ex_kits) {
-  adapter_ble_inc += [
-    "$dsoftbus_root_path/dsoftbus_enhance/adapter/common/net/bluetooth/broadcast/adapter/ble/include",
-  ]
-  adapter_ble_src += [
-    "$dsoftbus_root_path/dsoftbus_enhance/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_enhance_ble_utils.c",
-    "$dsoftbus_root_path/dsoftbus_enhance/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c",
-  ]
+  import("$dsoftbus_root_path/dsoftbus_enhance/adapter/common/net/bluetooth/broadcast/adapter/ble/adapter_ble_enhance.gni")
+  adapter_ble_inc += adapter_ble_enhance_inc
+  adapter_ble_src += adapter_ble_enhance_src
 } else {
   adapter_ble_src += [
     "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c",
-- 
Gitee


From 74cfa5e855a78b8fbb3f58f89afce3984741ef0c Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Sat, 23 Dec 2023 01:39:12 +0000
Subject: [PATCH 84/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../adapter/ble/src/softbus_ble_utils.c       | 30 ++++++++++++-------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index 951106e5d6..f813886c71 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -21,6 +21,10 @@
 #include "disc_log.h"
 #include <securec.h>
 
+#define UUID_LEN 2
+#define UUID_MASK_LEN 2
+#define ID_LEN 2
+
 int32_t BtStatusToSoftBus(BtStatus btStatus)
 {
     int32_t status;
@@ -264,8 +268,8 @@ void SoftbusFilterToBt(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFil
         }
         serviceData[0] = serviceUuid & BC_BYTE_MASK;
         serviceData[1] = (serviceUuid >> BC_SHIFT_BIT) & BC_BYTE_MASK;
-        if(memcpy_s(serviceData + 2, serviceDataLen - 2, (filter + filterSize)->serviceData,
-            serviceDataLen - 2) != EOK) {
+        if (memcpy_s(serviceData + UUID_LEN, serviceDataLen - UUID_LEN, (filter + filterSize)->serviceData,
+            serviceDataLen - UUID_LEN) != EOK) {
             DISC_LOGW(DISC_BLE_ADAPTER, "copy service data failed");
         }
         uint8_t *serviceDataMask = (uint8_t *)SoftBusCalloc(serviceDataLen);
@@ -276,8 +280,8 @@ void SoftbusFilterToBt(BleScanNativeFilter *nativeFilter, const SoftBusBcScanFil
         }
         serviceDataMask[0] = BC_BYTE_MASK;
         serviceDataMask[1] = BC_BYTE_MASK;
-        if(memcpy_s(serviceDataMask + 2, serviceDataLen - 2, (filter + filterSize)->serviceDataMask,
-            serviceDataLen - 2) != EOK) {
+        if (memcpy_s(serviceDataMask + UUID_MASK_LEN, serviceDataLen - UUID_MASK_LEN,
+            (filter + filterSize)->serviceDataMask, serviceDataLen - UUID_MASK_LEN) != EOK) {
             DISC_LOGW(DISC_BLE_ADAPTER, "copy service data mask failed");
         }
         (nativeFilter + filterSize)->serviceData = (unsigned char *)serviceData;
@@ -397,9 +401,13 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
 {
     uint8_t index = 0;
     bool isRsp = false;
-    while (index <= advLen) {
+    while (index < advLen) {
         uint8_t len = advData[index];
-        if (index + len >= advLen) {
+        if (len == 0 ) {
+            index++;
+            continue;
+        }
+        if (index + len >= advLen || index + 1 >= advLen) {
             break;
         }
         uint8_t type = advData[++index];
@@ -407,7 +415,7 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
             dst->data.flag = advData[index + len - 1];
             dst->data.isSupportFlag = true;
         } else if (type == SHORTENED_LOCAL_NAME_BC_TYPE || type == LOCAL_NAME_BC_TYPE) {
-            if(memcpy_s(dst->localName, len - 1, &advData[index + 1], len - 1) != EOK) {
+            if (memcpy_s(dst->localName, len - 1, &advData[index + 1], len - 1) != EOK) {
                 DISC_LOGE(DISC_BLE_ADAPTER, "copy local name failed");
             }
         } else {
@@ -416,7 +424,7 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
                 DISC_LOGI(DISC_BLE_ADAPTER, "unsupported adv type: %u", type);
                 continue;
             }
-            uint8_t *payload = (uint8_t *)SoftBusCalloc(len -3);
+            uint8_t *payload = (uint8_t *)SoftBusCalloc(len - ID_LEN - 1);
             if (payload == NULL) {
                 index += len;
                 DISC_LOGE(DISC_BLE_ADAPTER, "malloc payload failed");
@@ -430,10 +438,10 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
             }
             isRsp = !isRsp;
             data->type = BtAdvTypeToSoftbus(type);
-            data->id = ((uint16_t)advData[index + 2] << BC_SHIFT_BIT) | (uint16_t)advData[index + 1];
-            data->payloadLen = len -3;
+            data->id = ((uint16_t)advData[index + ID_LEN] << BC_SHIFT_BIT) | (uint16_t)advData[index + ID_LEN - 1];
+            data->payloadLen = len - ID_LEN - 1;
             data->payload = payload;
-            if(memcpy_s(data->payload, data->payloadLen, &advData[index + 3], data->payloadLen) != EOK) {
+            if (memcpy_s(data->payload, data->payloadLen, &advData[index + 3], data->payloadLen) != EOK) {
                 DISC_LOGE(DISC_BLE_ADAPTER, "copy payload failed");
             }
         }
-- 
Gitee


From 4a1fc8244362d30c94db9bdfbf26c7bfa7f0a9eb Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Sat, 23 Dec 2023 01:49:37 +0000
Subject: [PATCH 85/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/net?=
 =?UTF-8?q?=5Fbluetooth.gni.=20gatt=20adapter=E5=B1=82=E9=9D=A2=E5=90=91?=
 =?UTF-8?q?=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4?=
 =?UTF-8?q?=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 adapter/common/net/bluetooth/net_bluetooth.gni | 1 +
 1 file changed, 1 insertion(+)

diff --git a/adapter/common/net/bluetooth/net_bluetooth.gni b/adapter/common/net/bluetooth/net_bluetooth.gni
index 6ea504e210..f13aa76b88 100644
--- a/adapter/common/net/bluetooth/net_bluetooth.gni
+++ b/adapter/common/net/bluetooth/net_bluetooth.gni
@@ -29,6 +29,7 @@ adapter_ble_src = [
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/adapter_bt_utils.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/common/softbus_adapter_bt_common.c",
   "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c",
+  "$dsoftbus_root_path/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c",
 ]
 
 if (dsoftbus_feature_ex_kits) {
-- 
Gitee


From 7581bd7dc7334c182f6da168b9ca2342d1e6da3e Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Sat, 23 Dec 2023 01:51:37 +0000
Subject: [PATCH 86/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/manager/src/softbus=5Fbroadcast=5Fmgr.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
index b5f23358c3..f8311a4aed 100644
--- a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
+++ b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
@@ -15,8 +15,14 @@
 
 #include "softbus_broadcast_manager.h"
 #include "softbus_broadcast_type.h"
+#include "softbus_errcode.h"
 
 int32_t InitBroadcastMgr(void)
+{
+    return SOFTBUS_OK;
+}
+
+int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBroadcastMediumInterface *interface)
 {
     return SOFTBUS_OK;
 }
\ No newline at end of file
-- 
Gitee


From 93e203f652bb567da835d2175c6978efc7b4188b Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Sat, 23 Dec 2023 10:10:47 +0000
Subject: [PATCH 87/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/manager/src/softbus=5Fbroadcast=5Fmgr.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
index f8311a4aed..b5f23358c3 100644
--- a/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
+++ b/adapter/common/net/bluetooth/broadcast/manager/src/softbus_broadcast_mgr.c
@@ -15,14 +15,8 @@
 
 #include "softbus_broadcast_manager.h"
 #include "softbus_broadcast_type.h"
-#include "softbus_errcode.h"
 
 int32_t InitBroadcastMgr(void)
-{
-    return SOFTBUS_OK;
-}
-
-int32_t RegisterBroadcastMediumFunction(SoftbusMediumType type, const SoftbusBroadcastMediumInterface *interface)
 {
     return SOFTBUS_OK;
 }
\ No newline at end of file
-- 
Gitee


From c2bc4960be4cd7bc0f361348f36fbcf348864972 Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Sat, 23 Dec 2023 10:12:28 +0000
Subject: [PATCH 88/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Futils.c.=20gatt=20adapte?=
 =?UTF-8?q?r=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82?=
 =?UTF-8?q?=E9=85=8D=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F?=
 =?UTF-8?q?=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
index f813886c71..8ebfd60828 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_utils.c
@@ -403,7 +403,7 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
     bool isRsp = false;
     while (index < advLen) {
         uint8_t len = advData[index];
-        if (len == 0 ) {
+        if (len == 0) {
             index++;
             continue;
         }
@@ -415,7 +415,7 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
             dst->data.flag = advData[index + len - 1];
             dst->data.isSupportFlag = true;
         } else if (type == SHORTENED_LOCAL_NAME_BC_TYPE || type == LOCAL_NAME_BC_TYPE) {
-            if (memcpy_s(dst->localName, len - 1, &advData[index + 1], len - 1) != EOK) {
+            if (memcpy_s(dst->localName, sizeof(dst->localName), &advData[index + 1], len - 1) != EOK) {
                 DISC_LOGE(DISC_BLE_ADAPTER, "copy local name failed");
             }
         } else {
@@ -441,7 +441,7 @@ void ParseScanResult(const uint8_t *advData, uint8_t advLen, SoftBusBcScanResult
             data->id = ((uint16_t)advData[index + ID_LEN] << BC_SHIFT_BIT) | (uint16_t)advData[index + ID_LEN - 1];
             data->payloadLen = len - ID_LEN - 1;
             data->payload = payload;
-            if (memcpy_s(data->payload, data->payloadLen, &advData[index + 3], data->payloadLen) != EOK) {
+            if (memcpy_s(data->payload, data->payloadLen, &advData[index + ID_LEN + 1], data->payloadLen) != EOK) {
                 DISC_LOGE(DISC_BLE_ADAPTER, "copy payload failed");
             }
         }
-- 
Gitee


From d4623e964959660588cb6b4fe6f6950113f4c1ce Mon Sep 17 00:00:00 2001
From: yuxpro <weiyuanxin3@huawei.com>
Date: Sat, 23 Dec 2023 10:12:48 +0000
Subject: [PATCH 89/89] =?UTF-8?q?update=20adapter/common/net/bluetooth/bro?=
 =?UTF-8?q?adcast/adapter/ble/src/softbus=5Fble=5Fgatt.c.=20gatt=20adapter?=
 =?UTF-8?q?=E5=B1=82=E9=9D=A2=E5=90=91=E6=8E=A5=E5=8F=A3=E9=80=82=E9=85=8D?=
 =?UTF-8?q?=EF=BC=8C=E7=A7=BB=E9=99=A4=E7=AE=A1=E7=90=86=E5=8A=9F=E8=83=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: yuxpro <weiyuanxin3@huawei.com>
---
 .../bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c   | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
index c08bb1dcbf..c00365aa8e 100644
--- a/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
+++ b/adapter/common/net/bluetooth/broadcast/adapter/ble/src/softbus_ble_gatt.c
@@ -280,7 +280,7 @@ static void WrapperScanStateChangeCallback(uint8_t channelId, int32_t resultCode
         return;
     }
     ScanChannel *scanChannel = &g_scanChannel[channelId];
-    if (!scanChannel->isUsed || !scanChannel->isScanning) {
+    if (!scanChannel->isUsed) {
         DISC_LOGE(DISC_BLE_ADAPTER, "scanner is not in used, scannerId: %u, bt-scannerId: %d",
             channelId, scanChannel->scannerId);
         SoftBusMutexUnlock(&g_scannerLock);
@@ -515,7 +515,6 @@ static int32_t StopAdv(int32_t advId)
     int32_t ret = BleStopAdv(g_advChannel[advId].advId);
     DISC_LOGI(DISC_BLE_ADAPTER, "advId: %d, bt-advId: %d, ret: %d", advId, g_advChannel[advId].advId, ret);
     g_advChannel[advId].isAdvertising = false;
-    g_advChannel[advId].advId = -1;
     SoftBusMutexUnlock(&g_advLock);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
         return SOFTBUS_ERR;
@@ -635,7 +634,6 @@ static int32_t StartScan(int32_t scannerId, const SoftBusBcScanParams *param, co
     DISC_LOGI(DISC_BLE_ADAPTER, "scannerId: %d, bt-scannerId: %d, ret: %d",
         scannerId, g_scanChannel[scannerId].scannerId, ret);
     FreeBtFilter(nativeFilter, filterSize);
-    SoftBusFree(nativeFilter);
     SoftBusMutexUnlock(&g_scannerLock);
     if (ret != OHOS_BT_STATUS_SUCCESS) {
         return SOFTBUS_ERR;
@@ -719,7 +717,6 @@ static bool SetLpParam(const SoftBusLpBroadcastParam *bcParam, const SoftBusLpSc
     lpParam.duration = LP_ADV_DURATION_MS;
     int32_t ret = SetLpDeviceParam(&lpParam);
     FreeBtFilter(lpParam.filter, scanParam->filterSize);
-    SoftBusFree(lpParam.filter);
     SoftBusFree(lpParam.rawData.advData);
     SoftBusFree(lpParam.rawData.rspData);
     DISC_LOGI(DISC_BLE_ADAPTER, "advHandle: %d, ret: %d", bcParam->advHandle, ret);
-- 
Gitee