LE filters without custom data types am: 1874cc7371 (45bfd927) · Commits · e / os / android_packages_modules_Bluetooth

system/btif/src/btif_ble_scanner.cc

+51 −93

Original line number	Diff line number	Diff line
		@@ -415,129 +415,87 @@ class BleScannerInterfaceImpl : public BleScannerInterface {
		if (data.size() != mask.size() && data.size() != 0 && mask.size() != 0)
		return;

		tBTM_BLE_PF_COND_PARAM* p_cond;
		switch (filt_type) {
		case BTM_BLE_PF_ADDR_FILTER: {
		p_cond = new tBTM_BLE_PF_COND_PARAM;
		memset(p_cond, 0, sizeof(tBTM_BLE_PF_COND_PARAM));
		tBLE_BD_ADDR target_addr;
		bdcpy(target_addr.bda, bd_addr->address);
		target_addr.type = addr_type;

		bdcpy(p_cond->target_addr.bda, bd_addr->address);
		p_cond->target_addr.type = addr_type;
		break;
		do_in_bta_thread(
		FROM_HERE,
		base::Bind(&BTM_LE_PF_addr_filter, action, filt_index,
		std::move(target_addr),
		Bind(&bta_scan_filt_cfg_cb, filt_type, client_if)));
		return;
		}

		case BTM_BLE_PF_SRVC_DATA:
		p_cond = nullptr;
		break;

		case BTM_BLE_PF_SRVC_UUID: {
		p_cond = new tBTM_BLE_PF_COND_PARAM;
		memset(p_cond, 0, sizeof(tBTM_BLE_PF_COND_PARAM));
		do_in_bta_thread(FROM_HERE,
		base::Bind(&BTM_LE_PF_srvc_data, action, filt_index));
		return;

		case BTM_BLE_PF_SRVC_UUID:
		case BTM_BLE_PF_SRVC_SOL_UUID: {
		tBT_UUID bt_uuid;
		btif_to_bta_uuid(&bt_uuid, p_uuid);

		p_cond->srvc_uuid.cond_logic = BTM_BLE_PF_LOGIC_AND;
		p_cond->srvc_uuid.uuid = bt_uuid;

		if (p_uuid_mask != NULL) {
		uint8_t* p = (uint8_t*)p_cond + sizeof(tBTM_BLE_PF_UUID_COND);
		p_cond->srvc_uuid.p_uuid_mask = (tBTM_BLE_PF_COND_MASK*)p;
		btif_to_bta_uuid_mask(p_cond->srvc_uuid.p_uuid_mask, p_uuid_mask,
		p_uuid);
		}

		break;
		if (p_uuid_mask == NULL) {
		do_in_bta_thread(
		FROM_HERE,
		base::Bind(&BTM_LE_PF_uuid_filter, action, filt_index, filt_type,
		bt_uuid, BTM_BLE_PF_LOGIC_AND, nullptr,
		Bind(&bta_scan_filt_cfg_cb, filt_type, client_if)));
		return;
		}

		case BTM_BLE_PF_SRVC_SOL_UUID: {
		p_cond = new tBTM_BLE_PF_COND_PARAM;
		memset(p_cond, 0, sizeof(tBTM_BLE_PF_COND_PARAM));

		p_cond->solicitate_uuid.cond_logic = BTM_BLE_PF_LOGIC_AND;
		btif_to_bta_uuid(&p_cond->solicitate_uuid.uuid, p_uuid);
		break;
		tBTM_BLE_PF_COND_MASK* mask = new tBTM_BLE_PF_COND_MASK;
		btif_to_bta_uuid_mask(mask, p_uuid_mask, p_uuid);
		do_in_bta_thread(
		FROM_HERE,
		base::Bind(&BTM_LE_PF_uuid_filter, action, filt_index, filt_type,
		bt_uuid, BTM_BLE_PF_LOGIC_AND, base::Owned(mask),
		Bind(&bta_scan_filt_cfg_cb, filt_type, client_if)));
		return;
		}

		case BTM_BLE_PF_LOCAL_NAME: {
		p_cond = new tBTM_BLE_PF_COND_PARAM;
		memset(p_cond, 0, sizeof(tBTM_BLE_PF_COND_PARAM));

		uint8_t* p = (uint8_t*)p_cond + sizeof(tBTM_BLE_PF_LOCAL_NAME_COND);
		p_cond->local_name.data_len = data.size();
		p_cond->local_name.p_data = p;
		memcpy(p_cond->local_name.p_data, data.data(), data.size());
		break;
		do_in_bta_thread(
		FROM_HERE, base::Bind(&BTM_LE_PF_local_name, action, filt_index,
		std::move(data), Bind(&bta_scan_filt_cfg_cb,
		filt_type, client_if)));
		return;
		}

		case BTM_BLE_PF_MANU_DATA: {
		p_cond = new tBTM_BLE_PF_COND_PARAM;
		memset(p_cond, 0, sizeof(tBTM_BLE_PF_COND_PARAM));

		uint8_t data_len = data.size();

		p_cond->manu_data.company_id = company_id;
		p_cond->manu_data.company_id_mask =
		company_id_mask ? company_id_mask : 0xFFFF;
		p_cond->manu_data.data_len = data_len;

		uint8_t* p = (uint8_t*)p_cond + sizeof(tBTM_BLE_PF_MANU_COND);
		p_cond->manu_data.p_pattern = p;
		memcpy(p_cond->manu_data.p_pattern, data.data(), data_len);
		p += data_len;

		if (mask.size()) {
		p_cond->manu_data.p_pattern_mask = p;
		memcpy(p_cond->manu_data.p_pattern_mask, mask.data(), mask.size());
		}
		break;
		do_in_bta_thread(
		FROM_HERE,
		base::Bind(&BTM_LE_PF_manu_data, action, filt_index, company_id,
		company_id_mask, std::move(data), std::move(mask),
		Bind(&bta_scan_filt_cfg_cb, filt_type, client_if)));
		return;
		}

		case BTM_BLE_PF_SRVC_DATA_PATTERN: {
		p_cond = new tBTM_BLE_PF_COND_PARAM;
		memset(p_cond, 0, sizeof(tBTM_BLE_PF_COND_PARAM));

		p_cond->srvc_data.data_len = data.size();

		uint8_t* p = (uint8_t*)p_cond + sizeof(tBTM_BLE_PF_UUID_COND);
		p_cond->srvc_data.p_pattern = p;
		memcpy(p_cond->srvc_data.p_pattern, data.data(), data.size());
		p += data.size();
		if (mask.size()) {
		p_cond->srvc_data.p_pattern_mask = p;
		memcpy(p_cond->srvc_data.p_pattern_mask, mask.data(), mask.size());
		}
		break;
		do_in_bta_thread(
		FROM_HERE,
		base::Bind(&BTM_LE_PF_srvc_data_pattern, action, filt_index,
		std::move(data), std::move(mask),
		Bind(&bta_scan_filt_cfg_cb, filt_type, client_if)));
		return;
		}

		default:
		LOG_ERROR(LOG_TAG, "%s: Unknown filter type (%d)!", __func__, action);
		return;
		}

		if (p_cond != nullptr) {
		do_in_bta_thread(
		FROM_HERE,
		base::Bind(&BTM_BleCfgFilterCondition, action, filt_type, filt_index,
		base::Owned(p_cond),
		Bind(&bta_scan_filt_cfg_cb, filt_type, client_if)));
		} else {
		do_in_bta_thread(FROM_HERE, base::Bind(&BTM_BleCfgFilterCondition, action,
		filt_type, filt_index, nullptr,
		Bind(&bta_scan_filt_cfg_cb,
		filt_type, client_if)));
		}
		}

		void ScanFilterClear(int client_if, int filter_index) override {
		BTIF_TRACE_DEBUG("%s: filter_index: %d", __func__, filter_index);

		do_in_bta_thread(
		FROM_HERE,
		base::Bind(
		&BTM_BleCfgFilterCondition, BTM_BLE_SCAN_COND_CLEAR,
		BTM_BLE_PF_TYPE_ALL, filter_index, nullptr,
		Bind(&bta_scan_filt_cfg_cb, BTM_BLE_PF_TYPE_ALL, client_if)));
		do_in_bta_thread(FROM_HERE,
		base::Bind(&BTM_LE_PF_clear, filter_index,
		Bind(&bta_scan_filt_cfg_cb, BTM_BLE_PF_TYPE_ALL,
		client_if)));
		}

		void ScanFilterEnable(int client_if, bool enable) override {

system/stack/btm/btm_ble_adv_filter.cc

+168 −391

File changed.

Preview size limit exceeded, changes collapsed.

system/stack/include/btm_ble_api.h

+32 −17

Original line number	Diff line number	Diff line
		@@ -828,22 +828,37 @@ extern void BTM_BleAdvFilterParamSetup(
		std::unique_ptr<btgatt_filt_param_setup_t> p_filt_params,
		tBTM_BLE_PF_PARAM_CB cb);

		/*******************************************************************************
		*
		* Function BTM_BleCfgFilterCondition
		*
		* Description This function is called to configure the adv data payload
		* filter condition.
		*
		* Parameters action: to read/write/clear
		* cond_type: filter condition type.
		* p_cond: filter condition paramter
		*
		******************************************************************************/
		extern void BTM_BleCfgFilterCondition(tBTM_BLE_SCAN_COND_OP action,
		tBTM_BLE_PF_COND_TYPE cond_type,
		/**
		* This functions are called to configure the adv data payload filter condition
		*/
		extern void BTM_LE_PF_srvc_data(tBTM_BLE_SCAN_COND_OP action,
		tBTM_BLE_PF_FILT_INDEX filt_index);
		extern void BTM_LE_PF_addr_filter(tBTM_BLE_SCAN_COND_OP action,
		tBTM_BLE_PF_FILT_INDEX filt_index,
		tBTM_BLE_PF_COND_PARAM* p_cond,
		tBLE_BD_ADDR addr, tBTM_BLE_PF_CFG_CBACK cb);
		extern void BTM_LE_PF_local_name(tBTM_BLE_SCAN_COND_OP action,
		tBTM_BLE_PF_FILT_INDEX filt_index,
		std::vector<uint8_t> name,
		tBTM_BLE_PF_CFG_CBACK cb);
		extern void BTM_LE_PF_uuid_filter(tBTM_BLE_SCAN_COND_OP action,
		tBTM_BLE_PF_FILT_INDEX filt_index,
		tBTM_BLE_PF_COND_TYPE filter_type,
		tBT_UUID uuid,
		tBTM_BLE_PF_LOGIC_TYPE cond_logic,
		tBTM_BLE_PF_COND_MASK* p_uuid_mask,
		tBTM_BLE_PF_CFG_CBACK cb);
		extern void BTM_LE_PF_manu_data(tBTM_BLE_SCAN_COND_OP action,
		tBTM_BLE_PF_FILT_INDEX filt_index,
		uint16_t company_id, uint16_t company_id_mask,
		std::vector<uint8_t> data,
		std::vector<uint8_t> data_mask,
		tBTM_BLE_PF_CFG_CBACK cb);
		extern void BTM_LE_PF_srvc_data_pattern(tBTM_BLE_SCAN_COND_OP action,
		tBTM_BLE_PF_FILT_INDEX filt_index,
		std::vector<uint8_t> data,
		std::vector<uint8_t> data_mask,
		tBTM_BLE_PF_CFG_CBACK cb);
		extern void BTM_LE_PF_clear(tBTM_BLE_PF_FILT_INDEX filt_index,
		tBTM_BLE_PF_CFG_CBACK cb);

		/*******************************************************************************

system/stack/include/btm_ble_api_types.h

+0 −43

Original line number	Diff line number	Diff line
		@@ -490,49 +490,6 @@ typedef union {
		uint8_t uuid128_mask[LEN_UUID_128];
		} tBTM_BLE_PF_COND_MASK;

		typedef struct {
		tBLE_BD_ADDR*
		p_target_addr; /* target address, if NULL, generic UUID filter */
		tBT_UUID uuid; /* UUID condition */
		tBTM_BLE_PF_LOGIC_TYPE cond_logic; /* AND/OR */
		tBTM_BLE_PF_COND_MASK* p_uuid_mask; /* UUID mask */
		} tBTM_BLE_PF_UUID_COND;

		typedef struct {
		uint8_t data_len; /* <= 20 bytes */
		uint8_t* p_data;
		} tBTM_BLE_PF_LOCAL_NAME_COND;

		typedef struct {
		uint16_t company_id; /* company ID */
		uint8_t data_len; /* <= 20 bytes */
		uint8_t* p_pattern;
		uint16_t company_id_mask; /* UUID value mask */
		uint8_t* p_pattern_mask; /* Manufacturer data matching mask,
		same length as data pattern,
		set to all 0xff, match exact data */
		} tBTM_BLE_PF_MANU_COND;

		typedef struct {
		uint16_t uuid; /* service ID */
		uint8_t data_len; /* <= 20 bytes */
		uint8_t* p_pattern;
		uint8_t* p_pattern_mask; /* Service data matching mask, same length as data
		pattern,
		set to all 0xff, match exact data */
		} tBTM_BLE_PF_SRVC_PATTERN_COND;

		typedef union {
		tBLE_BD_ADDR target_addr;
		tBTM_BLE_PF_LOCAL_NAME_COND local_name; /* lcoal name filtering */
		tBTM_BLE_PF_MANU_COND manu_data; /* manufactuer data filtering */
		tBTM_BLE_PF_UUID_COND srvc_uuid; /* service UUID filtering */
		tBTM_BLE_PF_UUID_COND
		solicitate_uuid; /* solicitated service UUID filtering */
		tBTM_BLE_PF_SRVC_PATTERN_COND srvc_data; /* service data pattern */
		uint8_t additional_data[2000];
		} tBTM_BLE_PF_COND_PARAM;

		/* per device filter + one generic filter indexed by 0 */
		#define BTM_BLE_MAX_FILTER_COUNTER (BTM_BLE_MAX_ADDR_FILTER + 1)