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

Commit d781bc77 authored by Zach Johnson's avatar Zach Johnson
Browse files

Simplify HAL protos 

* It's the HciHal, so HCI on functions and structs is redundant.
* FetchXYZ returns a stream, so rename to StreamXYZ
* Event & Commands are less about packets, so drop packet from the
struct names

Bug: 171749953
Tag: #gd-refactor
Test: gd/cert/run --rhost
Change-Id: I62fb098ee6a5a4805ad0667101c7de5a3368c4f2
parent fe81cb57

system/gd/cert/py_hal.py

+4 −4
Original line number Diff line number Diff line
@@ -26,8 +26,8 @@ class PyHal(Closable): 
    def __init__(self, device):

        self.device = device



        self.hci_event_stream = EventStream(self.device.hal.FetchHciEvent(empty_proto.Empty()))

        self.acl_stream = EventStream(self.device.hal.FetchHciAcl(empty_proto.Empty()))

        self.hci_event_stream = EventStream(self.device.hal.StreamEvents(empty_proto.Empty()))

        self.acl_stream = EventStream(self.device.hal.StreamAcl(empty_proto.Empty()))



        # We don't deal with SCO for now
@@ -42,7 +42,7 @@ class PyHal(Closable): 
        return self.acl_stream



    def send_hci_command(self, command):

        self.device.hal.SendHciCommand(hal_facade.HciCommandPacket(payload=bytes(command)))

        self.device.hal.SendCommand(hal_facade.Command(payload=bytes(command)))



    def send_acl(self, acl):

        self.device.hal.SendHciAcl(hal_facade.HciAclPacket(payload=bytes(acl)))
 
        self.device.hal.SendAcl(hal_facade.AclPacket(payload=bytes(acl)))

system/gd/hal/cert/simple_hal_test.py

+15 −21
Original line number Diff line number Diff line
@@ -40,9 +40,7 @@ class SimpleHalTest(GdBaseTestClass): 
        self.send_cert_hci_command(hci_packets.ResetBuilder())



    def send_cert_hci_command(self, command):

        self.cert.hal.SendHciCommand(

            hal_facade_pb2.HciCommandPacket(payload=bytes(command.Serialize())),

            timeout=_GRPC_TIMEOUT)

        self.cert.hal.SendCommand(hal_facade_pb2.Command(payload=bytes(command.Serialize())), timeout=_GRPC_TIMEOUT)



    def send_cert_acl_data(self, handle, pb_flag, b_flag, acl):

        lower = handle & 0xff
@@ -52,12 +50,10 @@ class SimpleHalTest(GdBaseTestClass): 
        lower_length = len(acl) & 0xff

        upper_length = (len(acl) & 0xff00) >> 8

        concatenated = bytes([lower, upper, lower_length, upper_length] + list(acl))

        self.cert.hal.SendHciAcl(hal_facade_pb2.HciAclPacket(payload=concatenated))

        self.cert.hal.SendAcl(hal_facade_pb2.AclPacket(payload=concatenated))



    def send_dut_hci_command(self, command):

        self.dut.hal.SendHciCommand(

            hal_facade_pb2.HciCommandPacket(payload=bytes(command.Serialize())),

            timeout=_GRPC_TIMEOUT)

        self.dut.hal.SendCommand(hal_facade_pb2.Command(payload=bytes(command.Serialize())), timeout=_GRPC_TIMEOUT)



    def send_dut_acl_data(self, handle, pb_flag, b_flag, acl):

        lower = handle & 0xff
@@ -67,16 +63,14 @@ class SimpleHalTest(GdBaseTestClass): 
        lower_length = len(acl) & 0xff

        upper_length = (len(acl) & 0xff00) >> 8

        concatenated = bytes([lower, upper, lower_length, upper_length] + list(acl))

        self.dut.hal.SendHciAcl(

            hal_facade_pb2.HciAclPacket(payload=concatenated),

            timeout=_GRPC_TIMEOUT)

        self.dut.hal.SendAcl(hal_facade_pb2.AclPacket(payload=concatenated), timeout=_GRPC_TIMEOUT)



    def test_none_event(self):

        with EventStream(self.dut.hal.FetchHciEvent(empty_pb2.Empty())) as hci_event_stream:

        with EventStream(self.dut.hal.StreamEvents(empty_pb2.Empty())) as hci_event_stream:

            assertThat(hci_event_stream).emitsNone(timeout=timedelta(seconds=1))



    def test_fetch_hci_event(self):

        with EventStream(self.dut.hal.FetchHciEvent(empty_pb2.Empty())) as hci_event_stream:

        with EventStream(self.dut.hal.StreamEvents(empty_pb2.Empty())) as hci_event_stream:



            self.send_dut_hci_command(

                hci_packets.LeAddDeviceToConnectListBuilder(hci_packets.ConnectListAddressType.RANDOM,
@@ -86,7 +80,7 @@ class SimpleHalTest(GdBaseTestClass): 
            assertThat(hci_event_stream).emits(lambda packet: bytes(event.Serialize()) in packet.payload)



    def test_loopback_hci_command(self):

        with EventStream(self.dut.hal.FetchHciEvent(empty_pb2.Empty())) as hci_event_stream:

        with EventStream(self.dut.hal.StreamEvents(empty_pb2.Empty())) as hci_event_stream:



            self.send_dut_hci_command(hci_packets.WriteLoopbackModeBuilder(hci_packets.LoopbackMode.ENABLE_LOCAL))
@@ -97,7 +91,7 @@ class SimpleHalTest(GdBaseTestClass): 
            assertThat(hci_event_stream).emits(lambda packet: bytes(command.Serialize()) in packet.payload)



    def test_inquiry_from_dut(self):

        with EventStream(self.dut.hal.FetchHciEvent(empty_pb2.Empty())) as hci_event_stream:

        with EventStream(self.dut.hal.StreamEvents(empty_pb2.Empty())) as hci_event_stream:



            self.send_cert_hci_command(hci_packets.WriteScanEnableBuilder(hci_packets.ScanEnable.INQUIRY_AND_PAGE_SCAN))

            lap = hci_packets.Lap()
@@ -109,7 +103,7 @@ class SimpleHalTest(GdBaseTestClass): 
                                              )



    def test_le_ad_scan_cert_advertises(self):

        with EventStream(self.dut.hal.FetchHciEvent(empty_pb2.Empty())) as hci_event_stream:

        with EventStream(self.dut.hal.StreamEvents(empty_pb2.Empty())) as hci_event_stream:



            # DUT scans

            self.send_dut_hci_command(hci_packets.LeSetRandomAddressBuilder('0D:05:04:03:02:01'))
@@ -174,10 +168,10 @@ class SimpleHalTest(GdBaseTestClass): 
                                                           hci_packets.FilterDuplicates.DISABLED, 0, 0))



    def test_le_connection_dut_advertises(self):

        with EventStream(self.dut.hal.FetchHciEvent(empty_pb2.Empty())) as hci_event_stream, \

                EventStream(self.cert.hal.FetchHciEvent(empty_pb2.Empty())) as cert_hci_event_stream, \

                EventStream(self.dut.hal.FetchHciAcl(empty_pb2.Empty())) as acl_data_stream, \

                EventStream(self.cert.hal.FetchHciAcl(empty_pb2.Empty())) as cert_acl_data_stream:

        with EventStream(self.dut.hal.StreamEvents(empty_pb2.Empty())) as hci_event_stream, \

                EventStream(self.cert.hal.StreamEvents(empty_pb2.Empty())) as cert_hci_event_stream, \

                EventStream(self.dut.hal.StreamAcl(empty_pb2.Empty())) as acl_data_stream, \

                EventStream(self.cert.hal.StreamAcl(empty_pb2.Empty())) as cert_acl_data_stream:



            # Cert Connects

            self.send_cert_hci_command(hci_packets.LeSetRandomAddressBuilder('0C:05:04:03:02:01'))
@@ -271,8 +265,8 @@ class SimpleHalTest(GdBaseTestClass): 
            assertThat(acl_data_stream).emits(lambda packet: b'SomeMoreAclData' in packet.payload)



    def test_le_connect_list_connection_cert_advertises(self):

        with EventStream(self.dut.hal.FetchHciEvent(empty_pb2.Empty())) as hci_event_stream, \

            EventStream(self.cert.hal.FetchHciEvent(empty_pb2.Empty())) as cert_hci_event_stream:

        with EventStream(self.dut.hal.StreamEvents(empty_pb2.Empty())) as hci_event_stream, \

            EventStream(self.cert.hal.StreamEvents(empty_pb2.Empty())) as cert_hci_event_stream:



            # DUT Connects

            self.send_dut_hci_command(hci_packets.LeSetRandomAddressBuilder('0D:05:04:03:02:01'))

system/gd/hal/facade.cc

+22 −22
Original line number Diff line number Diff line
@@ -40,9 +40,9 @@ class HciHalFacadeService : public HciHalFacade::Service, public ::bluetooth::ha 
    hal_->unregisterIncomingPacketCallback();

  }



  ::grpc::Status SendHciCommand(

  ::grpc::Status SendCommand(

      ::grpc::ServerContext* context,

      const ::bluetooth::hal::HciCommandPacket* request,

      const ::bluetooth::hal::Command* request,

      ::google::protobuf::Empty* response) override {

    std::unique_lock<std::mutex> lock(mutex_);

    can_send_hci_command_ = false;
@@ -54,55 +54,55 @@ class HciHalFacadeService : public HciHalFacade::Service, public ::bluetooth::ha 
    return ::grpc::Status::OK;

  }



  ::grpc::Status SendHciAcl(

  ::grpc::Status SendAcl(

      ::grpc::ServerContext* context,

      const ::bluetooth::hal::HciAclPacket* request,

      const ::bluetooth::hal::AclPacket* request,

      ::google::protobuf::Empty* response) override {

    std::string req_string = request->payload();

    hal_->sendAclData(std::vector<uint8_t>(req_string.begin(), req_string.end()));

    return ::grpc::Status::OK;

  }



  ::grpc::Status SendHciSco(

  ::grpc::Status SendSco(

      ::grpc::ServerContext* context,

      const ::bluetooth::hal::HciScoPacket* request,

      const ::bluetooth::hal::ScoPacket* request,

      ::google::protobuf::Empty* response) override {

    std::string req_string = request->payload();

    hal_->sendScoData(std::vector<uint8_t>(req_string.begin(), req_string.end()));

    return ::grpc::Status::OK;

  }



  ::grpc::Status FetchHciEvent(

  ::grpc::Status StreamEvents(

      ::grpc::ServerContext* context,

      const ::google::protobuf::Empty* request,

      ::grpc::ServerWriter<HciEventPacket>* writer) override {

      ::grpc::ServerWriter<Event>* writer) override {

    return pending_hci_events_.RunLoop(context, writer);

  };



  ::grpc::Status FetchHciAcl(

  ::grpc::Status StreamAcl(

      ::grpc::ServerContext* context,

      const ::google::protobuf::Empty* request,

      ::grpc::ServerWriter<HciAclPacket>* writer) override {

      ::grpc::ServerWriter<AclPacket>* writer) override {

    return pending_acl_events_.RunLoop(context, writer);

  };



  ::grpc::Status FetchHciSco(

  ::grpc::Status StreamSco(

      ::grpc::ServerContext* context,

      const ::google::protobuf::Empty* request,

      ::grpc::ServerWriter<HciScoPacket>* writer) override {

      ::grpc::ServerWriter<ScoPacket>* writer) override {

    return pending_sco_events_.RunLoop(context, writer);

  };



  ::grpc::Status FetchHciIso(

  ::grpc::Status StreamIso(

      ::grpc::ServerContext* context,

      const ::google::protobuf::Empty* request,

      ::grpc::ServerWriter<HciIsoPacket>* writer) override {

      ::grpc::ServerWriter<IsoPacket>* writer) override {

    return pending_iso_events_.RunLoop(context, writer);

  };



  void hciEventReceived(bluetooth::hal::HciPacket event) override {

    {

      HciEventPacket response;

      Event response;

      response.set_payload(std::string(event.begin(), event.end()));

      pending_hci_events_.OnIncomingEvent(std::move(response));

    }
@@ -111,19 +111,19 @@ class HciHalFacadeService : public HciHalFacade::Service, public ::bluetooth::ha 
  }



  void aclDataReceived(bluetooth::hal::HciPacket data) override {

    HciAclPacket response;

    AclPacket response;

    response.set_payload(std::string(data.begin(), data.end()));

    pending_acl_events_.OnIncomingEvent(std::move(response));

  }



  void scoDataReceived(bluetooth::hal::HciPacket data) override {

    HciScoPacket response;

    ScoPacket response;

    response.set_payload(std::string(data.begin(), data.end()));

    pending_sco_events_.OnIncomingEvent(std::move(response));

  }



  void isoDataReceived(bluetooth::hal::HciPacket data) override {

    HciIsoPacket response;

    IsoPacket response;

    response.set_payload(std::string(data.begin(), data.end()));

    pending_iso_events_.OnIncomingEvent(std::move(response));

  }
@@ -133,10 +133,10 @@ class HciHalFacadeService : public HciHalFacade::Service, public ::bluetooth::ha 
  bool can_send_hci_command_ = true;

  mutable std::mutex mutex_;

  std::condition_variable cv_;

  ::bluetooth::grpc::GrpcEventQueue<HciEventPacket> pending_hci_events_{"FetchHciEvent"};

  ::bluetooth::grpc::GrpcEventQueue<HciAclPacket> pending_acl_events_{"FetchHciAcl"};

  ::bluetooth::grpc::GrpcEventQueue<HciScoPacket> pending_sco_events_{"FetchHciSco"};

  ::bluetooth::grpc::GrpcEventQueue<HciIsoPacket> pending_iso_events_{"FetchHciIso"};

  ::bluetooth::grpc::GrpcEventQueue<Event> pending_hci_events_{"StreamEvents"};

  ::bluetooth::grpc::GrpcEventQueue<AclPacket> pending_acl_events_{"StreamAcl"};

  ::bluetooth::grpc::GrpcEventQueue<ScoPacket> pending_sco_events_{"StreamSco"};

  ::bluetooth::grpc::GrpcEventQueue<IsoPacket> pending_iso_events_{"StreamIso"};

};



void HciHalFacadeModule::ListDependencies(ModuleList* list) {

system/gd/hal/facade.proto

+14 −14
Original line number Diff line number Diff line
@@ -5,33 +5,33 @@ package bluetooth.hal; 
import "google/protobuf/empty.proto";



service HciHalFacade {

  rpc SendHciCommand(HciCommandPacket) returns (google.protobuf.Empty) {}

  rpc SendHciAcl(HciAclPacket) returns (google.protobuf.Empty) {}

  rpc SendHciSco(HciScoPacket) returns (google.protobuf.Empty) {}

  rpc SendHciIso(HciIsoPacket) returns (google.protobuf.Empty) {}



  rpc FetchHciEvent(google.protobuf.Empty) returns (stream HciEventPacket) {}

  rpc FetchHciAcl(google.protobuf.Empty) returns (stream HciAclPacket) {}

  rpc FetchHciSco(google.protobuf.Empty) returns (stream HciScoPacket) {}

  rpc FetchHciIso(google.protobuf.Empty) returns (stream HciIsoPacket) {}

  rpc SendCommand(Command) returns (google.protobuf.Empty) {}

  rpc SendAcl(AclPacket) returns (google.protobuf.Empty) {}

  rpc SendSco(ScoPacket) returns (google.protobuf.Empty) {}

  rpc SendIso(IsoPacket) returns (google.protobuf.Empty) {}



  rpc StreamEvents(google.protobuf.Empty) returns (stream Event) {}

  rpc StreamAcl(google.protobuf.Empty) returns (stream AclPacket) {}

  rpc StreamSco(google.protobuf.Empty) returns (stream ScoPacket) {}

  rpc StreamIso(google.protobuf.Empty) returns (stream IsoPacket) {}

}



message HciEventPacket {

message Event {

  bytes payload = 1;

}



message HciCommandPacket {

message Command {

  bytes payload = 1;

}



message HciAclPacket {

message AclPacket {

  bytes payload = 1;

}



message HciScoPacket {

message ScoPacket {

  bytes payload = 1;

}



message HciIsoPacket {

message IsoPacket {

  bytes payload = 1;

}

system/gd/rust/hal/src/facade.rs

+13 −24
Original line number Diff line number Diff line 
//! BT HCI HAL facade





use bt_hal_proto::facade_grpc::{create_hci_hal_facade, HciHalFacade};

use bt_hal_proto::facade::*;

use bt_hal_proto::empty::Empty;

use bt_hal_proto::facade::*;

use bt_hal_proto::facade_grpc::{create_hci_hal_facade, HciHalFacade};



use tokio::runtime::Runtime;
@@ -25,59 +24,49 @@ impl HciHalFacadeService { 
}



impl HciHalFacade for HciHalFacadeService {

    fn send_hci_command(

        &mut self,

        _ctx: RpcContext<'_>,

        _cmd: HciCommandPacket,

        _sink: UnarySink<Empty>,

    ) {

    fn send_command(&mut self, _ctx: RpcContext<'_>, _cmd: Command, _sink: UnarySink<Empty>) {

        unimplemented!()

    }



    fn send_hci_acl(&mut self, _ctx: RpcContext<'_>, _acl: HciAclPacket, _sink: UnarySink<Empty>) {

    fn send_acl(&mut self, _ctx: RpcContext<'_>, _acl: AclPacket, _sink: UnarySink<Empty>) {

        unimplemented!()

    }



    fn send_hci_sco(&mut self, _ctx: RpcContext<'_>, _sco: HciScoPacket, _sink: UnarySink<Empty>) {

    fn send_sco(&mut self, _ctx: RpcContext<'_>, _sco: ScoPacket, _sink: UnarySink<Empty>) {

        unimplemented!()

    }



    fn send_hci_iso(&mut self, _ctx: RpcContext<'_>, _iso: HciIsoPacket, _sink: UnarySink<Empty>) {

    fn send_iso(&mut self, _ctx: RpcContext<'_>, _iso: IsoPacket, _sink: UnarySink<Empty>) {

        unimplemented!()

    }



    fn fetch_hci_event(

        &mut self,

        _ctx: RpcContext<'_>,

        _: Empty,

        _sink: ServerStreamingSink<HciEventPacket>,

    ) {

    fn stream_events(&mut self, _ctx: RpcContext<'_>, _: Empty, _sink: ServerStreamingSink<Event>) {

        unimplemented!()

    }



    fn fetch_hci_acl(

    fn stream_acl(

        &mut self,

        _ctx: RpcContext<'_>,

        _: Empty,

        _sink: ServerStreamingSink<HciAclPacket>,

        _sink: ServerStreamingSink<AclPacket>,

    ) {

        unimplemented!()

    }



    fn fetch_hci_sco(

    fn stream_sco(

        &mut self,

        _ctx: RpcContext<'_>,

        _: Empty,

        _sink: ServerStreamingSink<HciScoPacket>,

        _sink: ServerStreamingSink<ScoPacket>,

    ) {

        unimplemented!()

    }



    fn fetch_hci_iso(

    fn stream_iso(

        &mut self,

        _ctx: RpcContext<'_>,

        _: Empty,

        _sink: ServerStreamingSink<HciIsoPacket>,

        _sink: ServerStreamingSink<IsoPacket>,

    ) {

        unimplemented!()

    }