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

Commit 912ea4eb authored by Zach Johnson's avatar Zach Johnson
Browse files

rusty-gd: collapse facade implementation into facade.rs 

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

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

+1 −1
Original line number Diff line number Diff line
@@ -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;

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

+134 −1
Original line number Diff line number Diff line 
//! 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!()

    }

}

system/gd/rust/hci/src/facade/hci_facade_server.rs

deleted100644 → 0
+0 −136
Original line number Diff line number Diff line 
//! 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!()

    }

}