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

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

rusty-gd: simplify exported types 

drop the exports, it's simpler

Bug: 171749953
Tag: #gd-refactor
Test: gd/cert/run --rhost
Change-Id: I5d0c9f45f68ac818c9cd260dc50c325d066e5927
parent 21f7d9e7

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

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



use crate::HalExports;

use crate::Hal;

use bt_common::GrpcFacade;

use bt_facade_proto::common::Data;

use bt_facade_proto::empty::Empty;
@@ -20,15 +20,15 @@ module! { 
}



#[provides]

async fn provide_facade(hal_exports: HalExports, rt: Arc<Runtime>) -> HciHalFacadeService {

    HciHalFacadeService { rt, hal_exports }

async fn provide_facade(hal: Hal, rt: Arc<Runtime>) -> HciHalFacadeService {

    HciHalFacadeService { rt, hal }

}



/// HCI HAL facade service

#[derive(Clone, Stoppable)]

pub struct HciHalFacadeService {

    rt: Arc<Runtime>,

    hal_exports: HalExports,

    hal: Hal,

}



impl GrpcFacade for HciHalFacadeService {
@@ -39,7 +39,7 @@ impl GrpcFacade for HciHalFacadeService { 


impl HciHalFacade for HciHalFacadeService {

    fn send_command(&mut self, _ctx: RpcContext<'_>, mut data: Data, sink: UnarySink<Empty>) {

        let cmd_tx = self.hal_exports.cmd_tx.clone();

        let cmd_tx = self.hal.cmd_tx.clone();

        self.rt.block_on(async move {

            cmd_tx.send(CommandPacket::parse(&data.take_payload()).unwrap()).await.unwrap();

        });
@@ -47,7 +47,7 @@ impl HciHalFacade for HciHalFacadeService { 
    }



    fn send_acl(&mut self, _ctx: RpcContext<'_>, mut data: Data, sink: UnarySink<Empty>) {

        let acl_tx = self.hal_exports.acl_tx.clone();

        let acl_tx = self.hal.acl_tx.clone();

        self.rt.block_on(async move {

            acl_tx.send(AclPacket::parse(&data.take_payload()).unwrap()).await.unwrap();

        });
@@ -68,7 +68,7 @@ impl HciHalFacade for HciHalFacadeService { 
        _: Empty,

        mut sink: ServerStreamingSink<Data>,

    ) {

        let evt_rx = self.hal_exports.evt_rx.clone();

        let evt_rx = self.hal.evt_rx.clone();

        self.rt.spawn(async move {

            while let Some(event) = evt_rx.lock().await.recv().await {

                let mut output = Data::default();
@@ -79,7 +79,7 @@ impl HciHalFacade for HciHalFacadeService { 
    }



    fn stream_acl(&mut self, _ctx: RpcContext<'_>, _: Empty, mut sink: ServerStreamingSink<Data>) {

        let acl_rx = self.hal_exports.acl_rx.clone();

        let acl_rx = self.hal.acl_rx.clone();

        self.rt.spawn(async move {

            while let Some(acl) = acl_rx.lock().await.recv().await {

                let mut output = Data::default();

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

+10 −23
Original line number Diff line number Diff line 
//! Implementation of the HAl that talks to BT controller over Android's HIDL

use crate::internal::{Hal, RawHalExports};

use crate::internal::{InnerHal, RawHal};

use bt_packets::hci::{AclPacket, CommandPacket, EventPacket};

use gddi::{module, provides};

use std::sync::Arc;
@@ -11,25 +11,22 @@ use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender}; 
module! {

    hidl_hal_module,

    providers {

        RawHalExports => provide_hidl_hal,

        RawHal => provide_hidl_hal,

    }

}



#[provides]

async fn provide_hidl_hal(rt: Arc<Runtime>) -> RawHalExports {

    let (hal_exports, hal) = Hal::new();

async fn provide_hidl_hal(rt: Arc<Runtime>) -> RawHal {

    let (raw_hal, inner_hal) = InnerHal::new();

    let (init_tx, mut init_rx) = unbounded_channel();

    *CALLBACKS.lock().unwrap() = Some(Callbacks {

        init_tx,

        evt_tx: hal.evt_tx,

        acl_tx: hal.acl_tx,

    });

    *CALLBACKS.lock().unwrap() =

        Some(Callbacks { init_tx, evt_tx: inner_hal.evt_tx, acl_tx: inner_hal.acl_tx });

    ffi::start_hal();

    init_rx.recv().await.unwrap();



    rt.spawn(dispatch_outgoing(hal.cmd_rx, hal.acl_rx));

    rt.spawn(dispatch_outgoing(inner_hal.cmd_rx, inner_hal.acl_rx));



    hal_exports

    raw_hal

}



#[cxx::bridge(namespace = bluetooth::hal)]
@@ -68,22 +65,12 @@ fn on_init_complete() { 


fn on_event(data: &[u8]) {

    let callbacks = CALLBACKS.lock().unwrap();

    callbacks

        .as_ref()

        .unwrap()

        .evt_tx

        .send(EventPacket::parse(data).unwrap())

        .unwrap();

    callbacks.as_ref().unwrap().evt_tx.send(EventPacket::parse(data).unwrap()).unwrap();

}



fn on_acl(data: &[u8]) {

    let callbacks = CALLBACKS.lock().unwrap();

    callbacks

        .as_ref()

        .unwrap()

        .acl_tx

        .send(AclPacket::parse(data).unwrap())

        .unwrap();

    callbacks.as_ref().unwrap().acl_tx.send(AclPacket::parse(data).unwrap()).unwrap();

}



fn on_sco(_data: &[u8]) {}

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

+7 −12
Original line number Diff line number Diff line
@@ -45,7 +45,7 @@ const H4_HEADER_SIZE: usize = 1; 
/// This is used by the HCI module to send commands to the

/// HAL and receive events from the HAL

#[derive(Clone, Stoppable)]

pub struct HalExports {

pub struct Hal {

    /// Transmit end of a channel used to send HCI commands

    pub cmd_tx: Sender<CommandPacket>,

    /// Receive end of a channel used to receive HCI events
@@ -64,39 +64,34 @@ mod internal { 
    use tokio::sync::Mutex;



    #[derive(Clone, Stoppable)]

    pub struct RawHalExports {

    pub struct RawHal {

        pub cmd_tx: UnboundedSender<CommandPacket>,

        pub evt_rx: Arc<Mutex<UnboundedReceiver<EventPacket>>>,

        pub acl_tx: UnboundedSender<AclPacket>,

        pub acl_rx: Arc<Mutex<UnboundedReceiver<AclPacket>>>,

    }



    pub struct Hal {

    pub struct InnerHal {

        pub cmd_rx: UnboundedReceiver<CommandPacket>,

        pub evt_tx: UnboundedSender<EventPacket>,

        pub acl_rx: UnboundedReceiver<AclPacket>,

        pub acl_tx: UnboundedSender<AclPacket>,

    }



    impl Hal {

        pub fn new() -> (RawHalExports, Self) {

    impl InnerHal {

        pub fn new() -> (RawHal, Self) {

            let (cmd_tx, cmd_rx) = unbounded_channel();

            let (evt_tx, evt_rx) = unbounded_channel();

            let (acl_down_tx, acl_down_rx) = unbounded_channel();

            let (acl_up_tx, acl_up_rx) = unbounded_channel();

            (

                RawHalExports {

                RawHal {

                    cmd_tx,

                    evt_rx: Arc::new(Mutex::new(evt_rx)),

                    acl_tx: acl_down_tx,

                    acl_rx: Arc::new(Mutex::new(acl_up_rx)),

                },

                Self {

                    cmd_rx,

                    evt_tx,

                    acl_rx: acl_down_rx,

                    acl_tx: acl_up_tx,

                },

                Self { cmd_rx, evt_tx, acl_rx: acl_down_rx, acl_tx: acl_up_tx },

            )

        }

    }

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

+10 −17
Original line number Diff line number Diff line
@@ -2,7 +2,7 @@ 
//! This connects to "rootcanal" which provides a simulated

//! Bluetooth chip as well as a simulated environment.



use crate::internal::{Hal, RawHalExports};

use crate::internal::{InnerHal, RawHal};

use crate::{Result, H4_HEADER_SIZE};

use bt_packets::hci::{AclPacket, CommandPacket, EventPacket};

use bytes::{BufMut, Bytes, BytesMut};
@@ -35,22 +35,22 @@ enum HciPacketHeaderSize { 
module! {

    rootcanal_hal_module,

    providers {

        RawHalExports => provide_rootcanal_hal,

        RawHal => provide_rootcanal_hal,

    }

}



#[provides]

async fn provide_rootcanal_hal(config: RootcanalConfig, rt: Arc<Runtime>) -> RawHalExports {

    let (hal_exports, hal) = Hal::new();

async fn provide_rootcanal_hal(config: RootcanalConfig, rt: Arc<Runtime>) -> RawHal {

    let (raw_hal, inner_hal) = InnerHal::new();

    let (reader, writer) = TcpStream::connect(&config.to_socket_addr().unwrap())

        .await

        .expect("unable to create stream to rootcanal")

        .into_split();



    rt.spawn(dispatch_incoming(hal.evt_tx, hal.acl_tx, reader));

    rt.spawn(dispatch_outgoing(hal.cmd_rx, hal.acl_rx, writer));

    rt.spawn(dispatch_incoming(inner_hal.evt_tx, inner_hal.acl_tx, reader));

    rt.spawn(dispatch_outgoing(inner_hal.cmd_rx, inner_hal.acl_rx, writer));



    hal_exports

    raw_hal

}



/// Rootcanal configuration
@@ -63,10 +63,7 @@ pub struct RootcanalConfig { 
impl RootcanalConfig {

    /// Create a rootcanal config

    pub fn new(address: &str, port: u16) -> Self {

        Self {

            address: String::from(address),

            port,

        }

        Self { address: String::from(address), port }

    }



    fn to_socket_addr(&self) -> Result<SocketAddr> {
@@ -96,9 +93,7 @@ where 
            payload.resize(len, 0);

            reader.read_exact(&mut payload).await?;

            buffer.unsplit(payload);

            evt_tx

                .send(EventPacket::parse(&buffer.freeze()).unwrap())

                .unwrap();

            evt_tx.send(EventPacket::parse(&buffer.freeze()).unwrap()).unwrap();

        } else if buffer[0] == HciPacketType::Acl as u8 {

            buffer.resize(HciPacketHeaderSize::Acl as usize, 0);

            reader.read_exact(&mut buffer).await?;
@@ -107,9 +102,7 @@ where 
            payload.resize(len, 0);

            reader.read_exact(&mut payload).await?;

            buffer.unsplit(payload);

            acl_tx

                .send(AclPacket::parse(&buffer.freeze()).unwrap())

                .unwrap();

            acl_tx.send(AclPacket::parse(&buffer.freeze()).unwrap()).unwrap();

        }

    }

}

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

+9 −13
Original line number Diff line number Diff line 
//! BT snoop logger



use crate::internal::RawHalExports;

use crate::HalExports;

use crate::internal::RawHal;

use crate::Hal;

use bt_common::sys_prop;

use bt_packets::hci::{AclPacket, CommandPacket, EventPacket};

use bytes::{BufMut, Bytes, BytesMut};
@@ -91,16 +91,12 @@ fn get_configured_snoop_mode() -> String { 
module! {

    snoop_module,

    providers {

        HalExports => provide_snooped_hal,

        Hal => provide_snooped_hal,

    },

}



#[provides]

async fn provide_snooped_hal(

    config: SnoopConfig,

    hal_exports: RawHalExports,

    rt: Arc<Runtime>,

) -> HalExports {

async fn provide_snooped_hal(config: SnoopConfig, raw_hal: RawHal, rt: Arc<Runtime>) -> Hal {

    let (cmd_down_tx, mut cmd_down_rx) = channel::<CommandPacket>(10);

    let (evt_up_tx, evt_up_rx) = channel::<EventPacket>(10);

    let (acl_down_tx, mut acl_down_rx) = channel::<AclPacket>(10);
@@ -110,19 +106,19 @@ async fn provide_snooped_hal( 
        let mut logger = SnoopLogger::new(config).await;

        loop {

            select! {

                Some(evt) = consume(&hal_exports.evt_rx) => {

                Some(evt) = consume(&raw_hal.evt_rx) => {

                    evt_up_tx.send(evt.clone()).await.unwrap();

                    logger.log(Type::Evt, Direction::Up, evt.to_bytes()).await;

                },

                Some(cmd) = cmd_down_rx.recv() => {

                    hal_exports.cmd_tx.send(cmd.clone()).unwrap();

                    raw_hal.cmd_tx.send(cmd.clone()).unwrap();

                    logger.log(Type::Cmd, Direction::Down, cmd.to_bytes()).await;

                },

                Some(acl) = acl_down_rx.recv() => {

                    hal_exports.acl_tx.send(acl.clone()).unwrap();

                    raw_hal.acl_tx.send(acl.clone()).unwrap();

                    logger.log(Type::Acl, Direction::Down, acl.to_bytes()).await;

                },

                Some(acl) = consume(&hal_exports.acl_rx) => {

                Some(acl) = consume(&raw_hal.acl_rx) => {

                    acl_up_tx.send(acl.clone()).await.unwrap();

                    logger.log(Type::Acl, Direction::Up, acl.to_bytes()).await;

                }
@@ -130,7 +126,7 @@ async fn provide_snooped_hal( 
        }

    });



    HalExports {

    Hal {

        cmd_tx: cmd_down_tx,

        evt_rx: Arc::new(Mutex::new(evt_up_rx)),

        acl_tx: acl_down_tx,