Convert advertising HAL from struct into class (3/3) (6c0d440a) · Commits · e / os / android_packages_modules_Bluetooth

system/btcore/include/hal_util.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -16,9 +16,17 @@

		#pragma once

		#ifdef __cplusplus
		extern "C" {
		#endif

		struct hw_module_t;

		// Loads the Bluetooth library. If OS_GENERIC is defined, this function looks
		// explicitly for libbluetooth.default.so and loads it. On Android, this calls
		// the hw_get_module routine with the Bluetooth stack module id.
		int hal_util_load_bt_library(const struct hw_module_t **module);

		#ifdef __cplusplus
		}
		#endif

system/btif/include/btif_gatt.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@

		extern const btgatt_client_interface_t btgattClientInterface;
		extern const btgatt_server_interface_t btgattServerInterface;
		extern const ble_advertiser_interface_t btLeAdvertiserInstance;

		BleAdvertiserInterface* get_ble_advertiser_instance();
		#endif

system/btif/src/btif_ble_advertiser.cc

+126 −182

Original line number	Diff line number	Diff line
		@@ -26,26 +26,13 @@

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

		using base::Bind;
		using base::Owned;
		using std::vector;

		extern bt_status_t do_in_jni_thread(const base::Closure& task);
		extern const btgatt_callbacks_t* bt_gatt_callbacks;

		#define CHECK_BTGATT_INIT() \
		do { \
		if (bt_gatt_callbacks == NULL) { \
		LOG_WARN(LOG_TAG, "%s: BTGATT not initialized", __func__); \
		return BT_STATUS_NOT_READY; \
		} else { \
		LOG_VERBOSE(LOG_TAG, "%s", __func__); \
		} \
		} while (0)

		namespace {

		@@ -157,10 +144,42 @@ vector<uint8_t> build_adv_data(bool set_scan_rsp, bool include_name,

		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;
		class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface {
		~BleAdvertiserInterfaceImpl(){};

		void RegisterAdvertiserCb(
		base::Callback<void(uint8_t /* adv_id /, uint8_t / status */)> cb,
		uint8_t advertiser_id, uint8_t status) {
		do_in_jni_thread(Bind(cb, advertiser_id, status));
		}

		void RegisterAdvertiser(
		base::Callback<void(uint8_t /* advertiser_id /, uint8_t / status */)>
		cb) override {
		do_in_bta_thread(
		FROM_HERE, Bind(&BleAdvertisingManager::RegisterAdvertiser,
		base::Unretained(BleAdvertisingManager::Get()),
		Bind(&BleAdvertiserInterfaceImpl::RegisterAdvertiserCb,
		base::Unretained(this), cb)));
		}

		void Unregister(uint8_t advertiser_id) override {
		do_in_bta_thread(
		FROM_HERE,
		Bind(&BleAdvertisingManager::Unregister,
		base::Unretained(BleAdvertisingManager::Get()), advertiser_id));
		}

		void SetData(int advertiser_id, bool set_scan_rsp, bool include_name,
		bool include_txpower, int min_interval, int max_interval,
		int appearance, vector<uint8_t> manufacturer_data,
		vector<uint8_t> service_data,
		vector<uint8_t> service_uuid) override {
		vector<uint8_t> data =
		build_adv_data(set_scan_rsp, include_name, include_txpower, appearance,
		manufacturer_data, service_data, service_uuid);

		uint8_t* data_ptr = nullptr;
		if (data.size()) {
		// base::Owned will free this ptr
		data_ptr = new uint8_t[data.size()];
		@@ -170,54 +189,32 @@ void btif_adv_set_data_impl(int advertiser_id, bool set_scan_rsp,
		if (!set_scan_rsp) {
		if (data_ptr) {
		do_in_bta_thread(FROM_HERE,
		base::Bind(&BTM_BleWriteAdvData, OwnedArray(data_ptr),
		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));
		do_in_bta_thread(FROM_HERE, Bind(&BTM_BleWriteAdvData, nullptr,
		data.size(), bta_adv_set_data_cback));
		}
		} else {
		if (data_ptr) {
		do_in_bta_thread(FROM_HERE,
		base::Bind(&BTM_BleWriteScanRsp, OwnedArray(data_ptr),
		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));
		}
		do_in_bta_thread(FROM_HERE, Bind(&BTM_BleWriteScanRsp, nullptr,
		data.size(), bta_adv_set_data_cback));
		}
		}

		bt_status_t btif_adv_set_data(int advertiser_id, bool set_scan_rsp,
		bool include_name, bool include_txpower,
		int min_interval, int max_interval,
		int appearance, vector<uint8_t> manufacturer_data,
		vector<uint8_t> service_data,
		vector<uint8_t> service_uuid) {
		CHECK_BTGATT_INIT();

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

		return do_in_jni_thread(Bind(&btif_adv_set_data_impl, advertiser_id,
		set_scan_rsp, std::move(data)));
		}

		void multi_adv_set_params_cb_impl(int advertiser_id, int status) {
		HAL_CBACK(bt_gatt_callbacks, advertiser->multi_adv_set_params_cb,
		advertiser_id, status);
		}

		void multi_adv_set_params_cb(uint8_t advertiser_id, uint8_t status) {
		do_in_jni_thread(Bind(multi_adv_set_params_cb_impl, advertiser_id, status));
		void MultiAdvSetParametersCb(BleAdvertiserCb cb, uint8_t status) {
		do_in_jni_thread(Bind(cb, status));
		}

		void btif_multiadv_set_params_impl(int advertiser_id, int min_interval,
		int max_interval, int adv_type, int chnl_map,
		int tx_power) {
		virtual void MultiAdvSetParameters(int advertiser_id, int min_interval,
		int max_interval, int adv_type,
		int chnl_map, int tx_power,
		BleAdvertiserCb cb) {
		tBTM_BLE_ADV_PARAMS* params = new tBTM_BLE_ADV_PARAMS;
		params->adv_int_min = min_interval;
		params->adv_int_max = max_interval;
		@@ -228,121 +225,68 @@ void btif_multiadv_set_params_impl(int advertiser_id, int min_interval,

		do_in_bta_thread(
		FROM_HERE,
		base::Bind(&BleAdvertisingManager::SetParameters,
		Bind(&BleAdvertisingManager::SetParameters,
		base::Unretained(BleAdvertisingManager::Get()), advertiser_id,
		base::Owned(params),
		base::Bind(multi_adv_set_params_cb, advertiser_id)));
		Bind(&BleAdvertiserInterfaceImpl::MultiAdvSetParametersCb,
		base::Unretained(this), cb)));
		}

		bt_status_t btif_multiadv_set_params(int advertiser_id, int min_interval,
		int max_interval, int adv_type,
		int chnl_map, int tx_power) {
		CHECK_BTGATT_INIT();
		return do_in_jni_thread(Bind(btif_multiadv_set_params_impl, advertiser_id,
		min_interval, max_interval, adv_type, chnl_map,
		tx_power));
		void MultiAdvSetInstDataCb(BleAdvertiserCb cb, uint8_t advertiser_id,
		uint8_t status) {
		do_in_jni_thread(Bind(cb, status));
		}

		void multi_adv_data_cb_impl(int advertiser_id, int status) {
		HAL_CBACK(bt_gatt_callbacks, advertiser->multi_adv_data_cb, advertiser_id,
		status);
		}

		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));
		}

		void btif_multiadv_set_data_impl(int advertiser_id, bool set_scan_rsp,
		vector<uint8_t> data) {
		do_in_bta_thread(FROM_HERE,
		base::Bind(&BleAdvertisingManager::SetData,
		base::Unretained(BleAdvertisingManager::Get()),
		advertiser_id, set_scan_rsp, std::move(data),
		base::Bind(multi_adv_data_cb, advertiser_id)));
		}

		bt_status_t btif_multiadv_set_data(int advertiser_id, bool set_scan_rsp,
		bool include_name, bool incl_txpower,
		int appearance,
		void MultiAdvSetInstData(int advertiser_id, bool set_scan_rsp,
		bool include_name, bool incl_txpower, int appearance,
		vector<uint8_t> manufacturer_data,
		vector<uint8_t> service_data,
		vector<uint8_t> service_uuid) {
		CHECK_BTGATT_INIT();

		vector<uint8_t> service_uuid,
		BleAdvertiserCb cb) override {
		vector<uint8_t> data =
		build_adv_data(set_scan_rsp, include_name, incl_txpower, appearance,
		manufacturer_data, service_data, service_uuid);

		return do_in_jni_thread(Bind(&btif_multiadv_set_data_impl, advertiser_id,
		set_scan_rsp, std::move(data)));
		do_in_bta_thread(
		FROM_HERE, Bind(&BleAdvertisingManager::SetData,
		base::Unretained(BleAdvertisingManager::Get()),
		advertiser_id, set_scan_rsp, std::move(data),
		Bind(&BleAdvertiserInterfaceImpl::MultiAdvSetInstDataCb,
		base::Unretained(this), cb, advertiser_id)));
		}

		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,
		status, enable);
		void MultiAdvEnableTimeoutCb(BleAdvertiserCb cb, uint8_t status) {
		do_in_jni_thread(Bind(cb, status));
		}

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

		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 MultiAdvEnable(uint8_t advertiser_id, bool enable, BleAdvertiserCb cb,
		int timeout_s, BleAdvertiserCb timeout_cb) override {
		VLOG(1) << __func__ << " advertiser_id: " << +advertiser_id
		<< " ,enable: " << enable;

		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,
		enable);
		do_in_bta_thread(
		FROM_HERE,
		base::Bind(&BleAdvertisingManager::Enable,
		Bind(&BleAdvertisingManager::Enable,
		base::Unretained(BleAdvertisingManager::Get()), advertiser_id,
		enable, 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,
		int timeout_s) {
		CHECK_BTGATT_INIT();
		return do_in_jni_thread(
		Bind(btif_multiadv_enable_impl, advertiser_id, enable, timeout_s));
		}

		void multi_adv_reg_cb_impl(bt_uuid_t uuid, int advertiser_id, int status) {
		HAL_CBACK(bt_gatt_callbacks, advertiser->register_advertiser_cb, status,
		advertiser_id, &uuid);
		enable, Bind(&BleAdvertiserInterfaceImpl::MultiAdvEnableCb,
		base::Unretained(this), cb),
		timeout_s,
		Bind(&BleAdvertiserInterfaceImpl::MultiAdvEnableTimeoutCb,
		base::Unretained(this), timeout_cb)));
		}
		};

		void multi_adv_reg_cb(bt_uuid_t uuid, uint8_t advertiser_id, uint8_t status) {
		do_in_jni_thread(Bind(multi_adv_reg_cb_impl, uuid, advertiser_id, status));
		}
		BleAdvertiserInterface* btLeAdvertiserInstance = nullptr;

		bt_status_t btif_multiadv_register(bt_uuid_t* uuid) {
		do_in_bta_thread(FROM_HERE,
		base::Bind(&BleAdvertisingManager::RegisterAdvertiser,
		base::Unretained(BleAdvertisingManager::Get()),
		base::Bind(multi_adv_reg_cb, *uuid)));
		return (bt_status_t)BTA_GATT_OK;
		}
		} // namespace

		bt_status_t btif_multiadv_unregister(int advertiser_id) {
		do_in_bta_thread(FROM_HERE,
		base::Bind(&BleAdvertisingManager::Unregister,
		base::Unretained(BleAdvertisingManager::Get()),
		advertiser_id));
		BleAdvertiserInterface* get_ble_advertiser_instance() {
		if (btLeAdvertiserInstance == nullptr)
		btLeAdvertiserInstance = new BleAdvertiserInterfaceImpl();

		return (bt_status_t)BTA_GATT_OK;
		return btLeAdvertiserInstance;
		}

		} // namespace

		const ble_advertiser_interface_t btLeAdvertiserInstance = {
		btif_multiadv_register,
		btif_multiadv_unregister,
		btif_adv_set_data,
		btif_multiadv_set_params,
		btif_multiadv_set_data,
		btif_multiadv_enable
		};

system/btif/src/btif_gatt.cc

+7 −4

Original line number	Diff line number	Diff line
		@@ -58,7 +58,6 @@ const btgatt_callbacks_t *bt_gatt_callbacks = NULL;
		static bt_status_t btif_gatt_init( const btgatt_callbacks_t* callbacks )
		{
		bt_gatt_callbacks = callbacks;

		return BT_STATUS_SUCCESS;
		}

		@@ -80,7 +79,7 @@ static void btif_gatt_cleanup( void )
		BTA_GATTS_Disable();
		}

		static const btgatt_interface_t btgattInterface = {
		static btgatt_interface_t btgattInterface = {
		sizeof(btgattInterface),

		btif_gatt_init,
		@@ -88,7 +87,7 @@ static const btgatt_interface_t btgattInterface = {

		&btgattClientInterface,
		&btgattServerInterface,
		&btLeAdvertiserInstance
		nullptr //filled in btif_gatt_get_interface
		};

		/*******************************************************************************
		@@ -102,6 +101,10 @@ static const btgatt_interface_t btgattInterface = {
		*******************************************************************************/
		const btgatt_interface_t *btif_gatt_get_interface()
		{
		// TODO(jpawlowski) right now initializing advertiser field in static
		// structure cause explosion of dependencies. It must be initialized here
		// until those dependencies are properly abstracted for tests.
		btgattInterface.advertiser = get_ble_advertiser_instance();
		return &btgattInterface;
		}

system/service/gatt_server_old.cc

+4 −28

Original line number	Diff line number	Diff line
		@@ -40,10 +40,8 @@
		#include "service/hal/bluetooth_interface.h"
		#include "service/logging_helpers.h"

		extern "C" {
		#include "osi/include/log.h"
		#include "osi/include/osi.h"
		} // extern "C"

		namespace {

		@@ -343,7 +341,7 @@ void RegisterClientCallback(int status, int client_if, bt_uuid_t *app_uuid) {
		g_internal->client_if = client_if;

		// Setup our advertisement. This has no callback.
		bt_status_t btstat = g_internal->gatt->advertiser->set_adv_data(
		g_internal->gatt->advertiser->SetData(
		client_if, false, /* beacon, not scan response */
		false, /* name */
		false, /* no txpower */
		@@ -352,14 +350,10 @@ void RegisterClientCallback(int status, int client_if, bt_uuid_t *app_uuid) {
		{}, /* no mfg data */
		{}, /* no service data */
		{} /* no service id yet */);
		if (btstat != BT_STATUS_SUCCESS) {
		LOG_ERROR(LOG_TAG, "Failed to set advertising data");
		return;
		}

		// TODO(icoolidge): Deprecated, use multi-adv interface.
		// This calls back to ListenCallback.
		btstat = g_internal->gatt->client->listen(client_if, true);
		bt_status_t btstat = g_internal->gatt->client->listen(client_if, true);
		if (btstat != BT_STATUS_SUCCESS) {
		LOG_ERROR(LOG_TAG, "Failed to start listening");
		}
		@@ -462,13 +456,6 @@ const btgatt_client_callbacks_t gatt_client_callbacks = {
		nullptr, /* services_added_cb */
		};

		const ble_advertiser_callbacks_t bt_le_advertiser_callbacks = {
		nullptr, /* multi_adv_register_cb; */
		nullptr, /* multi_adv_set_params_cb */
		nullptr, /* multi_adv_data_cb*/
		nullptr, /* multi_adv_enable_cb; */
		};

		const btgatt_callbacks_t gatt_callbacks = {
		/** Set to sizeof(btgatt_callbacks_t) */
		sizeof(btgatt_callbacks_t),
		@@ -478,9 +465,6 @@ const btgatt_callbacks_t gatt_callbacks = {

		/** GATT Server callbacks */
		&gatt_server_callbacks,

		/** GATT Advertiser callbacks */
		&bt_le_advertiser_callbacks,
		};

		} // namespace
		@@ -598,7 +582,7 @@ bool Server::SetAdvertisement(const std::vector<UUID>& ids,
		std::lock_guard<std::mutex> lock(internal_->lock);

		// Setup our advertisement. This has no callback.
		bt_status_t btstat = internal_->gatt->advertiser->set_adv_data(
		internal_->gatt->advertiser->SetData(
		internal_->client_if, false, /* beacon, not scan response */
		transmit_name, /* name */
		false, /* no txpower */
		@@ -607,10 +591,6 @@ bool Server::SetAdvertisement(const std::vector<UUID>& ids,
		mutable_manufacturer_data,
		mutable_service_data,
		id_data);
		if (btstat != BT_STATUS_SUCCESS) {
		LOG_ERROR(LOG_TAG, "Failed to set advertising data");
		return false;
		}
		return true;
		}

		@@ -630,7 +610,7 @@ bool Server::SetScanResponse(const std::vector<UUID>& ids,
		std::lock_guard<std::mutex> lock(internal_->lock);

		// Setup our advertisement. This has no callback.
		bt_status_t btstat = internal_->gatt->advertiser->set_adv_data(
		internal_->gatt->advertiser->SetData(
		internal_->client_if, true, /* scan response */
		transmit_name, /* name */
		false, /* no txpower */
		@@ -639,10 +619,6 @@ bool Server::SetScanResponse(const std::vector<UUID>& ids,
		mutable_manufacturer_data,
		mutable_service_data,
		id_data);
		if (btstat != BT_STATUS_SUCCESS) {
		LOG_ERROR(LOG_TAG, "Failed to set scan response data");
		return false;
		}
		return true;
		}