From f0a4348cb1e9f050c5b8b876127e3dcc724019da Mon Sep 17 00:00:00 2001 From: Zach Johnson Date: Tue, 22 Dec 2020 15:02:04 -0800 Subject: [PATCH] rusty-gd: shim & facade are very similar, start sharing code Bug: 171749953 Tag: #gd-refactor Test: gd/cert/run --rhost SimpleHalTest Change-Id: I548ee2ad36adc109f48d9572826940ad5eee978e --- gd/rust/hci/src/facade.rs | 56 +++++++++++++++++++++++++++-------------------- gd/rust/shim/src/hci.rs | 51 ++++++++++-------------------------------- gd/rust/shim/src/stack.rs | 4 +--- 3 files changed, 45 insertions(+), 66 deletions(-) diff --git a/gd/rust/hci/src/facade.rs b/gd/rust/hci/src/facade.rs index 2b18557ff..31e3fa87d 100644 --- a/gd/rust/hci/src/facade.rs +++ b/gd/rust/hci/src/facade.rs @@ -33,31 +33,47 @@ async fn provide_facade( acl: AclHal, rt: Arc, ) -> HciFacadeService { - let (from_hci_evt_tx, to_grpc_evt_rx) = channel::(10); - let (from_hci_le_evt_tx, to_grpc_le_evt_rx) = channel::(10); + let (evt_tx, evt_rx) = channel::(10); + let (le_evt_tx, le_evt_rx) = channel::(10); HciFacadeService { commands, events, acl, rt, - from_hci_evt_tx, - to_grpc_evt_rx: Arc::new(Mutex::new(to_grpc_evt_rx)), - from_hci_le_evt_tx, - to_grpc_le_evt_rx: Arc::new(Mutex::new(to_grpc_le_evt_rx)), + evt_tx, + evt_rx: Arc::new(Mutex::new(evt_rx)), + le_evt_tx, + le_evt_rx: Arc::new(Mutex::new(le_evt_rx)), } } /// HCI layer facade service +#[allow(missing_docs)] #[derive(Clone, Stoppable)] pub struct HciFacadeService { - commands: RawCommandSender, + pub commands: RawCommandSender, events: EventRegistry, - acl: AclHal, + pub acl: AclHal, rt: Arc, - from_hci_evt_tx: Sender, - to_grpc_evt_rx: Arc>>, - from_hci_le_evt_tx: Sender, - to_grpc_le_evt_rx: Arc>>, + evt_tx: Sender, + pub evt_rx: Arc>>, + le_evt_tx: Sender, + pub le_evt_rx: Arc>>, +} + +impl HciFacadeService { + /// Register for the event & plug in the channel to get them back on + pub async fn register_event(&self, code: u32) { + self.events.clone().register(EventCode::from_u32(code).unwrap(), self.evt_tx.clone()).await; + } + + /// Register for the le event & plug in the channel to get them back on + pub async fn register_le_event(&self, code: u32) { + self.events + .clone() + .register_le(SubeventCode::from_u32(code).unwrap(), self.le_evt_tx.clone()) + .await; + } } impl GrpcFacade for HciFacadeService { @@ -75,12 +91,7 @@ impl HciFacade for HciFacadeService { } fn request_event(&mut self, _ctx: RpcContext<'_>, req: EventRequest, sink: UnarySink) { - self.rt.block_on( - self.events.register( - EventCode::from_u32(req.get_code()).unwrap(), - self.from_hci_evt_tx.clone(), - ), - ); + self.rt.block_on(self.register_event(req.get_code())); sink.success(Empty::default()); } @@ -90,10 +101,7 @@ impl HciFacade for HciFacadeService { req: EventRequest, sink: UnarySink, ) { - self.rt.block_on(self.events.register_le( - SubeventCode::from_u32(req.get_code()).unwrap(), - self.from_hci_le_evt_tx.clone(), - )); + self.rt.block_on(self.register_le_event(req.get_code())); sink.success(Empty::default()); } @@ -111,7 +119,7 @@ impl HciFacade for HciFacadeService { _req: Empty, mut resp: ServerStreamingSink, ) { - let evt_rx = self.to_grpc_evt_rx.clone(); + let evt_rx = self.evt_rx.clone(); self.rt.spawn(async move { while let Some(event) = evt_rx.lock().await.recv().await { @@ -128,7 +136,7 @@ impl HciFacade for HciFacadeService { _req: Empty, mut resp: ServerStreamingSink, ) { - let evt_rx = self.to_grpc_le_evt_rx.clone(); + let evt_rx = self.le_evt_rx.clone(); self.rt.spawn(async move { while let Some(event) = evt_rx.lock().await.recv().await { diff --git a/gd/rust/shim/src/hci.rs b/gd/rust/shim/src/hci.rs index 7667e5dcd..4407a168c 100644 --- a/gd/rust/shim/src/hci.rs +++ b/gd/rust/shim/src/hci.rs @@ -1,15 +1,9 @@ //! Hci shim -use bt_hal::AclHal; -use bt_hci::{EventRegistry, RawCommandSender}; -use bt_packets::hci::{ - AclPacket, CommandPacket, EventCode, EventPacket, LeMetaEventPacket, SubeventCode, -}; -use num_traits::FromPrimitive; +use bt_hci::facade::HciFacadeService; +use bt_packets::hci::{AclPacket, CommandPacket}; use std::sync::Arc; use tokio::runtime::Runtime; -use tokio::sync::mpsc::{channel, Receiver, Sender}; -use tokio::sync::Mutex; #[cxx::bridge(namespace = bluetooth::shim::rust)] mod ffi { @@ -42,40 +36,21 @@ unsafe impl Send for ffi::u8SliceCallback {} unsafe impl Send for ffi::u8SliceOnceCallback {} pub struct Hci { - commands: RawCommandSender, - events: EventRegistry, - acl: AclHal, + internal: HciFacadeService, rt: Arc, acl_callback_set: bool, evt_callback_set: bool, le_evt_callback_set: bool, - evt_tx: Sender, - evt_rx: Arc>>, - le_evt_tx: Sender, - le_evt_rx: Arc>>, } impl Hci { - pub fn new( - rt: Arc, - commands: RawCommandSender, - events: EventRegistry, - acl: AclHal, - ) -> Self { - let (evt_tx, evt_rx) = channel::(10); - let (le_evt_tx, le_evt_rx) = channel::(10); + pub fn new(rt: Arc, internal: HciFacadeService) -> Self { Self { rt, - commands, - events, - acl, + internal, acl_callback_set: false, evt_callback_set: false, le_evt_callback_set: false, - evt_tx, - evt_rx: Arc::new(Mutex::new(evt_rx)), - le_evt_tx, - le_evt_rx: Arc::new(Mutex::new(le_evt_rx)), } } } @@ -86,7 +61,7 @@ pub fn hci_send_command( callback: cxx::UniquePtr, ) { let packet = CommandPacket::parse(data).unwrap(); - let mut commands = hci.commands.clone(); + let mut commands = hci.internal.commands.clone(); hci.rt.spawn(async move { let resp = commands.send(packet).await.unwrap(); callback.Run(&resp.to_bytes()); @@ -94,24 +69,22 @@ pub fn hci_send_command( } pub fn hci_send_acl(hci: &mut Hci, data: &[u8]) { - hci.rt.block_on(hci.acl.tx.send(AclPacket::parse(data).unwrap())).unwrap(); + hci.rt.block_on(hci.internal.acl.tx.send(AclPacket::parse(data).unwrap())).unwrap(); } pub fn hci_register_event(hci: &mut Hci, event: u8) { - hci.rt.block_on(hci.events.register(EventCode::from_u8(event).unwrap(), hci.evt_tx.clone())); + hci.rt.block_on(hci.internal.register_event(event.into())); } pub fn hci_register_le_event(hci: &mut Hci, subevent: u8) { - hci.rt.block_on( - hci.events.register_le(SubeventCode::from_u8(subevent).unwrap(), hci.le_evt_tx.clone()), - ); + hci.rt.block_on(hci.internal.register_le_event(subevent.into())); } pub fn hci_set_acl_callback(hci: &mut Hci, callback: cxx::UniquePtr) { assert!(!hci.acl_callback_set); hci.acl_callback_set = true; - let stream = hci.acl.rx.clone(); + let stream = hci.internal.acl.rx.clone(); hci.rt.spawn(async move { while let Some(item) = stream.lock().await.recv().await { callback.Run(&item.to_bytes()); @@ -123,7 +96,7 @@ pub fn hci_set_evt_callback(hci: &mut Hci, callback: cxx::UniquePtr Box { Box::new(Hci::new( stack.get_runtime(), - stack.get_blocking::(), - stack.get_blocking::(), - stack.get_blocking::(), + stack.get_blocking::(), )) } -- 2.11.0