diff --git a/core/discovery/ble/approach_ble/include/disc_approach_ble.h b/core/discovery/ble/approach_ble/include/disc_approach_ble.h new file mode 100644 index 0000000000000000000000000000000000000000..54612aac57c0068d8c92ceb0ca74053208e6188e --- /dev/null +++ b/core/discovery/ble/approach_ble/include/disc_approach_ble.h @@ -0,0 +1,35 @@ +/* + * 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. + */ + +#ifndef DISC_APPROACH_BLE_H +#define DISC_APPROACH_BLE_H + +#include "disc_manager.h" +#include "softbus_adapter_ble_gatt.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif + +void ProcessApproachPacket(const SoftBusBleScanResult *scanResultData, DiscInnerCallback *callback); + +#ifdef __cplusplus +#if __cplusplus +} +#endif /* __cplusplus */ +#endif /* __cplusplus */ +#endif /* DISC_APPROACH_BLE_H */ \ No newline at end of file diff --git a/core/discovery/ble/approach_ble/src/disc_approach_ble_virtual.c b/core/discovery/ble/approach_ble/src/disc_approach_ble_virtual.c new file mode 100644 index 0000000000000000000000000000000000000000..067ca7987d30a8d697c00f636aea3fd3848d64c5 --- /dev/null +++ b/core/discovery/ble/approach_ble/src/disc_approach_ble_virtual.c @@ -0,0 +1,22 @@ +/* + * 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 "disc_approach_ble.h" + +void ProcessApproachPacket(const SoftBusBleScanResult *scanResultData, DiscInnerCallback *callback) +{ + (void)scanResultData; + (void)callback; +} \ No newline at end of file diff --git a/core/discovery/ble/disc_ble.gni b/core/discovery/ble/disc_ble.gni index 4d14cbe6c1861cd462446e5c7669f227c4139a50..508eaf258b8ea5de4ab4f8eac688a3c2560f6ade 100644 --- a/core/discovery/ble/disc_ble.gni +++ b/core/discovery/ble/disc_ble.gni @@ -14,16 +14,17 @@ import("//foundation/communication/dsoftbus/dsoftbus.gni") native_source_path = rebase_path("$dsoftbus_root_path") -disc_dep_dir = "dsoftbus_enhance/core/discovery/ble/share_ble" -enhanced_share = exec_script("$dsoftbus_root_path/check_sub_module.py", - [ - "$native_source_path", - "$disc_dep_dir", - ], - "value") +disc_dep_dir = "dsoftbus_enhance/core/discovery/ble" +disc_enhanced = exec_script("$dsoftbus_root_path/check_sub_module.py", + [ + "$native_source_path", + "$disc_dep_dir", + ], + "value") ble_discovery_inc = [ "$dsoftbus_root_path/core/discovery/ble/dispatcher/include", + "$dsoftbus_root_path/core/discovery/ble/approach_ble/include", "$dsoftbus_root_path/core/discovery/ble/share_ble/include", "$dsoftbus_root_path/core/discovery/ble/softbus_ble/include", "$dsoftbus_root_path/core/common/include", @@ -46,13 +47,18 @@ if (!support_bluetooth) { } } -if (enhanced_share) { +if (disc_enhanced) { + import( + "$dsoftbus_root_path/dsoftbus_enhance/core/discovery/ble/approach_ble/approach_ble.gni") import( "$dsoftbus_root_path/dsoftbus_enhance/core/discovery/ble/share_ble/share_ble.gni") - ble_discovery_src += share_sources - ble_discovery_inc += share_include_dirs - ble_discovery_deps += share_deps + ble_discovery_src += share_sources + approach_sources + ble_discovery_inc += share_include_dirs + approach_include_dirs + ble_discovery_deps += share_deps + approach_deps } else { - ble_discovery_src += [ "$dsoftbus_root_path/core/discovery/ble/share_ble/src/disc_share_ble_virtual.c" ] + ble_discovery_src += [ + "$dsoftbus_root_path/core/discovery/ble/share_ble/src/disc_share_ble_virtual.c", + "$dsoftbus_root_path/core/discovery/ble/approach_ble/src/disc_approach_ble_virtual.c", + ] } diff --git a/core/discovery/ble/softbus_ble/include/disc_ble_constant.h b/core/discovery/ble/softbus_ble/include/disc_ble_constant.h index 5bada0dd9caefa99f32ef6a4a9dd004f31e37c80..799359f084bcf8ed9e9924cba3a819db44a3d09c 100644 --- a/core/discovery/ble/softbus_ble/include/disc_ble_constant.h +++ b/core/discovery/ble/softbus_ble/include/disc_ble_constant.h @@ -20,6 +20,7 @@ #define MAX_CAP_NUM (CAPABILITY_NUM * INT32_MAX_BIT_NUM) #define BLE_SCAN_FILTER_LEN 7 +#define MAX_BLE_FILTER_SIZE 2 #define CUST_DATA_MAX_LEN 14 #define SOFTBUS_BLE_CLIENT_ID 0x1 @@ -40,6 +41,9 @@ #define UUID_LEN 2 #define ADV_HEAD_LEN 7 #define RSP_HEAD_LEN 4 +#define POS_UUID_NO_FLAG 2 +#define ADV_HEAD_LEN_NO_FLAG 4 +#define APPROACH_RSP_HEAD_LEN 1 #define FLAG_BYTE_LEN 0x2 #define FLAG_AD_TYPE 0x1 @@ -68,6 +72,7 @@ #define POS_CAPABLITY 5 #define POS_CAPABLITY_EXTENSION 6 #define POS_TLV 7 +#define POS_TLV_APPROACH 3 #define SHORT_USER_ID_HASH_LEN 2 #define SHORT_DEVICE_ID_HASH_LENGTH 8 @@ -82,4 +87,7 @@ #define MAX_BROADCAST_DATA_LEN 31 #define SCAN_RSP_HEADER_LEN 4 +#define AD_TYPE_LOCAL_NAME_SHORT 0x08 +#define AD_TYPE_LOCAL_NAME_CMPL 0x09 + #endif diff --git a/core/discovery/ble/softbus_ble/include/disc_ble_utils.h b/core/discovery/ble/softbus_ble/include/disc_ble_utils.h index dc93edfb9e65f65a464a5fdfbb0fd463749c39f8..39b8b2df7d24516b2ea854af2088769d5e5d88f1 100644 --- a/core/discovery/ble/softbus_ble/include/disc_ble_utils.h +++ b/core/discovery/ble/softbus_ble/include/disc_ble_utils.h @@ -52,6 +52,11 @@ typedef struct { int8_t power; } DeviceWrapper; +typedef struct { + uint8_t version; + uint8_t business; +} DiscBleScanFilter; + bool CheckBitMapEmpty(uint32_t capBitMapNum, const uint32_t *capBitMap); bool CheckCapBitMapExist(uint32_t capBitMapNum, const uint32_t *capBitMap, uint32_t pos); void SetCapBitMapPos(uint32_t capBitMapNum, uint32_t *capBitMap, uint32_t pos); @@ -65,6 +70,10 @@ int32_t DiscBleGetShortUserIdHash(unsigned char *hashStr, uint32_t len); int32_t AssembleTLV(BroadcastData *broadcastData, unsigned char dataType, const void *data, uint32_t dataLen); int32_t GetDeviceInfoFromDisAdvData(DeviceWrapper *info, const unsigned char *data, uint32_t dataLen); +int32_t ConvertBleAddr(DeviceInfo *foundInfo); +int32_t RangeDevice(DeviceInfo *foundInfo, char rssi, int8_t power); +bool CheckAdvFlagExist(const uint8_t *data, uint32_t len); + #ifdef __cplusplus #if __cplusplus } diff --git a/core/discovery/ble/softbus_ble/src/disc_ble.c b/core/discovery/ble/softbus_ble/src/disc_ble.c index b8a99677d9042887ccfdadc60b0690cf55d8324b..538621d2279e1670fda411da135bcafdae0232d9 100644 --- a/core/discovery/ble/softbus_ble/src/disc_ble.c +++ b/core/discovery/ble/softbus_ble/src/disc_ble.c @@ -22,6 +22,7 @@ #include "disc_ble_constant.h" #include "disc_ble_utils.h" #include "disc_manager.h" +#include "disc_approach_ble.h" #include "discovery_service.h" #include "lnn_device_info.h" #include "lnn_ohos_account.h" @@ -58,9 +59,10 @@ #define BLE_MSG_TIME_OUT 6000 -/* Defination of boardcast */ +// Defination of boardcast #define BLE_VERSION 4 -#define NEARBY_BUSINESS 0x1 +#define APPROACH_VERSION 1 +#define APPROACH_BUSINESS 0x1 #define DISTRIBUTE_BUSINESS 0x5 #define BYTE_MASK 0xFF #define DEVICE_NAME_MAX_LEN 15 @@ -167,11 +169,17 @@ static DiscBleListener g_bleListener = { .scanListenerId = -1 }; +static const DiscBleScanFilter g_bleScanFilters[MAX_BLE_FILTER_SIZE] = { + { BLE_VERSION, DISTRIBUTE_BUSINESS }, + { APPROACH_VERSION, APPROACH_BUSINESS } +}; + //g_conncernCapabilityMask support capability of this ble discovery static uint32_t g_concernCapabilityMask = 1 << CASTPLUS_CAPABILITY_BITMAP | 1 << DVKIT_CAPABILITY_BITMAP | - 1 << OSD_CAPABILITY_BITMAP; + 1 << OSD_CAPABILITY_BITMAP | + 1 << APPROACH_CAPABILITY_BITMAP; static const int g_bleTransCapabilityMap[CAPABILITY_MAX_BITNUM] = { -1, @@ -180,7 +188,7 @@ static const int g_bleTransCapabilityMap[CAPABILITY_MAX_BITNUM] = { -1, OSD_CAPABILITY_BITMAP, -1, - -1, + APPROACH_CAPABILITY_BITMAP, -1, -1, -1, @@ -207,7 +215,7 @@ static int32_t BleInfoDump(int fd); static int32_t BleAdvertiserDump(int fd); static int32_t RecvMessageInfoDump(int fd); -/* This function is used to compatibled with mobile phone, will remove later */ +// This function is used to compatibled with mobile phone, will remove later static int ConvertCapBitMap(int oldCap) { switch (oldCap) { @@ -309,30 +317,50 @@ static bool CheckScanner(void) return scanCapBit != 0; } -static int32_t ScanFilter(const SoftBusBleScanResult *scanResultData) +static inline bool IsDistributedBusiness(const uint8_t *data) { - uint32_t advLen = scanResultData->advLen; - uint8_t *advData = scanResultData->advData; - DISC_CHECK_AND_RETURN_RET_LOG(scanResultData->dataStatus == SOFTBUS_BLE_DATA_COMPLETE, SOFTBUS_ERR, - "dataStatus[%u] is invalid", scanResultData->dataStatus); - DISC_CHECK_AND_RETURN_RET_LOG(advLen >= (POS_TLV + ADV_HEAD_LEN), SOFTBUS_ERR, - "advLen[%u] is too short, less than adv header length", advLen); - - uint32_t broadcastAdvLen = advData[POS_PACKET_LENGTH]; - DISC_CHECK_AND_RETURN_RET_LOG(broadcastAdvLen >= (ADV_HEAD_LEN + RSP_HEAD_LEN - 1), SOFTBUS_ERR, - "broadcastAdvLen[%u] is too short, less than adv header length", broadcastAdvLen); - DISC_CHECK_AND_RETURN_RET_LOG(advLen > (POS_PACKET_LENGTH + broadcastAdvLen + 1), SOFTBUS_ERR, - "advLen[%u] is too short, less than adv packet length", advLen); - uint32_t broadcastRspLen = advData[POS_PACKET_LENGTH + broadcastAdvLen + 1]; - DISC_CHECK_AND_RETURN_RET_LOG(advLen >= (POS_PACKET_LENGTH + broadcastAdvLen + 1 + broadcastRspLen + 1), - SOFTBUS_ERR, "advLen[%u] is too short, less than adv+rsp packet length", advLen); - - DISC_CHECK_AND_RETURN_RET_LOG(advData[POS_UUID] == (uint8_t)(BLE_UUID & BYTE_MASK), SOFTBUS_ERR, - "uuid low byte[%hhu] is invalid", advData[POS_UUID]); - DISC_CHECK_AND_RETURN_RET_LOG(advData[POS_UUID + 1] == (uint8_t)((BLE_UUID >> BYTE_SHIFT_BIT) & BYTE_MASK), - SOFTBUS_ERR, "uuid high byte[%hhu] is invalid", advData[POS_UUID + 1]); - DISC_CHECK_AND_RETURN_RET_LOG(advData[POS_VERSION + ADV_HEAD_LEN] == BLE_VERSION, SOFTBUS_ERR, - "adv version[%hhu] is invalid", advData[POS_VERSION + ADV_HEAD_LEN]); + return data[POS_BUSINESS + ADV_HEAD_LEN_NO_FLAG] == DISTRIBUTE_BUSINESS; +} + +static inline bool IsApproachBusiness(const uint8_t *data) +{ + return data[POS_BUSINESS + ADV_HEAD_LEN_NO_FLAG] == APPROACH_BUSINESS; +} + +static int32_t ScanFilter(const uint8_t *advData, uint32_t advLen) +{ + DISC_CHECK_AND_RETURN_RET_LOG(advLen > (ADV_HEAD_LEN_NO_FLAG + POS_BUSINESS), SOFTBUS_ERR, + "advLen[%u] is too short, less than adv business header length", advLen); + + DISC_CHECK_AND_RETURN_RET_LOG(advData[POS_UUID_NO_FLAG] == (uint8_t)(BLE_UUID & BYTE_MASK), SOFTBUS_ERR, + "uuid low byte[%hhu] is invalid", advData[POS_UUID_NO_FLAG]); + DISC_CHECK_AND_RETURN_RET_LOG(advData[POS_UUID_NO_FLAG + 1] == + (uint8_t)((BLE_UUID >> BYTE_SHIFT_BIT) & BYTE_MASK), + SOFTBUS_ERR, "uuid high byte[%hhu] is invalid", advData[POS_UUID_NO_FLAG + 1]); + + uint32_t broadcastAdvLen = advData[0]; + if (IsApproachBusiness(advData)) { + DISC_CHECK_AND_RETURN_RET_LOG(advLen >= (POS_TLV_APPROACH + ADV_HEAD_LEN_NO_FLAG), SOFTBUS_ERR, + "advLen[%u] is too short, less than adv header length", advLen); + DISC_CHECK_AND_RETURN_RET_LOG(broadcastAdvLen >= ADV_HEAD_LEN_NO_FLAG, SOFTBUS_ERR, + "broadcastAdvLen[%u] is too short, less than adv header length", broadcastAdvLen); + DISC_CHECK_AND_RETURN_RET_LOG(advLen > broadcastAdvLen, SOFTBUS_ERR, + "advLen[%u] is too short, less than adv packet length", advLen); + DISC_CHECK_AND_RETURN_RET_LOG(advData[POS_VERSION + ADV_HEAD_LEN_NO_FLAG] == APPROACH_VERSION, SOFTBUS_ERR, + "adv version[%hhu] is invalid", advData[POS_VERSION + ADV_HEAD_LEN_NO_FLAG]); + } else { + DISC_CHECK_AND_RETURN_RET_LOG(advLen >= (POS_TLV + ADV_HEAD_LEN_NO_FLAG), SOFTBUS_ERR, + "advLen[%u] is too short, less than adv header length", advLen); + DISC_CHECK_AND_RETURN_RET_LOG(broadcastAdvLen >= (ADV_HEAD_LEN_NO_FLAG + RSP_HEAD_LEN - 1), SOFTBUS_ERR, + "broadcastAdvLen[%u] is too short, less than adv header length", broadcastAdvLen); + DISC_CHECK_AND_RETURN_RET_LOG(advLen > (broadcastAdvLen + 1), SOFTBUS_ERR, + "advLen[%u] is too short, less than adv packet length", advLen); + uint32_t broadcastRspLen = advData[broadcastAdvLen + 1]; + DISC_CHECK_AND_RETURN_RET_LOG(advLen >= (broadcastAdvLen + 1 + broadcastRspLen + 1), + SOFTBUS_ERR, "advLen[%u] is too short, less than adv+rsp packet length", advLen); + DISC_CHECK_AND_RETURN_RET_LOG(advData[POS_VERSION + ADV_HEAD_LEN_NO_FLAG] == BLE_VERSION, SOFTBUS_ERR, + "adv version[%hhu] is invalid", advData[POS_VERSION + ADV_HEAD_LEN_NO_FLAG]); + } if (!CheckScanner()) { DLOGI("no need to scan"); @@ -397,41 +425,6 @@ static bool ProcessHashAccount(DeviceInfo *foundInfo) return false; } -static int32_t ConvertBleAddr(DeviceInfo *foundInfo) -{ - // convert ble bin mac to string mac before report - char bleMac[BT_MAC_LEN] = {0}; - if (ConvertBtMacToStr(bleMac, BT_MAC_LEN, - (uint8_t *)foundInfo->addr[0].info.ble.bleMac, BT_ADDR_LEN) != SOFTBUS_OK) { - DLOGE("convert ble mac to string failed"); - return SOFTBUS_ERR; - } - (void)memset_s(foundInfo->addr[0].info.ble.bleMac, BT_MAC_LEN, 0, BT_MAC_LEN); - (void)memcpy_s(foundInfo->addr[0].info.ble.bleMac, BT_MAC_LEN, bleMac, BT_MAC_LEN); - return SOFTBUS_OK; -} - -static int32_t RangeDevice(DeviceInfo *foundInfo, char rssi, int8_t power) -{ - int32_t range = -1; - if (power != SOFTBUS_ILLEGAL_BLE_POWER) { - SoftBusRangeParam param = { - .rssi = *(signed char *)(&rssi), - .power = power, - .identity = {0} - }; - (void)memcpy_s(param.identity, SOFTBUS_DEV_IDENTITY_LEN, foundInfo->devId, DISC_MAX_DEVICE_ID_LEN); - int ret = SoftBusBleRange(¶m, &range); - if (ret != SOFTBUS_OK) { - DLOGE("range device failed, ret=%d", ret); - range = -1; - // range failed should report device continually - } - } - foundInfo->range = range; - return SOFTBUS_OK; -} - static void ProcessDisNonPacket(const uint8_t *advData, uint32_t advLen, char rssi, DeviceInfo *foundInfo) { @@ -504,29 +497,33 @@ static void ProcessDistributePacket(const SoftBusBleScanResult *scanResultData) } } -static inline bool IsDistributedBusiness(const uint8_t *data) -{ - return data[POS_BUSINESS + ADV_HEAD_LEN] == DISTRIBUTE_BUSINESS; -} - -static inline bool IsNearByBusiness(const uint8_t *data) -{ - return data[POS_BUSINESS + ADV_HEAD_LEN] == NEARBY_BUSINESS; -} - static void BleScanResultCallback(int listenerId, const SoftBusBleScanResult *scanResultData) { (void)listenerId; DISC_CHECK_AND_RETURN_LOG(scanResultData != NULL, "scan result is null"); DISC_CHECK_AND_RETURN_LOG(scanResultData->advData != NULL, "scan result advData is null"); - DISC_CHECK_AND_RETURN_LOG(ScanFilter(scanResultData) == SOFTBUS_OK, "scan filter failed"); + DISC_CHECK_AND_RETURN_LOG(scanResultData->dataStatus == SOFTBUS_BLE_DATA_COMPLETE, "dataStatus[%u] is invalid", + scanResultData->dataStatus); uint8_t *advData = scanResultData->advData; + uint32_t advLen = scanResultData->advLen; + // check adv flag and skip it + if (CheckAdvFlagExist(advData, advLen)) { + advLen -= (FLAG_BYTE_LEN + TL_LEN); + advData += (FLAG_BYTE_LEN + TL_LEN); + } + + if (ScanFilter(advData, advLen) != SOFTBUS_OK) { + DLOGE("scan filter failed"); + return; + } + if (IsDistributedBusiness(advData)) { - SignalingMsgPrint("ble rcv", advData, scanResultData->advLen, SOFTBUS_LOG_DISC); + SignalingMsgPrint("ble rcv", advData, advLen, SOFTBUS_LOG_DISC); ProcessDistributePacket(scanResultData); - } else if (IsNearByBusiness(advData)) { - DLOGI("ignore nearby business"); + } else if (IsApproachBusiness(advData)) { + DLOGI("Process packet for approach business"); + ProcessApproachPacket(scanResultData, g_discBleInnerCb); } else { DLOGI("ignore other business"); } @@ -1565,41 +1562,45 @@ static int32_t DiscBleLooperInit(void) return SOFTBUS_OK; } -static void DiscFreeBleScanFilter(SoftBusBleScanFilter *filter) +static void DiscFreeBleScanFilter(SoftBusBleScanFilter *filters) { - if (filter) { - SoftBusFree(filter->serviceData); - SoftBusFree(filter->serviceDataMask); - SoftBusFree(filter); + DISC_CHECK_AND_RETURN_LOG(filters != NULL, "filters is NULL"); + for (int32_t i = 0; i < MAX_BLE_FILTER_SIZE; i++) { + SoftBusFree(filters[i].serviceData); + SoftBusFree(filters[i].serviceDataMask); } + SoftBusFree(filters); } static void DiscBleSetScanFilter(int32_t listenerId) { - SoftBusBleScanFilter *filter = (SoftBusBleScanFilter *)SoftBusCalloc(sizeof(SoftBusBleScanFilter)); - DISC_CHECK_AND_RETURN_LOG(filter != NULL, "malloc filter failed"); + SoftBusBleScanFilter *filters = (SoftBusBleScanFilter *)SoftBusCalloc(sizeof(SoftBusBleScanFilter) * + MAX_BLE_FILTER_SIZE); + DISC_CHECK_AND_RETURN_LOG(filters != NULL, "calloc disc ble scan filters failed"); - filter->serviceData = (uint8_t *)SoftBusCalloc(BLE_SCAN_FILTER_LEN); - filter->serviceDataMask = (uint8_t *)SoftBusCalloc(BLE_SCAN_FILTER_LEN); - if (filter->serviceData == NULL || filter->serviceDataMask == NULL) { - DLOGE("malloc filter data failed"); - DiscFreeBleScanFilter(filter); - return; - } + for (int32_t i = 0; i < MAX_BLE_FILTER_SIZE; i++) { + filters[i].serviceData = (uint8_t *)SoftBusCalloc(BLE_SCAN_FILTER_LEN); + filters[i].serviceDataMask = (uint8_t *)SoftBusCalloc(BLE_SCAN_FILTER_LEN); + if (filters[i].serviceData == NULL || filters[i].serviceDataMask == NULL) { + DLOGE("malloc filters data failed"); + DiscFreeBleScanFilter(filters); + return; + } - filter->serviceDataLength = BLE_SCAN_FILTER_LEN; - filter->serviceData[0] = BLE_UUID & BYTE_MASK; - filter->serviceData[1] = (BLE_UUID >> BYTE_SHIFT_BIT) & BYTE_MASK; - filter->serviceData[UUID_LEN + POS_VERSION] = BLE_VERSION; - filter->serviceData[UUID_LEN + POS_BUSINESS] = DISTRIBUTE_BUSINESS; - filter->serviceDataMask[0] = BYTE_MASK; - filter->serviceDataMask[1] = BYTE_MASK; - filter->serviceDataMask[UUID_LEN + POS_VERSION] = BYTE_MASK; - filter->serviceDataMask[UUID_LEN + POS_BUSINESS] = BYTE_MASK; + filters[i].serviceDataLength = BLE_SCAN_FILTER_LEN; + filters[i].serviceData[0] = BLE_UUID & BYTE_MASK; + filters[i].serviceData[1] = (BLE_UUID >> BYTE_SHIFT_BIT) & BYTE_MASK; + filters[i].serviceData[UUID_LEN + POS_VERSION] = g_bleScanFilters[i].version; + filters[i].serviceData[UUID_LEN + POS_BUSINESS] = g_bleScanFilters[i].business; + filters[i].serviceDataMask[0] = BYTE_MASK; + filters[i].serviceDataMask[1] = BYTE_MASK; + filters[i].serviceDataMask[UUID_LEN + POS_VERSION] = BYTE_MASK; + filters[i].serviceDataMask[UUID_LEN + POS_BUSINESS] = BYTE_MASK; + } - if (SoftBusSetScanFilter(listenerId, filter, 1) != SOFTBUS_OK) { - DLOGE("set scan filter failed"); - DiscFreeBleScanFilter(filter); + if (SoftBusSetScanFilter(listenerId, filters, MAX_BLE_FILTER_SIZE) != SOFTBUS_OK) { + DLOGE("set scan filters failed"); + DiscFreeBleScanFilter(filters); } } diff --git a/core/discovery/ble/softbus_ble/src/disc_ble_utils.c b/core/discovery/ble/softbus_ble/src/disc_ble_utils.c index dcf99c89ca0528d0df25b916352e8c56004bf315..a5518bcdaa99aa4e049225799bed45859e8a806a 100644 --- a/core/discovery/ble/softbus_ble/src/disc_ble_utils.c +++ b/core/discovery/ble/softbus_ble/src/disc_ble_utils.c @@ -24,6 +24,7 @@ #include "securec.h" #include "softbus_adapter_crypto.h" #include "softbus_adapter_mem.h" +#include "softbus_adapter_range.h" #include "softbus_common.h" #include "softbus_def.h" #include "softbus_errcode.h" @@ -41,6 +42,8 @@ #define MAC_BIT_FOUR 4 #define MAC_BIT_FIVE 5 +#define INVALID_RANGE (-1) + bool CheckBitMapEmpty(uint32_t capBitMapNum, const uint32_t *capBitMap) { for (uint32_t i = 0; i < capBitMapNum; i++) { @@ -303,4 +306,60 @@ int32_t GetDeviceInfoFromDisAdvData(DeviceWrapper *device, const uint8_t *data, int32_t ret = ParseRecvTlvs(device, copyData, advLen + scanRspTlvLen); SoftBusFree(copyData); return ret; +} + +int32_t ConvertBleAddr(DeviceInfo *foundInfo) +{ + DISC_CHECK_AND_RETURN_RET_LOG(foundInfo != NULL, SOFTBUS_INVALID_PARAM, "invalid foundInfo"); + // convert ble bin mac to string mac before report + char bleMac[BT_MAC_LEN] = {0}; + if (ConvertBtMacToStr(bleMac, BT_MAC_LEN, + (uint8_t *)foundInfo->addr[0].info.ble.bleMac, BT_ADDR_LEN) != SOFTBUS_OK) { + DLOGE("convert ble mac to string failed"); + return SOFTBUS_ERR; + } + if (memset_s(foundInfo->addr[0].info.ble.bleMac, BT_MAC_LEN, 0, BT_MAC_LEN) != EOK) { + DLOGE("memset ble mac failed"); + return SOFTBUS_ERR; + } + if (memcpy_s(foundInfo->addr[0].info.ble.bleMac, BT_MAC_LEN, bleMac, BT_MAC_LEN) != EOK) { + DLOGE("memcopy ble mac failed"); + return SOFTBUS_ERR; + } + return SOFTBUS_OK; +} + +int32_t RangeDevice(DeviceInfo *foundInfo, char rssi, int8_t power) +{ + DISC_CHECK_AND_RETURN_RET_LOG(foundInfo != NULL, SOFTBUS_INVALID_PARAM, "invalid foundInfo"); + if (power == SOFTBUS_ILLEGAL_BLE_POWER) { + foundInfo->range = INVALID_RANGE; + return SOFTBUS_OK; + } + + int32_t range = INVALID_RANGE; + SoftBusRangeParam param = { + .rssi = *(signed char *)(&rssi), + .power = power, + .identity = {0} + }; + (void)memcpy_s(param.identity, SOFTBUS_DEV_IDENTITY_LEN, foundInfo->addr->info.ble.bleMac, BT_MAC_LEN); + int ret = SoftBusBleRange(¶m, &range); + if (ret != SOFTBUS_OK) { + DLOGE("range device failed, ret=%d", ret); + range = INVALID_RANGE; + // range failed should report device continually + } + foundInfo->range = range; + return SOFTBUS_OK; +} + +bool CheckAdvFlagExist(const uint8_t *data, uint32_t len) +{ + DISC_CHECK_AND_RETURN_RET_LOG(data != NULL, SOFTBUS_INVALID_PARAM, "invalid data"); + if (len < FLAG_BYTE_LEN + TL_LEN) { + DLOGE("adv len too short, len=%u", len); + return false; + } + return (data[0] == FLAG_BYTE_LEN && data[1] == FLAG_AD_TYPE); } \ No newline at end of file diff --git a/interfaces/kits/common/softbus_common.h b/interfaces/kits/common/softbus_common.h index ebdfbbbc8a9b776800194ae8b3446da79859752f..437e7ad45fa58be70246998f7524f162ba764c3c 100644 --- a/interfaces/kits/common/softbus_common.h +++ b/interfaces/kits/common/softbus_common.h @@ -334,7 +334,9 @@ typedef enum { /** Osd capability */ OSD_CAPABILITY_BITMAP, /**Share capability */ - SHARE_CAPABILITY_BITMAP + SHARE_CAPABILITY_BITMAP, + /**Approach capability */ + APPROACH_CAPABILITY_BITMAP } DataBitMap; /** @@ -362,6 +364,7 @@ static const CapabilityMap g_capabilityMap[] = { {DDMP_CAPABILITY_BITMAP, (char *)"ddmpCapability"}, {OSD_CAPABILITY_BITMAP, (char *)"osdCapability"}, {SHARE_CAPABILITY_BITMAP, (char *)"share"}, + {APPROACH_CAPABILITY_BITMAP, (char *)"approach"}, }; /** diff --git a/tests/core/discovery/ble/softbus_ble/BUILD.gn b/tests/core/discovery/ble/softbus_ble/BUILD.gn index d0dab638f05032bd151340d828ea0f0595f9bf7c..87a2e579fe3d48db626254f4d10746b9354b8306 100644 --- a/tests/core/discovery/ble/softbus_ble/BUILD.gn +++ b/tests/core/discovery/ble/softbus_ble/BUILD.gn @@ -27,6 +27,7 @@ ohos_unittest("DiscSoftBusBleTest") { "$dsoftbus_root_path/core/discovery/ble/dispatcher/include", "$dsoftbus_root_path/core/discovery/manager/include", "$dsoftbus_root_path/core/discovery/interface", + "$dsoftbus_root_path/core/discovery/ble/approach_ble/include", "$dsoftbus_root_path/core/discovery/ble/softbus_ble/include", "$dsoftbus_root_path/interfaces/kits/common", "$dsoftbus_root_path/interfaces/kits/discovery", diff --git a/tests/core/discovery/ble/softbus_ble_mock/BUILD.gn b/tests/core/discovery/ble/softbus_ble_mock/BUILD.gn index 21cd1a9f3122ecf23364f56d7880c84a133fb681..24e35a88dc3e2836f4b770b8bb29ca3dce766891 100644 --- a/tests/core/discovery/ble/softbus_ble_mock/BUILD.gn +++ b/tests/core/discovery/ble/softbus_ble_mock/BUILD.gn @@ -22,6 +22,7 @@ module_output_path = "dsoftbus/discovery" ohos_unittest("DiscBleTest") { module_out_path = module_output_path sources = [ + "$dsoftbus_root_path/core/discovery/ble/approach_ble/src/disc_approach_ble_virtual.c", "$dsoftbus_root_path/core/discovery/ble/softbus_ble/src/disc_ble.c", "$dsoftbus_root_path/core/discovery/ble/softbus_ble/src/disc_ble_utils.c", "ble_mock.cpp", @@ -35,6 +36,7 @@ ohos_unittest("DiscBleTest") { "$dsoftbus_root_path/core/discovery/ble/dispatcher/include", "$dsoftbus_root_path/core/discovery/manager/include", "$dsoftbus_root_path/core/discovery/interface", + "$dsoftbus_root_path/core/discovery/ble/approach_ble/include", "$dsoftbus_root_path/core/discovery/ble/softbus_ble/include", "$dsoftbus_root_path/interfaces/kits/common", "$dsoftbus_root_path/interfaces/kits/discovery",