Merge "[GD] Implement Advertising APIs for OOB" (20d9d331) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/le_advertising_manager.cc

+80 −5

Original line number	Diff line number	Diff line
		@@ -33,6 +33,7 @@ namespace bluetooth {
		namespace hci {

		const ModuleFactory LeAdvertisingManager::Factory = ModuleFactory([]() { return new LeAdvertisingManager(); });
		constexpr int kIdLocal = 0xff; // Id for advertiser not register from Java layer

		enum class AdvertisingApiType {
		LEGACY = 1,
		@@ -51,6 +52,8 @@ enum class AdvertisingFlag : uint8_t {
		struct Advertiser {
		os::Handler* handler;
		AddressWithType current_address;
		base::Callback<void(uint8_t /* status */)> status_callback;
		base::Callback<void(uint8_t /* status */)> timeout_callback;
		common::Callback<void(Address, AddressType)> scan_callback;
		common::Callback<void(ErrorCode, uint8_t, uint8_t)> set_terminated_callback;
		int8_t tx_power;
		@@ -186,7 +189,14 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		auto status = event_view.GetStatus();
		acl_manager_->OnAdvertisingSetTerminated(status, event_view.GetConnectionHandle(), advertiser_address);
		if (status == ErrorCode::LIMIT_REACHED \|\| status == ErrorCode::ADVERTISING_TIMEOUT) {
		if (id_map_[advertiser_id] == kIdLocal) {
		if (!advertising_sets_[advertiser_id].timeout_callback.is_null()) {
		advertising_sets_[advertiser_id].timeout_callback.Run((uint8_t)status);
		advertising_sets_[advertiser_id].timeout_callback.Reset();
		}
		} else {
		advertising_callbacks_->OnAdvertisingEnabled(advertiser_id, false, (uint8_t)status);
		}
		return;
		}

		@@ -304,6 +314,21 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		}
		}

		void start_advertising(
		AdvertiserId id,
		const ExtendedAdvertisingConfig config,
		uint16_t duration,
		const base::Callback<void(uint8_t /* status */)>& status_callback,
		const base::Callback<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,
		os::Handler* handler) {
		advertising_sets_[id].status_callback = status_callback;
		advertising_sets_[id].timeout_callback = timeout_callback;

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

		void create_extended_advertiser(
		int reg_id,
		AdvertiserId id,
		@@ -975,6 +1000,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		std::mutex id_mutex_;
		size_t num_instances_;
		std::vector<hci::EnabledSet> enabled_sets_;
		// map to mapping the id from java layer and advertier id
		std::map<uint8_t, int> id_map_;

		AdvertisingApiType advertising_api_type_{0};
		@@ -1016,6 +1042,14 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		continue;
		}

		if (id_map_[id] == kIdLocal) {
		if (!advertising_sets_[enabled_set.advertising_handle_].status_callback.is_null()) {
		advertising_sets_[enabled_set.advertising_handle_].status_callback.Run(advertising_status);
		advertising_sets_[enabled_set.advertising_handle_].status_callback.Reset();
		}
		continue;
		}

		if (started) {
		advertising_callbacks_->OnAdvertisingEnabled(id, enable, advertising_status);
		} else {
		@@ -1050,6 +1084,14 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		continue;
		}

		if (id_map_[id] == kIdLocal) {
		if (!advertising_sets_[enabled_set.advertising_handle_].status_callback.is_null()) {
		advertising_sets_[enabled_set.advertising_handle_].status_callback.Run(advertising_status);
		advertising_sets_[enabled_set.advertising_handle_].status_callback.Reset();
		}
		continue;
		}

		if (started) {
		advertising_callbacks_->OnAdvertisingEnabled(id, enable, advertising_status);
		} else {
		@@ -1072,7 +1114,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		}
		advertising_sets_[id].tx_power = complete_view.GetSelectedTxPower();

		if (advertising_sets_[id].started) {
		if (advertising_sets_[id].started && id_map_[id] != kIdLocal) {
		advertising_callbacks_->OnAdvertisingParametersUpdated(id, advertising_sets_[id].tx_power, advertising_status);
		}
		}
		@@ -1088,7 +1130,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		advertising_status = AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR;
		}

		if (advertising_callbacks_ == nullptr \|\| !advertising_sets_[id].started) {
		if (advertising_callbacks_ == nullptr \|\| !advertising_sets_[id].started \|\| id_map_[id] == kIdLocal) {
		return;
		}

		@@ -1129,8 +1171,9 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		advertising_status = AdvertisingCallback::AdvertisingStatus::INTERNAL_ERROR;
		}

		// Do not trigger callback if the advertiser not stated yet
		if (advertising_callbacks_ == nullptr \|\| !advertising_sets_[id].started) {
		// Do not trigger callback if the advertiser not stated yet, or the advertiser is not register
		// from Java layer
		if (advertising_callbacks_ == nullptr \|\| !advertising_sets_[id].started \|\| id_map_[id] == kIdLocal) {
		return;
		}

		@@ -1300,6 +1343,38 @@ AdvertiserId LeAdvertisingManager::ExtendedCreateAdvertiser(
		return id;
		}

		void LeAdvertisingManager::StartAdvertising(
		AdvertiserId advertiser_id,
		const ExtendedAdvertisingConfig config,
		uint16_t duration,
		const base::Callback<void(uint8_t /* status */)>& status_callback,
		const base::Callback<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,
		os::Handler* handler) {
		CallOn(
		pimpl_.get(),
		&impl::start_advertising,
		advertiser_id,
		config,
		duration,
		status_callback,
		timeout_callback,
		scan_callback,
		set_terminated_callback,
		handler);
		}

		void LeAdvertisingManager::RegisterAdvertiser(
		base::Callback<void(uint8_t /* inst_id /, uint8_t / status */)> callback) {
		AdvertiserId id = pimpl_->allocate_advertiser();
		if (id == kInvalidId) {
		callback.Run(kInvalidId, AdvertisingCallback::AdvertisingStatus::TOO_MANY_ADVERTISERS);
		} else {
		callback.Run(id, AdvertisingCallback::AdvertisingStatus::SUCCESS);
		}
		}

		void LeAdvertisingManager::GetOwnAddress(uint8_t advertiser_id) {
		CallOn(pimpl_.get(), &impl::get_own_address, advertiser_id);
		}

system/gd/hci/le_advertising_manager.h

+12 −0

Original line number	Diff line number	Diff line
		@@ -116,8 +116,20 @@ class LeAdvertisingManager : public bluetooth::Module {
		uint8_t max_extended_advertising_events,
		os::Handler* handler);

		void StartAdvertising(
		AdvertiserId advertiser_id,
		const ExtendedAdvertisingConfig config,
		uint16_t duration,
		const base::Callback<void(uint8_t /* status */)>& status_callback,
		const base::Callback<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,
		os::Handler* handler);

		void GetOwnAddress(uint8_t advertiser_id);

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

		void SetParameters(AdvertiserId advertiser_id, ExtendedAdvertisingConfig config);

		void SetData(AdvertiserId advertiser_id, bool set_scan_rsp, std::vector<GapData> data);

system/main/shim/le_advertising_manager.cc

+43 −1

Original line number	Diff line number	Diff line
		@@ -59,9 +59,9 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface,
		bluetooth::shim::GetAdvertising()->RegisterAdvertisingCallback(this);
		}

		// nobody use this function
		void RegisterAdvertiser(IdStatusCallback cb) override {
		LOG(INFO) << __func__ << " in shim layer";
		bluetooth::shim::GetAdvertising()->RegisterAdvertiser(cb);
		}

		void Unregister(uint8_t advertiser_id) override {
		@@ -73,6 +73,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface,

		void GetOwnAddress(uint8_t advertiser_id, GetAddressCallback cb) override {
		LOG(INFO) << __func__ << " in shim layer";
		address_callbacks_[advertiser_id] = cb;
		bluetooth::shim::GetAdvertising()->GetOwnAddress(advertiser_id);
		}

		@@ -123,6 +124,41 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface,
		std::vector<uint8_t> scan_response_data, int timeout_s,
		MultiAdvCb timeout_cb) override {
		LOG(INFO) << __func__ << " in shim layer";

		bluetooth::hci::ExtendedAdvertisingConfig config{};
		parse_parameter(config, params);

		size_t offset = 0;
		while (offset < advertise_data.size()) {
		GapData gap_data;
		uint8_t len = advertise_data[offset];
		auto begin = advertise_data.begin() + offset;
		auto end = begin + len + 1; // 1 byte for len
		auto data_copy = std::make_shared<std::vector<uint8_t>>(begin, end);
		bluetooth::packet::PacketView<bluetooth::packet::kLittleEndian> packet(
		data_copy);
		GapData::Parse(&gap_data, packet.begin());
		config.advertisement.push_back(gap_data);
		offset += len + 1; // 1 byte for len
		}

		offset = 0;
		while (offset < scan_response_data.size()) {
		GapData gap_data;
		uint8_t len = scan_response_data[offset];
		auto begin = scan_response_data.begin() + offset;
		auto end = begin + len + 1; // 1 byte for len
		auto data_copy = std::make_shared<std::vector<uint8_t>>(begin, end);
		bluetooth::packet::PacketView<bluetooth::packet::kLittleEndian> packet(
		data_copy);
		GapData::Parse(&gap_data, packet.begin());
		config.scan_response.push_back(gap_data);
		offset += len + 1; // 1 byte for len
		}

		bluetooth::shim::GetAdvertising()->StartAdvertising(
		advertiser_id, config, timeout_s * 100, cb, timeout_cb, scan_callback,
		set_terminated_callback, bluetooth::shim::GetGdShimHandler());
		}

		void StartAdvertisingSet(int reg_id, IdTxPowerStatusCallback register_cb,
		@@ -331,6 +367,11 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface,
		void OnOwnAddressRead(uint8_t advertiser_id, uint8_t address_type,
		bluetooth::hci::Address address) {
		RawAddress raw_address = bluetooth::ToRawAddress(address);
		if (address_callbacks_.find(advertiser_id) != address_callbacks_.end()) {
		address_callbacks_[advertiser_id].Run(address_type, raw_address);
		address_callbacks_.erase(advertiser_id);
		return;
		}
		do_in_jni_thread(FROM_HERE,
		base::Bind(&AdvertisingCallbacks::OnOwnAddressRead,
		base::Unretained(advertising_callbacks_),
		@@ -362,6 +403,7 @@ class BleAdvertiserInterfaceImpl : public BleAdvertiserInterface,
		// TODO set own_address_type based on address policy
		config.own_address_type = OwnAddressType::RANDOM_DEVICE_ADDRESS;
		}
		std::map<uint8_t, GetAddressCallback> address_callbacks_;
		};

		BleAdvertiserInterfaceImpl* bt_le_advertiser_instance = nullptr;