Refactor advertising data types (d16ba10f) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/include/bta_api.h

+0 −70

Original line number	Original line	Diff line number	Diff line
	@@ -184,7 +184,6 @@ typedef uint16_t tBTA_SEC;
	/* Discoverable Modes */		/* Discoverable Modes */
	#define BTA_DM_NON_DISC BTM_NON_DISCOVERABLE /* Device is not discoverable. */		#define BTA_DM_NON_DISC BTM_NON_DISCOVERABLE /* Device is not discoverable. */
	#define BTA_DM_GENERAL_DISC BTM_GENERAL_DISCOVERABLE /* General discoverable. */		#define BTA_DM_GENERAL_DISC BTM_GENERAL_DISCOVERABLE /* General discoverable. */
	#define BTA_DM_LIMITED_DISC BTM_LIMITED_DISCOVERABLE /* Limited discoverable. */
	#if (BLE_INCLUDED == TRUE)		#if (BLE_INCLUDED == TRUE)
	#define BTA_DM_BLE_NON_DISCOVERABLE BTM_BLE_NON_DISCOVERABLE /* Device is not LE discoverable */		#define BTA_DM_BLE_NON_DISCOVERABLE BTM_BLE_NON_DISCOVERABLE /* Device is not LE discoverable */
	#define BTA_DM_BLE_GENERAL_DISCOVERABLE BTM_BLE_GENERAL_DISCOVERABLE /* Device is LE General discoverable */		#define BTA_DM_BLE_GENERAL_DISCOVERABLE BTM_BLE_GENERAL_DISCOVERABLE /* Device is LE General discoverable */
	@@ -313,79 +312,10 @@ typedef struct
	} tBTA_DM_EIR_CONF;		} tBTA_DM_EIR_CONF;

	#if (BLE_INCLUDED == TRUE)		#if (BLE_INCLUDED == TRUE)
	/* ADV data flag bit definition used for BTM_BLE_AD_TYPE_FLAG */
	#define BTA_BLE_LIMIT_DISC_FLAG BTM_BLE_LIMIT_DISC_FLAG
	#define BTA_BLE_GEN_DISC_FLAG BTM_BLE_GEN_DISC_FLAG
	#define BTA_BLE_BREDR_NOT_SPT BTM_BLE_BREDR_NOT_SPT
	#define BTA_BLE_DMT_CONTROLLER_SPT BTM_BLE_DMT_CONTROLLER_SPT
	#define BTA_BLE_DMT_HOST_SPT BTM_BLE_DMT_HOST_SPT
	#define BTA_BLE_NON_LIMIT_DISC_FLAG BTM_BLE_NON_LIMIT_DISC_FLAG
	#define BTA_BLE_ADV_FLAG_MASK BTM_BLE_ADV_FLAG_MASK
	#define BTA_BLE_LIMIT_DISC_MASK BTM_BLE_LIMIT_DISC_MASK

	/* ADV data bit mask */
	#define BTA_BLE_AD_BIT_DEV_NAME BTM_BLE_AD_BIT_DEV_NAME
	#define BTA_BLE_AD_BIT_FLAGS BTM_BLE_AD_BIT_FLAGS
	#define BTA_BLE_AD_BIT_MANU BTM_BLE_AD_BIT_MANU
	#define BTA_BLE_AD_BIT_TX_PWR BTM_BLE_AD_BIT_TX_PWR
	#define BTA_BLE_AD_BIT_INT_RANGE BTM_BLE_AD_BIT_INT_RANGE
	#define BTA_BLE_AD_BIT_SERVICE BTM_BLE_AD_BIT_SERVICE
	#define BTA_BLE_AD_BIT_APPEARANCE BTM_BLE_AD_BIT_APPEARANCE
	#define BTA_BLE_AD_BIT_PROPRIETARY BTM_BLE_AD_BIT_PROPRIETARY
	#define BTA_DM_BLE_AD_BIT_SERVICE_SOL BTM_BLE_AD_BIT_SERVICE_SOL
	#define BTA_DM_BLE_AD_BIT_SERVICE_DATA BTM_BLE_AD_BIT_SERVICE_DATA
	#define BTA_DM_BLE_AD_BIT_SIGN_DATA BTM_BLE_AD_BIT_SIGN_DATA
	#define BTA_DM_BLE_AD_BIT_SERVICE_128SOL BTM_BLE_AD_BIT_SERVICE_128SOL
	#define BTA_DM_BLE_AD_BIT_PUBLIC_ADDR BTM_BLE_AD_BIT_PUBLIC_ADDR
	#define BTA_DM_BLE_AD_BIT_RANDOM_ADDR BTM_BLE_AD_BIT_RANDOM_ADDR
	#define BTA_DM_BLE_AD_BIT_SERVICE_128 BTM_BLE_AD_BIT_SERVICE_128 /128-bit Service UUIDs/

	typedef tBTM_BLE_AD_MASK tBTA_BLE_AD_MASK;
	typedef tBTM_BLE_INT_RANGE tBTA_BLE_INT_RANGE;
	typedef tBTM_BLE_SERVICE tBTA_BLE_SERVICE;
	typedef tBTM_BLE_PROP_ELEM tBTA_BLE_PROP_ELEM;
	typedef tBTM_BLE_PROPRIETARY tBTA_BLE_PROPRIETARY;
	typedef tBTM_BLE_MANU tBTA_BLE_MANU;
	typedef tBTM_BLE_SERVICE_DATA tBTA_BLE_SERVICE_DATA;
	typedef tBTM_BLE_128SERVICE tBTA_BLE_128SERVICE;
	typedef tBTM_BLE_32SERVICE tBTA_BLE_32SERVICE;

	typedef struct
	{
	tBTA_BLE_INT_RANGE int_range; /* slave prefered conn interval range */
	tBTA_BLE_MANU manu; /* manufacturer data */
	tBTA_BLE_SERVICE services; /* 16 bits services */
	tBTA_BLE_128SERVICE services_128b; /* 128 bits service */
	tBTA_BLE_32SERVICE service_32b; /* 32 bits Service UUID */
	tBTA_BLE_SERVICE sol_services; /* 16 bits services Solicitation UUIDs */
	tBTA_BLE_32SERVICE sol_service_32b; /* List of 32 bit Service Solicitation UUIDs */
	tBTA_BLE_128SERVICE sol_service_128b;/* List of 128 bit Service Solicitation UUIDs */
	tBTA_BLE_PROPRIETARY proprietary; /* proprietary data */
	tBTA_BLE_SERVICE_DATA service_data; /* service data */
	uint16_t appearance; /* appearance data */
	uint8_t flag;
	uint8_t tx_power;
	}tBTA_BLE_ADV_DATA;

	typedef void (tBTA_SET_ADV_DATA_CMPL_CBACK) (tBTA_STATUS status);

	/* advertising filter policy */		/* advertising filter policy */
	typedef tBTM_BLE_AFP tBTA_BLE_AFP;		typedef tBTM_BLE_AFP tBTA_BLE_AFP;

	/* These are the fields returned in each device adv packet. It
	** is returned in the results callback if registered.
	*/
	typedef struct
	{
	uint8_t conn_mode;
	tBTA_BLE_AD_MASK ad_mask; /* mask of the valid adv data field */
	uint8_t flag;
	uint8_t tx_power_level;
	uint8_t remote_name_len;
	uint8_t *p_remote_name;
	tBTA_BLE_SERVICE service;
	} tBTA_BLE_INQ_DATA;

	enum		enum
	{		{
	BTA_BLE_BATCH_SCAN_MODE_PASS = 1,		BTA_BLE_BATCH_SCAN_MODE_PASS = 1,

system/btif/Android.mk

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -41,7 +41,6 @@ btifCommonSrc += \
	src/btif_dm.cc \		src/btif_dm.cc \
	src/btif_gatt.cc \		src/btif_gatt.cc \
	src/btif_gatt_client.cc \		src/btif_gatt_client.cc \
	src/btif_gatt_multi_adv_util.cc \
	src/btif_gatt_server.cc \		src/btif_gatt_server.cc \
	src/btif_gatt_test.cc \		src/btif_gatt_test.cc \
	src/btif_gatt_util.cc \		src/btif_gatt_util.cc \

system/btif/BUILD.gn

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -32,7 +32,6 @@ static_library("btif") {
	"src/btif_ble_advertiser.cc",		"src/btif_ble_advertiser.cc",
	"src/btif_gatt.cc",		"src/btif_gatt.cc",
	"src/btif_gatt_client.cc",		"src/btif_gatt_client.cc",
	"src/btif_gatt_multi_adv_util.cc",
	"src/btif_gatt_server.cc",		"src/btif_gatt_server.cc",
	"src/btif_gatt_test.cc",		"src/btif_gatt_test.cc",
	"src/btif_gatt_util.cc",		"src/btif_gatt_util.cc",

system/btif/include/btif_gatt_multi_adv_util.h

deleted100644 → 0

+0 −87

Original line number	Original line	Diff line number	Diff line
	/******************************************************************************
	*
	* Copyright (C) 2014 Broadcom Corporation
	*
	* 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.
	*
	******************************************************************************/

	#pragma once

	#include <hardware/bluetooth.h>
	#include <vector>

	#include "ble_advertiser.h"

	#define CLNT_IF_IDX 0
	#define INST_ID_IDX 1
	#define INST_ID_IDX_MAX (INST_ID_IDX + 1)
	#define INVALID_ADV_INST (-1)
	#define STD_ADV_INSTID 0

	/* Default ADV flags for general and limited discoverability */
	#define ADV_FLAGS_LIMITED BTA_DM_LIMITED_DISC
	#define ADV_FLAGS_GENERAL BTA_DM_GENERAL_DISC

	typedef struct
	{
	int advertiser_id;
	bool set_scan_rsp;
	bool include_name;
	bool include_txpower;
	int min_interval;
	int max_interval;
	int appearance;
	uint16_t manufacturer_len;
	uint8_t p_manufacturer_data[MAX_SIZE_MANUFACTURER_DATA];
	uint16_t service_data_len;
	uint8_t p_service_data[MAX_SIZE_SERVICE_DATA];
	uint16_t service_uuid_len;
	uint8_t p_service_uuid[MAX_SIZE_SERVICE_DATA];
	} btif_adv_data_t;


	typedef struct
	{
	uint8_t advertiser_id;
	tBTA_BLE_AD_MASK mask;
	tBTA_BLE_ADV_DATA data;
	tBTM_BLE_ADV_PARAMS param;
	alarm_t *multi_adv_timer;
	int timeout_s;
	} btgatt_multi_adv_inst_cb;

	typedef struct
	{
	// Includes the stored data for standard LE instance
	btgatt_multi_adv_inst_cb *inst_cb;

	} btgatt_multi_adv_common_data;

	extern btgatt_multi_adv_common_data *btif_obtain_multi_adv_data_cb();

	extern void btif_gattc_incr_app_count(void);
	extern void btif_gattc_decr_app_count(void);
	extern void btif_gattc_clear_clientif(int advertiser_id, bool stop_timer);
	extern void btif_gattc_cleanup_inst_cb(int inst_id, bool stop_timer);
	extern void btif_gattc_cleanup_multi_inst_cb(btgatt_multi_adv_inst_cb *p_inst_cb,
	bool stop_timer);
	extern bool btif_gattc_copy_datacb(int arrindex, const btif_adv_data_t *p_adv_data,
	bool bInstData);
	extern void btif_gattc_adv_data_packager(int advertiser_id, bool set_scan_rsp,
	bool include_name, bool include_txpower, int min_interval, int max_interval,
	int appearance, const std::vector<uint8_t> &manufacturer_data,
	const std::vector<uint8_t> &service_data, const std::vector<uint8_t> &service_uuid,
	btif_adv_data_t *p_multi_adv_inst);
	extern void btif_gattc_adv_data_cleanup(btif_adv_data_t* adv);
	void btif_multi_adv_timer_ctrl(int advertiser_id, alarm_callback_t cb);

system/btif/src/btif_ble_advertiser.cc

+166 −104

Original line number	Original line	Diff line number	Diff line
	@@ -22,13 +22,13 @@
	#include <hardware/bt_gatt.h>		#include <hardware/bt_gatt.h>

	#include <base/bind.h>		#include <base/bind.h>
			#include <vector>

	#include "ble_advertiser.h"		#include "ble_advertiser.h"
	#include "bta_closure_api.h"		#include "bta_closure_api.h"
	#include "bta_gatt_api.h"		#include "bta_gatt_api.h"
	#include "btif_common.h"		#include "btif_common.h"
	#include "btif_gatt.h"		#include "btif_gatt.h"
	#include "btif_gatt_multi_adv_util.h"

	using base::Bind;		using base::Bind;
	using base::Owned;		using base::Owned;
	@@ -49,40 +49,144 @@ extern const btgatt_callbacks_t *bt_gatt_callbacks;

	namespace {		namespace {

	bt_status_t btif_multiadv_enable(int advertiser_id, bool enable, int timeout_s);		template <typename T>
	void btif_multi_adv_stop_cb(void *data) {		class OwnedArrayWrapper {
	int advertiser_id = PTR_TO_INT(data);		public:
	btif_multiadv_enable(advertiser_id, false, 0); // Does context switch		explicit OwnedArrayWrapper(T* o) : ptr_(o) {}
			~OwnedArrayWrapper() { delete[] ptr_; }
			T* get() const { return ptr_; }
			OwnedArrayWrapper(OwnedArrayWrapper&& other) {
			ptr_ = other.ptr_;
			other.ptr_ = NULL;
	}		}

	void bta_adv_set_data_cback(tBTA_STATUS call_status) {		private:
	do_in_jni_thread(Bind(&btif_gattc_cleanup_inst_cb, STD_ADV_INSTID, false));		mutable T* ptr_;
			};

			template <typename T>
			T* Unwrap(const OwnedArrayWrapper<T>& o) {
			return o.get();
	}		}

	void btif_adv_set_data_impl(btif_adv_data_t *p_adv_data) {		template <typename T>
	const int cbindex = CLNT_IF_IDX;		static inline OwnedArrayWrapper<T> OwnedArray(T* o) {
	if (cbindex >= 0 && btif_gattc_copy_datacb(cbindex, p_adv_data, false)) {		return OwnedArrayWrapper<T>(o);
	btgatt_multi_adv_common_data *p_multi_adv_data_cb =		}
	btif_obtain_multi_adv_data_cb();

	tBTM_BLE_ADV_DATA *adv_cfg = new tBTM_BLE_ADV_DATA;		/* return the actual power in dBm based on the mapping in config file */
	memcpy(adv_cfg, &p_multi_adv_data_cb->inst_cb[cbindex].data,		int ble_tx_power[BTM_BLE_ADV_TX_POWER_MAX + 1] = BTM_BLE_ADV_TX_POWER;
	sizeof(tBTM_BLE_ADV_DATA));		char ble_map_adv_tx_power(int tx_power_index) {
			if (0 <= tx_power_index && tx_power_index < BTM_BLE_ADV_TX_POWER_MAX)
			return (char)ble_tx_power[tx_power_index];
			return 0;
			}

	if (!p_adv_data->set_scan_rsp) {		#define MIN_ADV_LENGTH 2
	do_in_bta_thread(		#define BLE_AD_DATA_LEN 31
	FROM_HERE, base::Bind(&BTM_BleWriteAdvData,		vector<uint8_t> build_adv_data(bool set_scan_rsp, bool include_name,
	p_multi_adv_data_cb->inst_cb[cbindex].mask,		bool incl_txpower, uint16_t appearance,
	base::Owned(adv_cfg), bta_adv_set_data_cback));		vector<uint8_t> manufacturer_data,
			vector<uint8_t> service_data,
			vector<uint8_t> service_uuid) {
			vector<uint8_t> data;

			// Flags are added by lower layers of the stack, only if needed; no need to
			// add them here.

			// TODO(jpawlowski): appearance is a dead argument, never set by upper layers.
			// Remove.

			if (include_name) {
			char* bd_name;
			BTM_ReadLocalDeviceName(&bd_name);
			size_t bd_name_len = strlen(bd_name);
			uint8_t type;

			// TODO(jpawlowski) put a better limit on device name!
			if (data.size() + MIN_ADV_LENGTH + bd_name_len > BLE_AD_DATA_LEN) {
			bd_name_len = BLE_AD_DATA_LEN - data.size() - 1;
			type = BTM_BLE_AD_TYPE_NAME_SHORT;
	} else {		} else {
	do_in_bta_thread(		type = BTM_BLE_AD_TYPE_NAME_CMPL;
	FROM_HERE, base::Bind(&BTM_BleWriteScanRsp,		}
	p_multi_adv_data_cb->inst_cb[cbindex].mask,
	base::Owned(adv_cfg), bta_adv_set_data_cback));		data.push_back(bd_name_len + 1);
			data.push_back(type);
			data.insert(data.end(), bd_name, bd_name + bd_name_len);
			}

			if (manufacturer_data.size()) {
			data.push_back(manufacturer_data.size() + 1);
			data.push_back(HCI_EIR_MANUFACTURER_SPECIFIC_TYPE);
			data.insert(data.end(), manufacturer_data.begin(), manufacturer_data.end());
			}

			/* TX power */
			if (incl_txpower) {
			data.push_back(MIN_ADV_LENGTH);
			data.push_back(HCI_EIR_TX_POWER_LEVEL_TYPE);
			data.push_back(0); // lower layers will fill this value.
			}

			// TODO(jpawlowski): right now we can pass only one service, and it's size
			// determine type (16/32/128bit), this must be fixed in future!
			if (service_uuid.size()) {
			data.push_back(service_uuid.size() + 1);
			if (service_uuid.size() == LEN_UUID_16)
			data.push_back(BT_EIR_COMPLETE_16BITS_UUID_TYPE);
			else if (service_uuid.size() == LEN_UUID_32)
			data.push_back(BT_EIR_COMPLETE_32BITS_UUID_TYPE);
			else if (service_uuid.size() == LEN_UUID_128)
			data.push_back(BT_EIR_COMPLETE_128BITS_UUID_TYPE);

			data.insert(data.end(), service_uuid.begin(), service_uuid.end());
			}

			if (service_data.size()) {
			data.push_back(service_data.size() + 1);
			// TODO(jpawlowski): we can accept only 16bit uuid. Remove this restriction
			// as we move this code up the stack
			data.push_back(BT_EIR_SERVICE_DATA_16BITS_UUID_TYPE);

			data.insert(data.end(), service_data.begin(), service_data.end());
			}

			return data;
			}

			void bta_adv_set_data_cback(tBTA_STATUS call_status) {}

			void btif_adv_set_data_impl(int advertiser_id, bool set_scan_rsp,
			vector<uint8_t> data) {
			uint8_t* data_ptr = nullptr;

			if (data.size()) {
			// base::Owned will free this ptr
			data_ptr = new uint8_t[data.size()];
			memcpy(data_ptr, data.data(), data.size());
			}

			if (!set_scan_rsp) {
			if (data_ptr) {
			do_in_bta_thread(FROM_HERE,
			base::Bind(&BTM_BleWriteAdvData, OwnedArray(data_ptr),
			data.size(), bta_adv_set_data_cback));
			} else {
			do_in_bta_thread(FROM_HERE,
			base::Bind(&BTM_BleWriteAdvData, nullptr, data.size(),
			bta_adv_set_data_cback));
	}		}
	} else {		} else {
	BTIF_TRACE_ERROR("%s: failed to get instance data cbindex: %d", __func__,		if (data_ptr) {
	cbindex);		do_in_bta_thread(FROM_HERE,
			base::Bind(&BTM_BleWriteScanRsp, OwnedArray(data_ptr),
			data.size(), bta_adv_set_data_cback));
			} else {
			do_in_bta_thread(FROM_HERE,
			base::Bind(&BTM_BleWriteScanRsp, nullptr, data.size(),
			bta_adv_set_data_cback));
			}
	}		}
	}		}

	@@ -94,21 +198,17 @@ bt_status_t btif_adv_set_data(int advertiser_id, bool set_scan_rsp,
	vector<uint8_t> service_uuid) {		vector<uint8_t> service_uuid) {
	CHECK_BTGATT_INIT();		CHECK_BTGATT_INIT();

	btif_adv_data_t *adv_data = new btif_adv_data_t;		vector<uint8_t> data =
			build_adv_data(set_scan_rsp, include_name, include_txpower, appearance,
			manufacturer_data, service_data, service_uuid);

	btif_gattc_adv_data_packager(		return do_in_jni_thread(Bind(&btif_adv_set_data_impl, advertiser_id,
	advertiser_id, set_scan_rsp, include_name, include_txpower, min_interval,		set_scan_rsp, std::move(data)));
	max_interval, appearance, std::move(manufacturer_data),
	std::move(service_data), std::move(service_uuid), adv_data);

	return do_in_jni_thread(Bind(&btif_adv_set_data_impl, base::Owned(adv_data)));
	}		}

	void multi_adv_set_params_cb_impl(int advertiser_id, int status) {		void multi_adv_set_params_cb_impl(int advertiser_id, int status) {
	HAL_CBACK(bt_gatt_callbacks, advertiser->multi_adv_set_params_cb,		HAL_CBACK(bt_gatt_callbacks, advertiser->multi_adv_set_params_cb,
	advertiser_id, status);		advertiser_id, status);
	btif_multi_adv_timer_ctrl(
	advertiser_id, (status == BTA_GATT_OK) ? btif_multi_adv_stop_cb : NULL);
	}		}

	void multi_adv_set_params_cb(uint8_t advertiser_id, uint8_t status) {		void multi_adv_set_params_cb(uint8_t advertiser_id, uint8_t status) {
	@@ -118,22 +218,14 @@ void multi_adv_set_params_cb(uint8_t advertiser_id, uint8_t status) {
	void btif_multiadv_set_params_impl(int advertiser_id, int min_interval,		void btif_multiadv_set_params_impl(int advertiser_id, int min_interval,
	int max_interval, int adv_type, int chnl_map,		int max_interval, int adv_type, int chnl_map,
	int tx_power) {		int tx_power) {
	tBTM_BLE_ADV_PARAMS param;
	param.adv_int_min = min_interval;
	param.adv_int_max = max_interval;
	param.adv_type = adv_type;
	param.channel_map = chnl_map;
	param.adv_filter_policy = 0;
	param.tx_power = tx_power;

	btgatt_multi_adv_common_data *p_multi_adv_data_cb =
	btif_obtain_multi_adv_data_cb();
	memcpy(&p_multi_adv_data_cb->inst_cb[advertiser_id].param, &param,
	sizeof(tBTM_BLE_ADV_PARAMS));

	tBTM_BLE_ADV_PARAMS* params = new tBTM_BLE_ADV_PARAMS;		tBTM_BLE_ADV_PARAMS* params = new tBTM_BLE_ADV_PARAMS;
	memcpy(params, &(p_multi_adv_data_cb->inst_cb[advertiser_id].param),		params->adv_int_min = min_interval;
	sizeof(tBTM_BLE_ADV_PARAMS));		params->adv_int_max = max_interval;
			params->adv_type = adv_type;
			params->channel_map = chnl_map;
			params->adv_filter_policy = 0;
			params->tx_power = ble_map_adv_tx_power(tx_power);

	do_in_bta_thread(		do_in_bta_thread(
	FROM_HERE,		FROM_HERE,
	base::Bind(&BleAdvertisingManager::SetParameters,		base::Bind(&BleAdvertisingManager::SetParameters,
	@@ -152,7 +244,6 @@ bt_status_t btif_multiadv_set_params(int advertiser_id, int min_interval,
	}		}

	void multi_adv_data_cb_impl(int advertiser_id, int status) {		void multi_adv_data_cb_impl(int advertiser_id, int status) {
	btif_gattc_clear_clientif(advertiser_id, false);
	HAL_CBACK(bt_gatt_callbacks, advertiser->multi_adv_data_cb, advertiser_id,		HAL_CBACK(bt_gatt_callbacks, advertiser->multi_adv_data_cb, advertiser_id,
	status);		status);
	}		}
	@@ -161,25 +252,12 @@ void multi_adv_data_cb(uint8_t advertiser_id, uint8_t status) {
	do_in_jni_thread(Bind(multi_adv_data_cb_impl, advertiser_id, status));		do_in_jni_thread(Bind(multi_adv_data_cb_impl, advertiser_id, status));
	}		}

	void btif_multiadv_set_data_impl(btif_adv_data_t *p_adv_data) {		void btif_multiadv_set_data_impl(int advertiser_id, bool set_scan_rsp,
	uint8_t advertiser_id = p_adv_data->advertiser_id;		vector<uint8_t> data) {
	if (!btif_gattc_copy_datacb(advertiser_id, p_adv_data, true)) {
	BTIF_TRACE_ERROR("%s: failed to copy instance data: advertiser_id:%d",
	__func__, advertiser_id);
	return;
	}

	btgatt_multi_adv_common_data *p_multi_adv_data_cb =
	btif_obtain_multi_adv_data_cb();

	do_in_bta_thread(FROM_HERE,		do_in_bta_thread(FROM_HERE,
	base::Bind(&BleAdvertisingManager::SetData,		base::Bind(&BleAdvertisingManager::SetData,
	base::Unretained(BleAdvertisingManager::Get()),		base::Unretained(BleAdvertisingManager::Get()),
	advertiser_id, p_adv_data->set_scan_rsp,		advertiser_id, set_scan_rsp, std::move(data),
	p_multi_adv_data_cb->inst_cb[advertiser_id].mask,
	(tBTM_BLE_ADV_DATA *)&p_multi_adv_data_cb
	->inst_cb[advertiser_id]
	.data,
	base::Bind(multi_adv_data_cb, advertiser_id)));		base::Bind(multi_adv_data_cb, advertiser_id)));
	}		}

	@@ -191,49 +269,38 @@ bt_status_t btif_multiadv_set_data(int advertiser_id, bool set_scan_rsp,
	vector<uint8_t> service_uuid) {		vector<uint8_t> service_uuid) {
	CHECK_BTGATT_INIT();		CHECK_BTGATT_INIT();

	btif_adv_data_t *multi_adv_data_inst = new btif_adv_data_t;		vector<uint8_t> data =
			build_adv_data(set_scan_rsp, include_name, incl_txpower, appearance,
	const int min_interval = 0;		manufacturer_data, service_data, service_uuid);
	const int max_interval = 0;

	btif_gattc_adv_data_packager(		return do_in_jni_thread(Bind(&btif_multiadv_set_data_impl, advertiser_id,
	advertiser_id, set_scan_rsp, include_name, incl_txpower, min_interval,		set_scan_rsp, std::move(data)));
	max_interval, appearance, std::move(manufacturer_data),
	std::move(service_data), std::move(service_uuid), multi_adv_data_inst);

	return do_in_jni_thread(
	Bind(&btif_multiadv_set_data_impl, base::Owned(multi_adv_data_inst)));
	}		}

	void multi_adv_enable_cb_impl(int advertiser_id, int status, bool enable) {		void multi_adv_enable_cb_impl(int advertiser_id, int status, bool enable) {
	HAL_CBACK(bt_gatt_callbacks, advertiser->multi_adv_enable_cb, advertiser_id,		HAL_CBACK(bt_gatt_callbacks, advertiser->multi_adv_enable_cb, advertiser_id,
	status, enable);		status, enable);
	if (!enable) {
	btif_multi_adv_timer_ctrl(
	advertiser_id, (status == BTA_GATT_OK) ? btif_multi_adv_stop_cb : NULL);
	}
	}		}

	void multi_adv_enable_cb(bool enable, uint8_t advertiser_id,		void multi_adv_enable_cb(bool enable, uint8_t advertiser_id, uint8_t status) {
	uint8_t status) {
	do_in_jni_thread(		do_in_jni_thread(
	Bind(multi_adv_enable_cb_impl, advertiser_id, status, enable));		Bind(multi_adv_enable_cb_impl, advertiser_id, status, enable));
	}		}

			void multi_adv_timeout_cb(uint8_t advertiser_id, uint8_t status) {
			do_in_jni_thread(
			Bind(multi_adv_enable_cb_impl, advertiser_id, status, false));
			}

	void btif_multiadv_enable_impl(int advertiser_id, bool enable, int timeout_s) {		void btif_multiadv_enable_impl(int advertiser_id, bool enable, int timeout_s) {
	BTIF_TRACE_DEBUG("%s: advertiser_id: %d, enable: %d", __func__, advertiser_id,		BTIF_TRACE_DEBUG("%s: advertiser_id: %d, enable: %d", __func__, advertiser_id,
	enable);		enable);

	btgatt_multi_adv_common_data *p_multi_adv_data_cb =
	btif_obtain_multi_adv_data_cb();
	if (enable) p_multi_adv_data_cb->inst_cb[advertiser_id].timeout_s = timeout_s;

	do_in_bta_thread(		do_in_bta_thread(
	FROM_HERE,		FROM_HERE,
	base::Bind(&BleAdvertisingManager::Enable,		base::Bind(&BleAdvertisingManager::Enable,
	base::Unretained(BleAdvertisingManager::Get()), advertiser_id,		base::Unretained(BleAdvertisingManager::Get()), advertiser_id,
	enable,		enable, base::Bind(multi_adv_enable_cb, enable, advertiser_id),
	base::Bind(multi_adv_enable_cb, enable, advertiser_id)));		timeout_s, base::Bind(multi_adv_timeout_cb, advertiser_id)));
	}		}

	bt_status_t btif_multiadv_enable(int advertiser_id, bool enable,		bt_status_t btif_multiadv_enable(int advertiser_id, bool enable,
	@@ -253,8 +320,6 @@ void multi_adv_reg_cb(bt_uuid_t uuid, uint8_t advertiser_id, uint8_t status) {
	}		}

	bt_status_t btif_multiadv_register(bt_uuid_t* uuid) {		bt_status_t btif_multiadv_register(bt_uuid_t* uuid) {
	btif_gattc_incr_app_count();

	do_in_bta_thread(FROM_HERE,		do_in_bta_thread(FROM_HERE,
	base::Bind(&BleAdvertisingManager::RegisterAdvertiser,		base::Bind(&BleAdvertisingManager::RegisterAdvertiser,
	base::Unretained(BleAdvertisingManager::Get()),		base::Unretained(BleAdvertisingManager::Get()),
	@@ -263,9 +328,6 @@ bt_status_t btif_multiadv_register(bt_uuid_t *uuid) {
	}		}

	bt_status_t btif_multiadv_unregister(int advertiser_id) {		bt_status_t btif_multiadv_unregister(int advertiser_id) {
	btif_gattc_clear_clientif(advertiser_id, true);
	btif_gattc_decr_app_count();

	do_in_bta_thread(FROM_HERE,		do_in_bta_thread(FROM_HERE,
	base::Bind(&BleAdvertisingManager::Unregister,		base::Bind(&BleAdvertisingManager::Unregister,
	base::Unretained(BleAdvertisingManager::Get()),		base::Unretained(BleAdvertisingManager::Get()),