Feeding data over a crossbeam channel (or similar) to an Application?

[whooie]

Apologies if this is kind of a basic problem or of this is the wrong place to ask. It looks like #1029 is asking a very similar question, but I'm not sure I understand the ultimate answer to the problem.

The gist of my problem is that I'm trying to create an Application that continuously checks a channel (currently looking at crossbeam, but I have no particular preference) for data pulled from a scientific camera in another thread and displays it in a heatmap. I've got the display part working with plotters_iced, but it's the channel part that I'm stuck on.

My first try was to initialize my Application with the channel receiver and use iced::time::every to accomplish the main data pulling loop, but I can't capture the receiver as a field of the struct implementing Application. I also took a look at iced::subscription::unfold, but this is my first foray into any sort of parallelism and I have to say I really don't understand it well yet.

use crossbeam::Receiver;
use iced::{ /* stuff */ };
use iced_native::{
    command::Action as CmdAction,
    window::Action as WinAction,
};
use ndarray as nd;

#[derive(Clone, Debug)]
pub enum Message<T>
where T: FrameData // trait defined elsewhere -- just ndarray stuff
{
    Frame(nd::Array2<T>),
    Stop,
}

#[derive(Debug)]
pub struct ViewerConfig<T>
where T: FrameData
{
    pub source: Receiver<Message<T>>,
    pub colormap: ColorMap, // custom type defined elsewhere
    pub bounds: (f64, f64),
}

#[derive(Debug)]
pub struct FrameViewer<T>
where T: FrameData
{
    source: Receiver<Message<T>>,
    plot: FramePlot<T> // definition not listed here -- this handles frame drawing
}

impl<T> Application for FrameViewer<T>
where T: FrameData
{
    type Message = Message<T>;
    type Executor = executor::Default;
    type Flags = ViewerConfig<T>;
    type Theme = Theme;

    fn new(flags: Self::Flags) -> (Self, Command<Self::Message>) {
        let ViewerConfig { source, colormap, bounds } = flags;
        return (
            Self { source, plot: FramePlot::new(None, colormap, bounds) },
            Command::none(),
        );
    }

    fn title(&self) -> String { "Andor iXon 888 frame display".to_string() }

    fn update(&mut self, message: Self::Message) -> Command<Self::Message> {
        return match message {
            Message::Frame(frame) => {
                self.plot.set_frame(frame);
                Command::none()
            },
            Message::Stop => {
                Command::single(CmdAction::Window(WinAction::Close))
            },
        };
    }

    fn view(&self) -> Element<'_, Self::Message> {
        return Container::new(self.plot.view())
            .width(Length::Fill)
            .height(Length::Fill)
            .padding(CONTAINER_PAD)
            .center_x()
            .center_y()
            .into();
    }

    fn subscription(&self) -> Subscription<Self::Message> {
        const EVERY: u64 = 1; // us
        return iced::time::every(Duration::from_micros(EVERY))
            .map(|_| match self.source.recv() {
                Ok(message) => message,
                Err(_) => Message::Stop,
            ); // doesn't work because this closure can't capture `self`
    }
}

So what's the preferred or most convenient way to do something like this? My original plan is to have this Application run in its own thread and have another thread handle the actual data acquisition (because there's some other processing that I'd like to have happen outside of this context). After reading the other post I linked above, I'm still not sure how the sending side of the channel can ever be used from outside the Application/Subscription.

[hecrj]

See the docs of subscription::channel: https://docs.rs/iced/latest/iced/subscription/fn.channel.html

You should create the channels in the closure, rather than creating them before the application starts.

[whooie]

Okay, I think I understand this. Once the sender is sent back to the application as a message, what's the way to use it from another thread? Would I have to send it over another, different channel?