r/backtickbot • • Mar 12 '21

https://np.reddit.com/r/rust/comments/m3eqpu/yew_bevy_and_some_message_passing_magic/gqpsqg6/

From the [bevy Discord](https://discord.com/channels/691052431525675048/691052431974465548/819763823807299584)

Bevy side:

use bevy::prelude::{self, *};

use common::transport::{Event, EventHandle};

pub struct Plugin {
    pub handle: EventHandle,
}

impl prelude::Plugin for Plugin {
    fn build(&self, app: &mut AppBuilder) {
        app.add_resource(self.handle.clone())
            .add_event::<Send>()
            .add_event::<Receive>()
            .add_system(send.system())
            .add_system(receive.system())
            .add_system(log.system());
    }
}

#[derive(Debug)]
pub struct Send(Event);
#[derive(Debug)]
pub struct Receive(Event);

fn receive(handle: ResMut<EventHandle>, mut events: ResMut<Events<Receive>>) {
    if let Ok(ev) = handle.receiver.try_recv() {
        events.send(Receive(ev));
    }
}

fn send(
    handle: ResMut<EventHandle>,
    events: ResMut<Events<Send>>,
    mut reader: Local<EventReader<Send>>,
) {
    for ev in reader.iter(&events) {
        if let Err(e) = handle.sender.try_send(ev.0.clone()) {
            error!("Error sending event: {:?}", e);
        }
    }
}

fn log(events: Res<Events<Receive>>, mut reader: Local<EventReader<Receive>>) {
    for ev in reader.iter(&events) {
        info!("Event: {:?}", ev);
    }
}

Yew side:

use async_std::channel::{self, Sender};
use yew::prelude::*;
use yewtil::future::LinkFuture;

use common::transport::{Event, EventHandle};

pub enum Msg {
    Send(Event),
    Receive(Event),
}

pub struct App {
    props: Props,
    link: ComponentLink<Self>,
}

#[derive(Properties, Clone)]
pub struct Props {
    handle: EventHandle,
}

impl Component for App {
    type Message = Msg;
    type Properties = Props;

    fn create(props: Self::Properties, link: ComponentLink<Self>) -> Self {
        let this = Self { props, link };
        this.listen();

        this
    }

    fn update(&mut self, msg: Self::Message) -> ShouldRender {
        match msg {
            Msg::Send(e) => {
                self.props.handle.sender.try_send(e).ok();
            }
            Msg::Receive(e) => {
                log::info!("Event: {:?}", e);
                self.listen();
            }
        }

        false
    }

    fn change(&mut self, _props: Self::Properties) -> ShouldRender {
        false
    }

    fn view(&self) -> Html {
        html! {}
    }
}

impl App {
    fn listen(&self) {
        let handle = self.props.handle.clone();
        self.link.send_future(async move {
            loop {
                match handle.receiver.recv().await {
                    Ok(msg) => return Msg::Receive(msg),
                    Err(e) => log::error!("Error receiving event: {:?}", e),
                }
            }
        });
    }
}
5 Upvotes

0 comments sorted by