Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 12f470dc authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 8632107 from 6caf6051 to tm-qpr1-release

Change-Id: I8a10af7adc698216421517585f5ccb9eb36ae520
parents 357e7adb 6caf6051
Loading
Loading
Loading
Loading
+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;
}
+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,
+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


+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(
+243 −196

File changed.

Preview size limit exceeded, changes collapsed.

Loading