Merge "[DCK] Manage all advertiser IDs inside the handler thread" (bcc66e11) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_gatt.cpp

+13 −10

Original line number	Diff line number	Diff line
		@@ -2329,11 +2329,19 @@ static PeriodicAdvertisingParameters parsePeriodicParams(JNIEnv* env,
		return p;
		}

		static void ble_advertising_set_started_cb(int reg_id, uint8_t advertiser_id,
		static void ble_advertising_set_started_cb(int reg_id, int server_if,
		uint8_t advertiser_id,
		int8_t tx_power, uint8_t status) {
		std::shared_lock<std::shared_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| !mAdvertiseCallbacksObj) return;

		// tie advertiser ID to server_if, once the advertisement has started
		if (status == 0 /* AdvertisingCallback::AdvertisingStatus::SUCCESS */ &&
		server_if != 0) {
		bluetooth::gatt::associate_server_with_advertiser(server_if, advertiser_id);
		}

		sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
		method_onAdvertisingSetStarted, reg_id,
		advertiser_id, tx_power, status);
		@@ -2376,15 +2384,10 @@ static void startAdvertisingSetNative(
		periodic_data_data, periodic_data_data + periodic_data_len);
		env->ReleaseByteArrayElements(periodic_data, periodic_data_data, JNI_ABORT);

		auto advertiser_id = sGattIf->advertiser->StartAdvertisingSet(
		reg_id, base::Bind(&ble_advertising_set_started_cb, reg_id), params,
		data_vec, scan_resp_vec, periodicParams, periodic_data_vec, duration,
		maxExtAdvEvents, base::Bind(ble_advertising_set_timeout_cb));

		// tie advertiser ID to server_if
		if (server_if != 0) {
		bluetooth::gatt::associate_server_with_advertiser(server_if, advertiser_id);
		}
		sGattIf->advertiser->StartAdvertisingSet(
		reg_id, base::Bind(&ble_advertising_set_started_cb, reg_id, server_if),
		params, data_vec, scan_resp_vec, periodicParams, periodic_data_vec,
		duration, maxExtAdvEvents, base::Bind(ble_advertising_set_timeout_cb));
		}

		static void stopAdvertisingSetNative(JNIEnv* env, jobject object,

system/btif/src/btif_ble_advertiser.cc

+10 −10

Original line number	Diff line number	Diff line
		@@ -190,7 +190,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface {
		timeout_s * 100, jni_thread_wrapper(FROM_HERE, timeout_cb)));
		}

		uint8_t StartAdvertisingSet(int reg_id, IdTxPowerStatusCallback cb,
		void StartAdvertisingSet(int reg_id, IdTxPowerStatusCallback cb,
		AdvertiseParameters params,
		std::vector<uint8_t> advertise_data,
		std::vector<uint8_t> scan_response_data,
		@@ -200,7 +200,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface {
		IdStatusCallback timeout_cb) override {
		VLOG(1) << __func__;

		if (!BleAdvertisingManager::IsInitialized()) return {};
		if (!BleAdvertisingManager::IsInitialized()) return;
		tBTM_BLE_ADV_PARAMS* p_params = new tBTM_BLE_ADV_PARAMS;
		parseParams(p_params, params);

		@@ -216,7 +216,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface {
		std::move(periodic_data), duration, maxExtAdvEvents,
		jni_thread_wrapper(FROM_HERE, timeout_cb)));

		return {};
		return;
		}

		void SetPeriodicAdvertisingParameters(

system/gd/hci/facade/le_advertising_manager_facade.cc

+17 −3

Original line number	Diff line number	Diff line
		@@ -218,6 +218,7 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser
		: le_advertising_manager_(le_advertising_manager), facade_handler_(facade_handler) {
		ASSERT(le_advertising_manager_ != nullptr);
		ASSERT(facade_handler_ != nullptr);
		le_advertising_manager_->RegisterAdvertisingCallback(this);
		}

		::grpc::Status CreateAdvertiser(::grpc::ServerContext* context, const CreateAdvertiserRequest* request,
		@@ -229,7 +230,10 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser
		return ::grpc::Status(::grpc::StatusCode::INVALID_ARGUMENT, "Error while parsing advertising config");
		}
		LeAdvertiser le_advertiser(config);
		auto advertiser_id = le_advertising_manager_->ExtendedCreateAdvertiser(

		pending_advertiser_id_ = std::promise<AdvertiserId>();
		auto future = pending_advertiser_id_->get_future();
		le_advertising_manager_->ExtendedCreateAdvertiser(
		0,
		config,
		common::Bind(&LeAdvertiser::ScanCallback, common::Unretained(&le_advertiser)),
		@@ -237,6 +241,8 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser
		0,
		0,
		facade_handler_);

		auto advertiser_id = future.get();
		if (advertiser_id != LeAdvertisingManager::kInvalidId) {
		le_advertiser.SetAdvertiserId(advertiser_id);
		le_advertisers_.push_back(le_advertiser);
		@@ -257,7 +263,9 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser
		return ::grpc::Status(::grpc::StatusCode::INVALID_ARGUMENT, "Error while parsing advertising config");
		}
		LeAdvertiser le_advertiser(config);
		auto advertiser_id = le_advertising_manager_->ExtendedCreateAdvertiser(
		pending_advertiser_id_ = std::promise<AdvertiserId>();
		auto future = pending_advertiser_id_->get_future();
		le_advertising_manager_->ExtendedCreateAdvertiser(
		0,
		config,
		common::Bind(&LeAdvertiser::ScanCallback, common::Unretained(&le_advertiser)),
		@@ -265,6 +273,8 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser
		0,
		0,
		facade_handler_);

		auto advertiser_id = future.get();
		if (advertiser_id != LeAdvertisingManager::kInvalidId) {
		le_advertiser.SetAdvertiserId(advertiser_id);
		le_advertisers_.push_back(le_advertiser);
		@@ -377,7 +387,6 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser
		::grpc::ServerContext* context,
		const ::google::protobuf::Empty* request,
		::grpc::ServerWriter<AdvertisingCallbackMsg>* writer) override {
		le_advertising_manager_->RegisterAdvertisingCallback(this);
		return callback_events_.RunLoop(context, writer);
		}

		@@ -389,6 +398,10 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser
		}

		void OnAdvertisingSetStarted(int reg_id, uint8_t advertiser_id, int8_t tx_power, AdvertisingStatus status) {
		if (pending_advertiser_id_.has_value()) {
		pending_advertiser_id_->set_value(advertiser_id);
		pending_advertiser_id_.reset();
		}
		AdvertisingCallbackMsg msg;
		msg.set_message_type(AdvertisingCallbackMsgType::ADVERTISING_SET_STARTED);
		msg.set_advertiser_id(advertiser_id);
		@@ -469,6 +482,7 @@ class LeAdvertisingManagerFacadeService : public LeAdvertisingManagerFacade::Ser

		std::vector<LeAdvertiser> le_advertisers_;
		LeAdvertisingManager* le_advertising_manager_;
		std::optional<std::promise<AdvertiserId>> pending_advertiser_id_;
		os::Handler* facade_handler_;
		::bluetooth::grpc::GrpcEventQueue<AdvertisingCallbackMsg> callback_events_{"callback events"};
		::bluetooth::grpc::GrpcEventQueue<AddressMsg> address_events_{"address events"};

system/gd/hci/le_advertising_manager.cc

+103 −85

Original line number	Diff line number	Diff line
		@@ -330,8 +330,6 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		AdvertiserId allocate_advertiser() {
		// number of LE_MULTI_ADVT start from 1
		AdvertiserId id = advertising_api_type_ == AdvertisingApiType::ANDROID_HCI ? 1 : 0;
		{
		std::unique_lock lock(id_mutex_);
		while (id < num_instances_ && advertising_sets_.count(id) != 0) {
		id++;
		}
		@@ -340,7 +338,6 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		return kInvalidId;
		}
		advertising_sets_[id].in_use = true;
		}
		return id;
		}

		@@ -393,11 +390,27 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		}

		void create_advertiser(
		int reg_id,
		const AdvertisingConfig config,
		common::Callback<void(Address, AddressType)> scan_callback,
		common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,
		os::Handler* handler) {
		AdvertiserId id = allocate_advertiser();
		if (id == kInvalidId) {
		LOG_WARN("Number of max instances reached");
		start_advertising_fail(reg_id, AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);
		return;
		}

		create_advertiser_with_id(reg_id, id, config, scan_callback, set_terminated_callback, handler);
		}

		void create_advertiser_with_id(
		int reg_id,
		AdvertiserId id,
		const AdvertisingConfig config,
		const common::Callback<void(Address, AddressType)>& scan_callback,
		const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,
		common::Callback<void(Address, AddressType)> scan_callback,
		common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,
		os::Handler* handler) {
		// check advertising data is valid before start advertising
		if (!check_advertising_data(config.advertisement, config.connectable && config.discoverable) \|\|
		@@ -465,28 +478,55 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		uint16_t duration,
		base::OnceCallback<void(uint8_t /* status */)> status_callback,
		base::OnceCallback<void(uint8_t /* status */)> timeout_callback,
		const common::Callback<void(Address, AddressType)>& scan_callback,
		const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,
		const common::Callback<void(Address, AddressType)> scan_callback,
		const common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,
		os::Handler* handler) {
		advertising_sets_[id].status_callback = std::move(status_callback);
		advertising_sets_[id].timeout_callback = std::move(timeout_callback);

		create_extended_advertiser(kIdLocal, id, config, scan_callback, set_terminated_callback, duration, 0, handler);
		create_extended_advertiser_with_id(
		kIdLocal, id, config, scan_callback, set_terminated_callback, duration, 0, handler);
		}

		void create_extended_advertiser(
		int reg_id,
		const AdvertisingConfig config,
		common::Callback<void(Address, AddressType)> scan_callback,
		common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,
		uint16_t duration,
		uint8_t max_ext_adv_events,
		os::Handler* handler) {
		AdvertiserId id = allocate_advertiser();
		if (id == kInvalidId) {
		LOG_WARN("Number of max instances reached");
		start_advertising_fail(reg_id, AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);
		return;
		}
		create_extended_advertiser_with_id(
		reg_id,
		id,
		config,
		scan_callback,
		set_terminated_callback,
		duration,
		max_ext_adv_events,
		handler);
		}

		void create_extended_advertiser_with_id(
		int reg_id,
		AdvertiserId id,
		const AdvertisingConfig config,
		const common::Callback<void(Address, AddressType)>& scan_callback,
		const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,
		common::Callback<void(Address, AddressType)> scan_callback,
		common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,
		uint16_t duration,
		uint8_t max_ext_adv_events,
		os::Handler* handler) {
		id_map_[id] = reg_id;

		if (advertising_api_type_ != AdvertisingApiType::EXTENDED) {
		create_advertiser(reg_id, id, config, scan_callback, set_terminated_callback, handler);
		create_advertiser_with_id(
		reg_id, id, config, scan_callback, set_terminated_callback, handler);
		return;
		}

		@@ -661,6 +701,16 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		le_address_manager_->GetNextPrivateAddressIntervalMs());
		}

		void register_advertiser(
		common::ContextualOnceCallback<void(uint8_t /* inst_id /, uint8_t / status */)> callback) {
		AdvertiserId id = allocate_advertiser();
		if (id == kInvalidId) {
		callback.Invoke(kInvalidId, AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);
		} else {
		callback.Invoke(id, AdvertisingCallback::AdvertisingStatus::SUCCESS);
		}
		}

		void get_own_address(AdvertiserId advertiser_id) {
		if (advertising_sets_.find(advertiser_id) == advertising_sets_.end()) {
		LOG_INFO("Unknown advertising id %u", advertiser_id);
		@@ -1588,54 +1638,38 @@ size_t LeAdvertisingManager::GetNumberOfAdvertisingInstances() const {
		return pimpl_->GetNumberOfAdvertisingInstances();
		}

		AdvertiserId LeAdvertisingManager::create_advertiser(
		void LeAdvertisingManager::ExtendedCreateAdvertiser(
		int reg_id,
		const AdvertisingConfig config,
		const common::Callback<void(Address, AddressType)>& scan_callback,
		const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,
		common::Callback<void(Address, AddressType)> scan_callback,
		common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,
		uint16_t duration,
		uint8_t max_extended_advertising_events,
		os::Handler* handler) {
		AdvertisingApiType advertising_api_type = pimpl_->get_advertising_api_type();
		if (advertising_api_type != AdvertisingApiType::EXTENDED) {
		if (config.peer_address == Address::kEmpty) {
		if (config.advertising_type == hci::AdvertisingType::ADV_DIRECT_IND_HIGH \|\|
		config.advertising_type == hci::AdvertisingType::ADV_DIRECT_IND_LOW) {
		LOG_WARN("Peer address can not be empty for directed advertising");
		CallOn(
		pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);
		return kInvalidId;
		}
		}
		AdvertiserId id = pimpl_->allocate_advertiser();
		if (id == kInvalidId) {
		LOG_WARN("Number of max instances reached");
		CallOn(
		pimpl_.get(),
		&impl::start_advertising_fail,
		reg_id,
		AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);
		return id;
		AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);
		return;
		}
		}
		GetHandler()->Post(common::BindOnce(
		&impl::create_advertiser,
		common::Unretained(pimpl_.get()),
		reg_id,
		id,
		config,
		scan_callback,
		set_terminated_callback,
		handler));
		return id;
		}

		AdvertiserId LeAdvertisingManager::ExtendedCreateAdvertiser(
		int reg_id,
		const AdvertisingConfig config,
		const common::Callback<void(Address, AddressType)>& scan_callback,
		const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,
		uint16_t duration,
		uint8_t max_extended_advertising_events,
		os::Handler* handler) {
		AdvertisingApiType advertising_api_type = pimpl_->get_advertising_api_type();
		if (advertising_api_type != AdvertisingApiType::EXTENDED) {
		return create_advertiser(reg_id, config, scan_callback, set_terminated_callback, handler);
		return;
		};

		if (config.directed) {
		@@ -1643,55 +1677,44 @@ AdvertiserId LeAdvertisingManager::ExtendedCreateAdvertiser(
		LOG_INFO("Peer address can not be empty for directed advertising");
		CallOn(
		pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);
		return kInvalidId;
		return;
		}
		}
		if (config.channel_map == 0) {
		LOG_INFO("At least one channel must be set in the map");
		CallOn(pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);
		return kInvalidId;
		return;
		}
		if (!config.legacy_pdus) {
		if (config.connectable && config.scannable) {
		LOG_INFO("Extended advertising PDUs can not be connectable and scannable");
		CallOn(
		pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);
		return kInvalidId;
		return;
		}
		if (config.high_duty_directed_connectable) {
		LOG_INFO("Extended advertising PDUs can not be high duty cycle");
		CallOn(
		pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);
		return kInvalidId;
		return;
		}
		}
		if (config.interval_min > config.interval_max) {
		LOG_INFO("Advertising interval: min (%hu) > max (%hu)", config.interval_min, config.interval_max);
		CallOn(pimpl_.get(), &impl::start_advertising_fail, reg_id, AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR);
		return kInvalidId;
		}
		AdvertiserId id = pimpl_->allocate_advertiser();
		if (id == kInvalidId) {
		LOG_WARN("Number of max instances reached");
		CallOn(
		pimpl_.get(),
		&impl::start_advertising_fail,
		reg_id,
		AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);
		return id;
		return;
		}
		CallOn(
		pimpl_.get(),
		&impl::create_extended_advertiser,
		reg_id,
		id,
		config,
		scan_callback,
		set_terminated_callback,
		duration,
		max_extended_advertising_events,
		handler);
		return id;
		return;
		}

		void LeAdvertisingManager::StartAdvertising(
		@@ -1700,8 +1723,8 @@ void LeAdvertisingManager::StartAdvertising(
		uint16_t duration,
		base::OnceCallback<void(uint8_t /* status */)> status_callback,
		base::OnceCallback<void(uint8_t /* status */)> timeout_callback,
		const common::Callback<void(Address, AddressType)>& scan_callback,
		const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,
		common::Callback<void(Address, AddressType)> scan_callback,
		common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,
		os::Handler* handler) {
		CallOn(
		pimpl_.get(),
		@@ -1717,13 +1740,8 @@ void LeAdvertisingManager::StartAdvertising(
		}

		void LeAdvertisingManager::RegisterAdvertiser(
		base::OnceCallback<void(uint8_t /* inst_id /, uint8_t / status */)> callback) {
		AdvertiserId id = pimpl_->allocate_advertiser();
		if (id == kInvalidId) {
		std::move(callback).Run(kInvalidId, AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);
		} else {
		std::move(callback).Run(id, AdvertisingCallback::AdvertisingStatus::SUCCESS);
		}
		common::ContextualOnceCallback<void(uint8_t /* inst_id /, uint8_t / status */)> callback) {
		CallOn(pimpl_.get(), &impl::register_advertiser, std::move(callback));
		}

		void LeAdvertisingManager::GetOwnAddress(uint8_t advertiser_id) {

system/gd/hci/le_advertising_manager.h

+7 −13

Original line number	Diff line number	Diff line
		@@ -111,11 +111,11 @@ class LeAdvertisingManager : public bluetooth::Module {

		size_t GetNumberOfAdvertisingInstances() const;

		AdvertiserId ExtendedCreateAdvertiser(
		void ExtendedCreateAdvertiser(
		int reg_id,
		const AdvertisingConfig config,
		const common::Callback<void(Address, AddressType)>& scan_callback,
		const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,
		common::Callback<void(Address, AddressType)> scan_callback,
		common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,
		uint16_t duration,
		uint8_t max_extended_advertising_events,
		os::Handler* handler);
		@@ -126,13 +126,14 @@ class LeAdvertisingManager : public bluetooth::Module {
		uint16_t duration,
		base::OnceCallback<void(uint8_t /* status */)> status_callback,
		base::OnceCallback<void(uint8_t /* status */)> timeout_callback,
		const common::Callback<void(Address, AddressType)>& scan_callback,
		const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,
		common::Callback<void(Address, AddressType)> scan_callback,
		common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback,
		os::Handler* handler);

		void GetOwnAddress(uint8_t advertiser_id);

		void RegisterAdvertiser(base::OnceCallback<void(uint8_t /* inst_id /, uint8_t / status */)> callback);
		void RegisterAdvertiser(
		common::ContextualOnceCallback<void(uint8_t /* inst_id /, uint8_t / status */)> callback);

		void SetParameters(AdvertiserId advertiser_id, AdvertisingConfig config);

		@@ -163,13 +164,6 @@ class LeAdvertisingManager : public bluetooth::Module {
		std::string ToString() const override;

		private:
		// Return -1 if the advertiser was not created, otherwise the advertiser ID.
		AdvertiserId create_advertiser(
		int reg_id,
		const AdvertisingConfig config,
		const common::Callback<void(Address, AddressType)>& scan_callback,
		const common::Callback<void(ErrorCode, uint8_t, uint8_t)>& set_terminated_callback,
		os::Handler* handler);
		struct impl;
		std::unique_ptr<impl> pimpl_;
		};