Snap for 8632107 from 6caf60517ec79377a1bdbf01db40ce8c557eeaef to tm-qpr1-release (12f470dc) · Commits · e / os / android_packages_modules_Bluetooth

system/blueberry/facade/hci/le_acl_manager_facade.proto

+13 −3

Original line number	Original line	Diff line number	Diff line
	@@ -6,15 +6,14 @@ import "google/protobuf/empty.proto";
	import "blueberry/facade/common.proto";		import "blueberry/facade/common.proto";

	service LeAclManagerFacade {		service LeAclManagerFacade {
	rpc CreateConnection(blueberry.facade.BluetoothAddressWithType) returns (stream LeConnectionEvent) {}		rpc CreateConnection(CreateConnectionMsg) returns (stream LeConnectionEvent) {}
	rpc CreateBackgroundAndDirectConnection(blueberry.facade.BluetoothAddressWithType)
	returns (stream LeConnectionEvent) {}
	rpc CancelConnection(blueberry.facade.BluetoothAddressWithType) returns (google.protobuf.Empty) {}		rpc CancelConnection(blueberry.facade.BluetoothAddressWithType) returns (google.protobuf.Empty) {}
	rpc Disconnect(LeHandleMsg) returns (google.protobuf.Empty) {}		rpc Disconnect(LeHandleMsg) returns (google.protobuf.Empty) {}
	rpc ConnectionCommand(LeConnectionCommandMsg) returns (google.protobuf.Empty) {}		rpc ConnectionCommand(LeConnectionCommandMsg) returns (google.protobuf.Empty) {}
	rpc SendAclData(LeAclData) returns (google.protobuf.Empty) {}		rpc SendAclData(LeAclData) returns (google.protobuf.Empty) {}
	rpc FetchAclData(LeHandleMsg) returns (stream LeAclData) {}		rpc FetchAclData(LeHandleMsg) returns (stream LeAclData) {}
	rpc FetchIncomingConnection(google.protobuf.Empty) returns (stream LeConnectionEvent) {}		rpc FetchIncomingConnection(google.protobuf.Empty) returns (stream LeConnectionEvent) {}
			rpc AddDeviceToResolvingList(IrkMsg) returns (google.protobuf.Empty) {}
	}		}

	message LeHandleMsg {		message LeHandleMsg {
	@@ -34,3 +33,14 @@ message LeAclData {
	bytes payload = 2;		bytes payload = 2;
	}		}

			message CreateConnectionMsg {
			blueberry.facade.BluetoothAddressWithType peer_address = 1;
			bool is_direct = 2;
			}

			message IrkMsg {
			blueberry.facade.BluetoothAddressWithType peer = 1;
			bytes peer_irk = 2;
			bytes local_irk = 3;
			}

system/blueberry/tests/gd/cert/py_hci.py

+83 −2

Original line number	Original line	Diff line number	Diff line
	@@ -13,6 +13,7 @@
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and		# See the License for the specific language governing permissions and
	# limitations under the License.		# limitations under the License.
			from datetime import timedelta

	from google.protobuf import empty_pb2 as empty_proto		from google.protobuf import empty_pb2 as empty_proto
	from blueberry.tests.gd.cert.event_stream import EventStream		from blueberry.tests.gd.cert.event_stream import EventStream
	@@ -70,6 +71,43 @@ class PyHciAclConnection(IEventStream):
	return self.our_acl_stream.get_event_queue()		return self.our_acl_stream.get_event_queue()


			class PyHciLeAclConnection(IEventStream):

			def __init__(self, handle, acl_stream, device, peer, peer_type, peer_resolvable, local_resolvable):
			self.handle = int(handle)
			self.device = device
			self.peer = peer
			self.peer_type = peer_type
			self.peer_resolvable = peer_resolvable
			self.local_resolvable = local_resolvable
			# todo, handle we got is 0, so doesn't match - fix before enabling filtering
			self.our_acl_stream = FilteringEventStream(acl_stream, None)

			def send(self, pb_flag, b_flag, data):
			acl = AclBuilder(self.handle, pb_flag, b_flag, RawBuilder(data))
			self.device.hci.SendAcl(common.Data(payload=bytes(acl.Serialize())))

			def send_first(self, data):
			self.send(hci_packets.PacketBoundaryFlag.FIRST_AUTOMATICALLY_FLUSHABLE,
			hci_packets.BroadcastFlag.POINT_TO_POINT, bytes(data))

			def send_continuing(self, data):
			self.send(hci_packets.PacketBoundaryFlag.CONTINUING_FRAGMENT, hci_packets.BroadcastFlag.POINT_TO_POINT,
			bytes(data))

			def get_event_queue(self):
			return self.our_acl_stream.get_event_queue()

			def local_resolvable_address(self):
			return self.local_resolvable

			def peer_resolvable_address(self):
			return self.peer_resolvable

			def peer_address(self):
			return self.peer


	class PyHciAdvertisement(object):		class PyHciAdvertisement(object):

	def __init__(self, handle, py_hci):		def __init__(self, handle, py_hci):
	@@ -79,7 +117,7 @@ class PyHciAdvertisement(object):
	def set_data(self, complete_name):		def set_data(self, complete_name):
	data = GapData()		data = GapData()
	data.data_type = GapDataType.COMPLETE_LOCAL_NAME		data.data_type = GapDataType.COMPLETE_LOCAL_NAME
	data.data = list(bytes(complete_name))		data.data = list(complete_name)
	self.py_hci.send_command(		self.py_hci.send_command(
	LeSetExtendedAdvertisingDataBuilder(self.handle, Operation.COMPLETE_ADVERTISEMENT,		LeSetExtendedAdvertisingDataBuilder(self.handle, Operation.COMPLETE_ADVERTISEMENT,
	FragmentPreference.CONTROLLER_SHOULD_NOT, [data]))		FragmentPreference.CONTROLLER_SHOULD_NOT, [data]))
	@@ -87,7 +125,7 @@ class PyHciAdvertisement(object):
	def set_scan_response(self, shortened_name):		def set_scan_response(self, shortened_name):
	data = GapData()		data = GapData()
	data.data_type = GapDataType.SHORTENED_LOCAL_NAME		data.data_type = GapDataType.SHORTENED_LOCAL_NAME
	data.data = list(bytes(shortened_name))		data.data = list(shortened_name)
	self.py_hci.send_command(		self.py_hci.send_command(
	LeSetExtendedAdvertisingScanResponseBuilder(self.handle, Operation.COMPLETE_ADVERTISEMENT,		LeSetExtendedAdvertisingScanResponseBuilder(self.handle, Operation.COMPLETE_ADVERTISEMENT,
	FragmentPreference.CONTROLLER_SHOULD_NOT, [data]))		FragmentPreference.CONTROLLER_SHOULD_NOT, [data]))
	@@ -121,6 +159,7 @@ class PyHci(Closable):
	self.register_for_events(hci_packets.EventCode.ROLE_CHANGE, hci_packets.EventCode.CONNECTION_REQUEST,		self.register_for_events(hci_packets.EventCode.ROLE_CHANGE, hci_packets.EventCode.CONNECTION_REQUEST,
	hci_packets.EventCode.CONNECTION_COMPLETE,		hci_packets.EventCode.CONNECTION_COMPLETE,
	hci_packets.EventCode.CONNECTION_PACKET_TYPE_CHANGED)		hci_packets.EventCode.CONNECTION_PACKET_TYPE_CHANGED)
			self.register_for_le_events(hci_packets.SubeventCode.ENHANCED_CONNECTION_COMPLETE)
	self.acl_stream = EventStream(self.device.hci.StreamAcl(empty_proto.Empty()))		self.acl_stream = EventStream(self.device.hci.StreamAcl(empty_proto.Empty()))

	def close(self):		def close(self):
	@@ -187,6 +226,48 @@ class PyHci(Closable):
	raise Exception("Please construct '%s' with acl_streaming=True!" % self.__class__.__name__)		raise Exception("Please construct '%s' with acl_streaming=True!" % self.__class__.__name__)
	return PyHciAclConnection(handle, self.acl_stream, self.device)		return PyHciAclConnection(handle, self.acl_stream, self.device)

			def set_random_le_address(self, addr):
			self.send_command(hci_packets.LeSetRandomAddressBuilder(addr))
			assertThat(self.event_stream).emits(HciMatchers.CommandComplete(OpCode.LE_SET_RANDOM_ADDRESS))

			def initiate_le_connection(self, remote_addr):
			phy_scan_params = hci_packets.LeCreateConnPhyScanParameters()
			phy_scan_params.scan_interval = 0x60
			phy_scan_params.scan_window = 0x30
			phy_scan_params.conn_interval_min = 0x18
			phy_scan_params.conn_interval_max = 0x28
			phy_scan_params.conn_latency = 0
			phy_scan_params.supervision_timeout = 0x1f4
			phy_scan_params.min_ce_length = 0
			phy_scan_params.max_ce_length = 0
			self.send_command(
			hci_packets.LeExtendedCreateConnectionBuilder(
			hci_packets.InitiatorFilterPolicy.USE_PEER_ADDRESS, hci_packets.OwnAddressType.RANDOM_DEVICE_ADDRESS,
			hci_packets.AddressType.RANDOM_DEVICE_ADDRESS, remote_addr, 1, [phy_scan_params]))
			assertThat(self.event_stream).emits(HciMatchers.CommandStatus(OpCode.LE_EXTENDED_CREATE_CONNECTION))

			def incoming_le_connection(self):
			connection_complete = HciCaptures.LeConnectionCompleteCapture()
			assertThat(self.le_event_stream).emits(connection_complete)

			handle = connection_complete.get().GetConnectionHandle()
			peer = connection_complete.get().GetPeerAddress()
			peer_type = connection_complete.get().GetPeerAddressType()
			local_resolvable = connection_complete.get().GetLocalResolvablePrivateAddress()
			peer_resolvable = connection_complete.get().GetPeerResolvablePrivateAddress()
			if self.acl_stream is None:
			raise Exception("Please construct '%s' with acl_streaming=True!" % self.__class__.__name__)
			return PyHciLeAclConnection(handle, self.acl_stream, self.device, peer, peer_type, peer_resolvable,
			local_resolvable)

			def incoming_le_connection_fails(self):
			connection_complete = HciCaptures.LeConnectionCompleteCapture()
			assertThat(self.le_event_stream).emitsNone(connection_complete, timeout=timedelta(seconds=5))

			def add_device_to_resolving_list(self, peer_address_type, peer_address, peer_irk, local_irk):
			self.send_command(
			hci_packets.LeAddDeviceToResolvingListBuilder(peer_address_type, peer_address, peer_irk, local_irk))

	def create_advertisement(self,		def create_advertisement(self,
	handle,		handle,
	own_address,		own_address,

system/blueberry/tests/gd/cert/py_le_acl_manager.py

+9 −12

Original line number	Original line	Diff line number	Diff line
	@@ -29,12 +29,13 @@ from blueberry.facade.hci import le_acl_manager_facade_pb2 as le_acl_manager_fac

	class PyLeAclManagerAclConnection(IEventStream, Closable):		class PyLeAclManagerAclConnection(IEventStream, Closable):

	def __init__(self, le_acl_manager, address, remote_addr, handle, event_stream):		def __init__(self, le_acl_manager, address, remote_addr, remote_addr_type, handle, event_stream):
	"""		"""
	An abstract representation for an LE ACL connection in GD certification test		An abstract representation for an LE ACL connection in GD certification test
	:param le_acl_manager: The LeAclManager from this GD device		:param le_acl_manager: The LeAclManager from this GD device
	:param address: The local device address		:param address: The local device address
	:param remote_addr: Remote device address		:param remote_addr: Remote device address
			:param remote_addr_type: Remote device address type
	:param handle: Connection handle		:param handle: Connection handle
	:param event_stream: The connection event stream for this connection		:param event_stream: The connection event stream for this connection
	"""		"""
	@@ -46,6 +47,7 @@ class PyLeAclManagerAclConnection(IEventStream, Closable):
	self.acl_stream = EventStream(		self.acl_stream = EventStream(
	self.le_acl_manager.FetchAclData(le_acl_manager_facade.LeHandleMsg(handle=self.handle)))		self.le_acl_manager.FetchAclData(le_acl_manager_facade.LeHandleMsg(handle=self.handle)))
	self.remote_address = remote_addr		self.remote_address = remote_addr
			self.remote_address_type = remote_addr_type
	self.own_address = address		self.own_address = address
	self.disconnect_reason = None		self.disconnect_reason = None

	@@ -113,18 +115,11 @@ class PyLeAclManager(Closable):
	safeClose(pair[0])		safeClose(pair[0])
	self.le_acl_manager.CancelConnection(pair[1])		self.le_acl_manager.CancelConnection(pair[1])

	def initiate_connection(self, remote_addr):		def initiate_connection(self, remote_addr, is_direct=True):
	assertThat(self.next_token in self.outgoing_connection_event_streams).isFalse()		assertThat(self.next_token in self.outgoing_connection_event_streams).isFalse()
			create_connection_msg = le_acl_manager_facade.CreateConnectionMsg(peer_address=remote_addr, is_direct=is_direct)
	self.outgoing_connection_event_streams[self.next_token] = EventStream(		self.outgoing_connection_event_streams[self.next_token] = EventStream(
	self.le_acl_manager.CreateConnection(remote_addr)), remote_addr		self.le_acl_manager.CreateConnection(create_connection_msg)), remote_addr
	token = self.next_token
	self.next_token += 1
	return token

	def initiate_background_and_direct_connection(self, remote_addr):
	assertThat(self.next_token in self.outgoing_connection_event_streams).isFalse()
	self.outgoing_connection_event_streams[self.next_token] = EventStream(
	self.le_acl_manager.CreateBackgroundAndDirectConnection(remote_addr)), remote_addr
	token = self.next_token		token = self.next_token
	self.next_token += 1		self.next_token += 1
	return token		return token
	@@ -135,11 +130,13 @@ class PyLeAclManager(Closable):
	complete = connection_complete.get()		complete = connection_complete.get()
	handle = complete.GetConnectionHandle()		handle = complete.GetConnectionHandle()
	remote = complete.GetPeerAddress()		remote = complete.GetPeerAddress()
			remote_address_type = complete.GetPeerAddressType()
	if complete.GetSubeventCode() == hci_packets.SubeventCode.ENHANCED_CONNECTION_COMPLETE:		if complete.GetSubeventCode() == hci_packets.SubeventCode.ENHANCED_CONNECTION_COMPLETE:
	address = complete.GetLocalResolvablePrivateAddress()		address = complete.GetLocalResolvablePrivateAddress()
	else:		else:
	address = None		address = None
	connection = PyLeAclManagerAclConnection(self.le_acl_manager, address, remote, handle, event_stream)		connection = PyLeAclManagerAclConnection(self.le_acl_manager, address, remote, remote_address_type, handle,
			event_stream)
	self.active_connections.append(connection)		self.active_connections.append(connection)
	return connection		return connection

system/blueberry/tests/gd/hci/direct_hci_test.py

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -205,7 +205,6 @@ class DirectHciTest(gd_base_test.GdBaseTestClass):

	def test_le_connection_dut_advertises(self):		def test_le_connection_dut_advertises(self):
	self.dut_hci.register_for_le_events(SubeventCode.CONNECTION_COMPLETE, SubeventCode.ADVERTISING_SET_TERMINATED,		self.dut_hci.register_for_le_events(SubeventCode.CONNECTION_COMPLETE, SubeventCode.ADVERTISING_SET_TERMINATED,
	SubeventCode.ENHANCED_CONNECTION_COMPLETE,
	SubeventCode.READ_REMOTE_FEATURES_COMPLETE)		SubeventCode.READ_REMOTE_FEATURES_COMPLETE)
	# Cert Connects		# Cert Connects
	self.cert_hal.unmask_event(EventCode.LE_META_EVENT)		self.cert_hal.unmask_event(EventCode.LE_META_EVENT)
	@@ -239,7 +238,6 @@ class DirectHciTest(gd_base_test.GdBaseTestClass):
	lambda packet: logging.debug(packet.payload) or b'SomeMoreAclData' in packet.payload)		lambda packet: logging.debug(packet.payload) or b'SomeMoreAclData' in packet.payload)

	def test_le_filter_accept_list_connection_cert_advertises(self):		def test_le_filter_accept_list_connection_cert_advertises(self):
	self.dut_hci.register_for_le_events(SubeventCode.CONNECTION_COMPLETE, SubeventCode.ENHANCED_CONNECTION_COMPLETE)
	# DUT Connects		# DUT Connects
	self.dut_hci.send_command(LeSetRandomAddressBuilder('0D:05:04:03:02:01'))		self.dut_hci.send_command(LeSetRandomAddressBuilder('0D:05:04:03:02:01'))
	self.dut_hci.send_command(		self.dut_hci.send_command(

system/blueberry/tests/gd/hci/le_acl_manager_test.py

+243 −196

File changed.

Preview size limit exceeded, changes collapsed.