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
Loading
Loading
Loading
Loading
+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;
+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!()
    }
}
+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!()
    }
}