L2cap shim improvements am: e51c82ee58 am: 51a81769a8 (2973173e) · Commits · e / os / android_packages_modules_Bluetooth

system/main/shim/btm.cc

+7 −21

Original line number	Original line	Diff line number	Diff line
	@@ -103,14 +103,6 @@ std::string Btm::ReadRemoteName::AddressString() const {
	return raw_address_.ToString();		return raw_address_.ToString();
	}		}

	static std::unordered_map<RawAddress, tBLE_ADDR_TYPE> le_address_type_cache_;

	static void store_le_address_type(RawAddress address, tBLE_ADDR_TYPE type) {
	if (le_address_type_cache_.count(address) == 0) {
	le_address_type_cache_[address] = type;
	}
	}

	void Btm::ScanningCallbacks::OnScannerRegistered(		void Btm::ScanningCallbacks::OnScannerRegistered(
	const bluetooth::hci::Uuid app_uuid, bluetooth::hci::ScannerId scanner_id,		const bluetooth::hci::Uuid app_uuid, bluetooth::hci::ScannerId scanner_id,
	ScanningStatus status){};		ScanningStatus status){};
	@@ -136,7 +128,6 @@ void Btm::ScanningCallbacks::OnScanResult(
	advertising_sid, tx_power, rssi,		advertising_sid, tx_power, rssi,
	periodic_advertising_interval,		periodic_advertising_interval,
	advertising_data.size(), &advertising_data[0]);		advertising_data.size(), &advertising_data[0]);
	store_le_address_type(raw_address, ble_address_type);
	}		}

	void Btm::ScanningCallbacks::OnTrackAdvFoundLost(){};		void Btm::ScanningCallbacks::OnTrackAdvFoundLost(){};
	@@ -666,24 +657,19 @@ uint16_t Btm::GetAclHandle(const RawAddress& remote_bda,
	}		}
	}		}

	tBLE_ADDR_TYPE Btm::GetAddressType(const RawAddress& bd_addr) {		hci::AddressWithType Btm::GetAddressAndType(const RawAddress& bd_addr) {
	tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(bd_addr);		tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(bd_addr);
	if (p_dev_rec != NULL && p_dev_rec->device_type & BT_DEVICE_TYPE_BLE) {		if (p_dev_rec != NULL && p_dev_rec->device_type & BT_DEVICE_TYPE_BLE) {
	if (!p_dev_rec->ble.identity_address_with_type.bda.IsEmpty()) {		if (!p_dev_rec->ble.identity_address_with_type.bda.IsEmpty()) {
	return p_dev_rec->ble.identity_address_with_type.type;		return ToAddressWithType(p_dev_rec->ble.identity_address_with_type.bda,
			p_dev_rec->ble.identity_address_with_type.type);
	} else {		} else {
	return p_dev_rec->ble.ble_addr_type;		return ToAddressWithType(p_dev_rec->ble.pseudo_addr,
			p_dev_rec->ble.ble_addr_type);
	}		}
	}		}
	if (le_address_type_cache_.count(bd_addr) == 0) {
	LOG(ERROR) << "Unknown bd_addr. Use public address";		LOG(ERROR) << "Unknown bd_addr. Use public address";
	return BLE_ADDR_PUBLIC;		return ToAddressWithType(bd_addr, BLE_ADDR_PUBLIC);
	}
	return le_address_type_cache_[bd_addr];
	}

	void Btm::StoreAddressType(const RawAddress& bd_addr, tBLE_ADDR_TYPE type) {
	store_le_address_type(bd_addr, type);
	}		}

	void Btm::Register_HACK_SetScoDisconnectCallback(		void Btm::Register_HACK_SetScoDisconnectCallback(

system/main/shim/btm.h

+1 −6

Original line number	Original line	Diff line number	Diff line
	@@ -210,12 +210,7 @@ class Btm {
	void Register_HACK_SetScoDisconnectCallback(		void Register_HACK_SetScoDisconnectCallback(
	HACK_ScoDisconnectCallback callback);		HACK_ScoDisconnectCallback callback);

	static tBLE_ADDR_TYPE GetAddressType(const RawAddress& bd_addr);		static hci::AddressWithType GetAddressAndType(const RawAddress& bd_addr);

	// Store the address type from advertising report or connection complete
	// packet.
	// TODO(b/161319293): Obtain from storage
	static void StoreAddressType(const RawAddress& bd_addr, tBLE_ADDR_TYPE type);

	private:		private:
	os::Alarm scanning_timer_;		os::Alarm scanning_timer_;

system/main/shim/l2c_api.cc

+88 −25

Original line number	Original line	Diff line number	Diff line
	@@ -262,6 +262,24 @@ struct ClassicDynamicChannelHelper {
	return true;		return true;
	}		}

			void FlushChannel(uint16_t cid) {
			auto buffer = channel_enqueue_buffer_.find(cid);
			if (buffer == channel_enqueue_buffer_.end()) {
			LOG_ERROR("Channel is not open");
			return;
			}
			buffer->second->Clear();
			}

			uint16_t GetNumBufferedPackets(uint16_t cid) {
			auto buffer = channel_enqueue_buffer_.find(cid);
			if (buffer == channel_enqueue_buffer_.end()) {
			LOG_ERROR("Channel is not open");
			return 0;
			}
			return buffer->second->Size();
			}

	std::unordered_map<uint16_t, std::unique_ptr<classic::DynamicChannel>>		std::unordered_map<uint16_t, std::unique_ptr<classic::DynamicChannel>>
	channels_;		channels_;
	std::unordered_map<uint16_t, std::unique_ptr<bluetooth::os::EnqueueBuffer<		std::unordered_map<uint16_t, std::unique_ptr<bluetooth::os::EnqueueBuffer<
	@@ -496,13 +514,16 @@ bluetooth::l2cap::classic::SecurityInterface* security_interface_ = nullptr;

	struct LeLinkPropertyListenerShim		struct LeLinkPropertyListenerShim
	: public bluetooth::l2cap::le::LinkPropertyListener {		: public bluetooth::l2cap::le::LinkPropertyListener {
	std::unordered_map<hci::Address, uint16_t> address_to_handle_;		struct ConnectionInfo {
	std::unordered_map<hci::Address, hci::Role> address_to_role_;		uint16_t handle;
			hci::Role role;
			AddressWithType address_with_type;
			};
			std::unordered_map<hci::Address, ConnectionInfo> info_;

	void OnLinkConnected(hci::AddressWithType remote, uint16_t handle,		void OnLinkConnected(AddressWithType remote, uint16_t handle,
	hci::Role role) override {		hci::Role role) override {
	address_to_handle_[remote.GetAddress()] = handle;		info_[remote.GetAddress()] = {handle, role, remote};
	address_to_role_[remote.GetAddress()] = role;
	btm_ble_connected(ToRawAddress(remote.GetAddress()), handle,		btm_ble_connected(ToRawAddress(remote.GetAddress()), handle,
	HCI_ENCRYPT_MODE_DISABLED, static_cast<uint8_t>(role),		HCI_ENCRYPT_MODE_DISABLED, static_cast<uint8_t>(role),
	static_cast<tBLE_ADDR_TYPE>(remote.GetAddressType()),		static_cast<tBLE_ADDR_TYPE>(remote.GetAddressType()),
	@@ -510,7 +531,7 @@ struct LeLinkPropertyListenerShim
	}		}

	void OnLinkDisconnected(hci::AddressWithType remote) override {		void OnLinkDisconnected(hci::AddressWithType remote) override {
	address_to_handle_.erase(remote.GetAddress());		info_.erase(remote.GetAddress());
	}		}

	void OnReadRemoteVersionInformation(hci::AddressWithType remote,		void OnReadRemoteVersionInformation(hci::AddressWithType remote,
	@@ -530,14 +551,14 @@ struct LeLinkPropertyListenerShim
	uint16_t connection_latency,		uint16_t connection_latency,
	uint16_t supervision_timeout) override {		uint16_t supervision_timeout) override {
	acl_ble_update_event_received(		acl_ble_update_event_received(
	HCI_SUCCESS, address_to_handle_[remote.GetAddress()],		HCI_SUCCESS, info_[remote.GetAddress()].handle, connection_interval,
	connection_interval, connection_latency, supervision_timeout);		connection_latency, supervision_timeout);
	}		}

	void OnPhyUpdate(hci::AddressWithType remote, uint8_t tx_phy,		void OnPhyUpdate(hci::AddressWithType remote, uint8_t tx_phy,
	uint8_t rx_phy) override {		uint8_t rx_phy) override {
	gatt_notify_phy_updated(		gatt_notify_phy_updated(GATT_SUCCESS, info_[remote.GetAddress()].handle,
	GATT_SUCCESS, address_to_handle_[remote.GetAddress()], tx_phy, rx_phy);		tx_phy, rx_phy);
	}		}

	void OnDataLengthChange(hci::AddressWithType remote, uint16_t tx_octets,		void OnDataLengthChange(hci::AddressWithType remote, uint16_t tx_octets,
	@@ -563,7 +584,6 @@ class LeSecurityEnforcementShim
	LOG_ERROR("Received unexpected callback");		LOG_ERROR("Received unexpected callback");
	return;		return;
	}		}

	auto& callback = le_security_enforce_callback_map[counter];		auto& callback = le_security_enforce_callback_map[counter];
	std::move(callback).Invoke(result == BTM_SUCCESS);		std::move(callback).Invoke(result == BTM_SUCCESS);
	le_security_enforce_callback_map.erase(counter);		le_security_enforce_callback_map.erase(counter);
	@@ -864,12 +884,7 @@ struct LeFixedChannelHelper {

	auto address = bluetooth::ToRawAddress(device);		auto address = bluetooth::ToRawAddress(device);

	LOG(ERROR) << __func__ << "!!!!!!!!!!!!!!!!!!" << +cid_
	<< device.ToString();

	(freg_.pL2CA_FixedConn_Cb)(cid_, address, true, 0, BT_TRANSPORT_LE);		(freg_.pL2CA_FixedConn_Cb)(cid_, address, true, 0, BT_TRANSPORT_LE);
	Btm::StoreAddressType(address,
	static_cast<tBLE_ADDR_TYPE>(remote.GetAddressType()));
	}		}

	void on_incoming_data(bluetooth::hci::Address device) {		void on_incoming_data(bluetooth::hci::Address device) {
	@@ -964,7 +979,12 @@ bool L2CA_ConnectFixedChnl(uint16_t cid, const RawAddress& rem_bda) {
	}		}

	auto* helper = &le_fixed_channel_helper_.find(cid)->second;		auto* helper = &le_fixed_channel_helper_.find(cid)->second;
	auto remote = ToAddressWithType(rem_bda, Btm::GetAddressType(rem_bda));		auto remote = Btm::GetAddressAndType(rem_bda);
			auto record =
			le_link_property_listener_shim_.info_.find(ToGdAddress(rem_bda));
			if (record != le_link_property_listener_shim_.info_.end()) {
			remote = record->second.address_with_type;
			}
	LOG(ERROR) << __func__ << remote.ToString();		LOG(ERROR) << __func__ << remote.ToString();
	auto manager = GetL2capLeModule()->GetFixedChannelManager();		auto manager = GetL2capLeModule()->GetFixedChannelManager();
	manager->ConnectServices(		manager->ConnectServices(
	@@ -1123,9 +1143,20 @@ bool L2CA_SetChnlFlushability(uint16_t cid, bool is_flushable) {
	}		}

	uint16_t L2CA_FlushChannel(uint16_t lcid, uint16_t num_to_flush) {		uint16_t L2CA_FlushChannel(uint16_t lcid, uint16_t num_to_flush) {
	LOG_INFO("UNIMPLEMENTED %s", __func__);		auto psm = classic_cid_token_to_channel_map_[lcid];
			if (classic_dynamic_channel_helper_map_.count(psm) == 0) {
			LOG(ERROR) << __func__ << "Not registered psm: " << psm;
	return 0;		return 0;
	}		}
			if (num_to_flush == L2CAP_FLUSH_CHANS_GET) {
			return classic_dynamic_channel_helper_map_[psm]->GetNumBufferedPackets(
			lcid);
			} else {
			classic_dynamic_channel_helper_map_[psm]->FlushChannel(lcid);
			return 1; // Client doesn't care
			}
			// TODO: Implement LE part
			}

	bool L2CA_IsLinkEstablished(const RawAddress& bd_addr,		bool L2CA_IsLinkEstablished(const RawAddress& bd_addr,
	tBT_TRANSPORT transport) {		tBT_TRANSPORT transport) {
	@@ -1137,19 +1168,46 @@ bool L2CA_IsLinkEstablished(const RawAddress& bd_addr,
	}		}

	bool L2CA_IsLeLink(uint16_t acl_handle) {		bool L2CA_IsLeLink(uint16_t acl_handle) {
	for (const auto& entry : le_link_property_listener_shim_.address_to_handle_) {		for (const auto& entry : le_link_property_listener_shim_.info_) {
	if (entry.second == acl_handle) return true;		if (entry.second.handle == acl_handle) return true;
	}		}
	return false;		return false;
	}		}

			void L2CA_ReadConnectionAddr(const RawAddress& pseudo_addr,
			RawAddress& conn_addr, uint8_t* p_addr_type) {
			auto* helper = &le_fixed_channel_helper_.find(kSmpCid)->second;
			auto channel = helper->channels_.find(ToGdAddress(pseudo_addr));
			if (channel == helper->channels_.end() \|\| channel->second == nullptr) {
			LOG(ERROR) << "Channel is not open!";
			return;
			}
			auto local = channel->second->GetLinkOptions()->GetLocalAddress();
			conn_addr = ToRawAddress(local.GetAddress());
			*p_addr_type = static_cast<uint8_t>(local.GetAddressType());
			}

			bool L2CA_ReadRemoteConnectionAddr(const RawAddress& pseudo_addr,
			RawAddress& conn_addr,
			uint8_t* p_addr_type) {
			auto remote = ToGdAddress(pseudo_addr);
			if (le_link_property_listener_shim_.info_.count(remote) == 0) {
			LOG(ERROR) << __func__ << ": Unknown address";
			return false;
			}
			auto info = le_link_property_listener_shim_.info_[remote].address_with_type;
			conn_addr = ToRawAddress(info.GetAddress());
			*p_addr_type = static_cast<tBLE_ADDR_TYPE>(info.GetAddressType());
			return true;
			}

	hci_role_t L2CA_GetBleConnRole(const RawAddress& bd_addr) {		hci_role_t L2CA_GetBleConnRole(const RawAddress& bd_addr) {
	auto remote = ToGdAddress(bd_addr);		auto remote = ToGdAddress(bd_addr);
	if (le_link_property_listener_shim_.address_to_role_.count(remote) == 0) {		if (le_link_property_listener_shim_.info_.count(remote) == 0) {
	return HCI_ROLE_UNKNOWN;		return HCI_ROLE_UNKNOWN;
	}		}
	return static_cast<hci_role_t>(		return static_cast<hci_role_t>(
	le_link_property_listener_shim_.address_to_role_[remote]);		le_link_property_listener_shim_.info_[remote].role);
	}		}

	void L2CA_ConnectForSecurity(const RawAddress& bd_addr) {		void L2CA_ConnectForSecurity(const RawAddress& bd_addr) {
	@@ -1437,8 +1495,13 @@ uint16_t L2CA_ConnectLECocReq(uint16_t psm, const RawAddress& p_bd_addr,
	return 0;		return 0;
	}		}
	uint16_t cid_token = add_le_cid_token_entry(psm);		uint16_t cid_token = add_le_cid_token_entry(psm);
	le_dynamic_channel_helper_map_[psm]->Connect(		auto remote = Btm::GetAddressAndType(p_bd_addr);
	cid_token, ToAddressWithType(p_bd_addr, Btm::GetAddressType(p_bd_addr)));		auto record =
			le_link_property_listener_shim_.info_.find(ToGdAddress(p_bd_addr));
			if (record != le_link_property_listener_shim_.info_.end()) {
			remote = record->second.address_with_type;
			}
			le_dynamic_channel_helper_map_[psm]->Connect(cid_token, remote);
	return cid_token;		return cid_token;
	}		}

system/main/shim/l2c_api.h

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -480,5 +480,11 @@ uint16_t L2CA_GetNumLinks();

	bool L2CA_IsLeLink(uint16_t acl_handle);		bool L2CA_IsLeLink(uint16_t acl_handle);

			void L2CA_ReadConnectionAddr(const RawAddress& pseudo_addr,
			RawAddress& conn_addr, uint8_t* p_addr_type);

			bool L2CA_ReadRemoteConnectionAddr(const RawAddress& pseudo_addr,
			RawAddress& conn_addr, uint8_t* p_addr_type);

	} // namespace shim		} // namespace shim
	} // namespace bluetooth		} // namespace bluetooth