rusty-gd: collapse facade implementation into facade.rs

Bug: 171749953
Tag: #gd-refactor
Test: gd/cert/run --rhost
Change-Id: I63049dbb233fe9e3a3d957dd21d7aea3d5d23162

diff --git a/gd/rust/facade/src/lib.rs b/gd/rust/facade/src/lib.rs
index 482b2f9..00d0d2f 100644 (file)
--- a/gd/rust/facade/src/lib.rs
+++ b/gd/rust/facade/src/lib.rs
@@ -12,7 +12,7 @@ pub use bt_facade_common_proto::common;
 pub use bt_facade_rootservice_proto::rootservice;
 
 use bt_hal::rootcanal_hal::{RootcanalConfig, RootcanalHal};
-use bt_hci::facade::hci_facade_server::HciLayerFacadeService;
+use bt_hci::facade::HciLayerFacadeService;
 use bt_hci::Hci;
 
 use tokio::runtime::Runtime;

diff --git a/gd/rust/hci/src/facade.rs b/gd/rust/hci/src/facade.rs
index 2020b4f..127743d 100644 (file)
--- a/gd/rust/hci/src/facade.rs
+++ b/gd/rust/hci/src/facade.rs
@@ -1,4 +1,137 @@
 //! HCI layer facade
 
-pub mod hci_facade_server;
 pub mod protos;
+
+use futures::sink::SinkExt;
+use tokio::runtime::Runtime;
+
+use crate::HciExports;
+
+use futures::prelude::*;
+use grpcio::*;
+
+use std::sync::Arc;
+
+/// HCI layer facade service
+#[derive(Clone)]
+pub struct HciLayerFacadeService {
+    /// HCI interface
+    pub hci_exports: HciExports,
+    /// Tokio runtime
+    pub rt: Arc<Runtime>,
+}
+
+use protos::empty::Empty;
+use protos::facade::*;
+use protos::hci_layer_facade_grpc::{HciLayerFacade, create_hci_layer_facade};
+
+impl HciLayerFacadeService {
+    /// Create a new instance of HCI layer facade service
+    pub fn create(hci_exports: HciExports, rt: Arc<Runtime>) -> grpcio::Service {
+        create_hci_layer_facade(Self { hci_exports, rt })
+    }
+}
+
+impl HciLayerFacade for HciLayerFacadeService {
+    fn enqueue_command_with_complete(
+        &mut self,
+        ctx: RpcContext<'_>,
+        mut cmd: CommandMsg,
+        sink: UnarySink<Empty>,
+    ) {
+        self.rt.block_on(self.hci_exports.enqueue_command_with_complete(cmd.take_command().into()));
+
+        let f = sink
+            .success(Empty::default())
+            .map_err(|e: grpcio::Error| {
+                println!("failed to handle enqueue_command_with_complete request: {:?}", e)
+            })
+            .map(|_| ());
+
+        ctx.spawn(f);
+    }
+
+    fn enqueue_command_with_status(
+        &mut self,
+        ctx: RpcContext<'_>,
+        mut cmd: CommandMsg,
+        sink: UnarySink<Empty>,
+    ) {
+        self.rt.block_on(self.hci_exports.enqueue_command_with_complete(cmd.take_command().into()));
+
+        let f = sink
+            .success(Empty::default())
+            .map_err(|e: grpcio::Error| {
+                println!("failed to handle enqueue_command_with_status request: {:?}", e)
+            })
+            .map(|_| ());
+
+        ctx.spawn(f);
+    }
+
+    fn register_event_handler(
+        &mut self,
+        ctx: RpcContext<'_>,
+        code: EventCodeMsg,
+        sink: UnarySink<Empty>,
+    ) {
+        self.rt.block_on(self.hci_exports.register_event_handler(code.get_code() as u8));
+
+        let f = sink
+            .success(Empty::default())
+            .map_err(|e: grpcio::Error| {
+                println!("failed to handle enqueue_command_with_status request: {:?}", e)
+            })
+            .map(|_| ());
+
+        ctx.spawn(f);
+    }
+
+    fn register_le_event_handler(
+        &mut self,
+        _ctx: RpcContext<'_>,
+        _code: LeSubeventCodeMsg,
+        _sink: UnarySink<Empty>,
+    ) {
+        unimplemented!()
+    }
+
+    fn send_acl_data(&mut self, _ctx: RpcContext<'_>, _data: AclMsg, _sink: UnarySink<Empty>) {
+        unimplemented!()
+    }
+
+    fn fetch_events(
+        &mut self,
+        _ctx: RpcContext<'_>,
+        _req: Empty,
+        mut resp: ServerStreamingSink<EventMsg>,
+    ) {
+        let evt_rx = self.hci_exports.evt_rx.clone();
+
+        self.rt.spawn(async move {
+            while let Some(event) = evt_rx.lock().await.recv().await {
+                let mut evt = EventMsg::default();
+                evt.set_event(event.to_vec());
+                resp.send((evt, WriteFlags::default())).await.unwrap();
+            }
+        });
+    }
+
+    fn fetch_le_subevents(
+        &mut self,
+        _ctx: RpcContext<'_>,
+        _req: Empty,
+        mut _resp: ServerStreamingSink<LeSubeventMsg>,
+    ) {
+        unimplemented!()
+    }
+
+    fn fetch_acl_packets(
+        &mut self,
+        _ctx: RpcContext<'_>,
+        _req: Empty,
+        mut _resp: ServerStreamingSink<AclMsg>,
+    ) {
+        unimplemented!()
+    }
+}

diff --git a/gd/rust/hci/src/facade/hci_facade_server.rs b/gd/rust/hci/src/facade/hci_facade_server.rs
deleted file mode 100644 (file)
index fae450b..0000000
--- a/gd/rust/hci/src/facade/hci_facade_server.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-//! HCI layer facade service
-
-use futures::sink::SinkExt;
-use tokio::runtime::Runtime;
-
-use crate::HciExports;
-
-use futures::prelude::*;
-use grpcio::*;
-
-use std::sync::Arc;
-
-/// HCI layer facade service
-#[derive(Clone)]
-pub struct HciLayerFacadeService {
-    /// HCI interface
-    pub hci_exports: HciExports,
-    /// Tokio runtime
-    pub rt: Arc<Runtime>,
-}
-
-use super::protos::empty::Empty;
-use super::protos::facade::*;
-use super::protos::hci_layer_facade_grpc::HciLayerFacade;
-use crate::facade::protos::hci_layer_facade_grpc::create_hci_layer_facade;
-
-impl HciLayerFacadeService {
-    /// Create a new instance of HCI layer facade service
-    pub fn create(hci_exports: HciExports, rt: Arc<Runtime>) -> grpcio::Service {
-        create_hci_layer_facade(Self { hci_exports, rt })
-    }
-}
-
-impl HciLayerFacade for HciLayerFacadeService {
-    fn enqueue_command_with_complete(
-        &mut self,
-        ctx: RpcContext<'_>,
-        mut cmd: CommandMsg,
-        sink: UnarySink<Empty>,
-    ) {
-        self.rt.block_on(self.hci_exports.enqueue_command_with_complete(cmd.take_command().into()));
-
-        let f = sink
-            .success(Empty::default())
-            .map_err(|e: grpcio::Error| {
-                println!("failed to handle enqueue_command_with_complete request: {:?}", e)
-            })
-            .map(|_| ());
-
-        ctx.spawn(f);
-    }
-
-    fn enqueue_command_with_status(
-        &mut self,
-        ctx: RpcContext<'_>,
-        mut cmd: CommandMsg,
-        sink: UnarySink<Empty>,
-    ) {
-        self.rt.block_on(self.hci_exports.enqueue_command_with_complete(cmd.take_command().into()));
-
-        let f = sink
-            .success(Empty::default())
-            .map_err(|e: grpcio::Error| {
-                println!("failed to handle enqueue_command_with_status request: {:?}", e)
-            })
-            .map(|_| ());
-
-        ctx.spawn(f);
-    }
-
-    fn register_event_handler(
-        &mut self,
-        ctx: RpcContext<'_>,
-        code: EventCodeMsg,
-        sink: UnarySink<Empty>,
-    ) {
-        self.rt.block_on(self.hci_exports.register_event_handler(code.get_code() as u8));
-
-        let f = sink
-            .success(Empty::default())
-            .map_err(|e: grpcio::Error| {
-                println!("failed to handle enqueue_command_with_status request: {:?}", e)
-            })
-            .map(|_| ());
-
-        ctx.spawn(f);
-    }
-
-    fn register_le_event_handler(
-        &mut self,
-        _ctx: RpcContext<'_>,
-        _code: LeSubeventCodeMsg,
-        _sink: UnarySink<Empty>,
-    ) {
-        unimplemented!()
-    }
-
-    fn send_acl_data(&mut self, _ctx: RpcContext<'_>, _data: AclMsg, _sink: UnarySink<Empty>) {
-        unimplemented!()
-    }
-
-    fn fetch_events(
-        &mut self,
-        _ctx: RpcContext<'_>,
-        _req: Empty,
-        mut resp: ServerStreamingSink<EventMsg>,
-    ) {
-        let evt_rx = self.hci_exports.evt_rx.clone();
-
-        self.rt.spawn(async move {
-            while let Some(event) = evt_rx.lock().await.recv().await {
-                let mut evt = EventMsg::default();
-                evt.set_event(event.to_vec());
-                resp.send((evt, WriteFlags::default())).await.unwrap();
-            }
-        });
-    }
-
-    fn fetch_le_subevents(
-        &mut self,
-        _ctx: RpcContext<'_>,
-        _req: Empty,
-        mut _resp: ServerStreamingSink<LeSubeventMsg>,
-    ) {
-        unimplemented!()
-    }
-
-    fn fetch_acl_packets(
-        &mut self,
-        _ctx: RpcContext<'_>,
-        _req: Empty,
-        mut _resp: ServerStreamingSink<AclMsg>,
-    ) {
-        unimplemented!()
-    }
-}