How do you use IPC with Iced?

[patientplatypus6]

So iced runs it's own process that requires the main thread. I want to use Servo/ipc_channel to send data between several processes and I want iced rust to be able to access that data. In a spawned process a server is able to successfully send data to a GUI of iced/rust, and I can also send data between the main server and the spawned GUI process. But I don't know how to access the mach_ports from inside the Iced/Rust application or send a channel through the App::run interface to access the data (I don't think that this is possible because of sandboxing requirements, but it was suggested by another dev).

Here is the code I'm working with for the GUI page. Are there any suggestions? I think it would be important for this to be understood in order to make this library useful for other developers.

use ipc_channel::ipc::{self, IpcOneShotServer, IpcSender, IpcReceiver};
use std::collections::HashMap;
use std::process::Command as ProcessCommand;
use std::env;
use std::io;
use std::{thread, time};
use std::sync::mpsc::{Sender, Receiver};
use std::sync::mpsc;

use iced::widget::{button, container, row, text};
use iced::{executor, Application, Command, Length, Settings};
use iced::Color;
use self::theme::Theme;
use self::widget::Element;
use std::future::Future;

// use gtk::prelude::*;
// use gtk::{Application, ApplicationWindow};

type Data = Vec<(String, String)>;
type Bootstrap = (IpcSender<Data>, IpcReceiver<Data>);

#[derive(Debug, Default, Clone)]
struct State {
    content: String
}

#[derive(Debug, Clone)]
enum Message {
    ButtonPress(String), 
    Test(i32)
}

struct App{
    state: State
}

mod widget {
    #![allow(dead_code)]
    use crate::theme::Theme;

    pub type Renderer = iced::Renderer<Theme>;
    pub type Element<'a, Message> = iced::Element<'a, Message, Renderer>;
    pub type Container<'a, Message> = iced::widget::Container<'a, Message, Renderer>;
    pub type Button<'a, Message> = iced::widget::Button<'a, Message, Renderer>;
}

mod theme {
    use iced::widget::{button, container, text};
    use iced::{application, color, Color};

    #[derive(Debug, Clone, Copy, Default)]
    pub struct Theme;

    impl application::StyleSheet for Theme {
        type Style = ();

        fn appearance(&self, _style: &Self::Style) -> application::Appearance {
            application::Appearance {
                background_color: color!(0x28, 0x28, 0x28),
                text_color: color!(0xeb, 0xdb, 0xb2),
            }
        }
    }

    impl text::StyleSheet for Theme {
        type Style = ();

        fn appearance(&self, _style: Self::Style) -> text::Appearance {
            text::Appearance {
                color: color!(0xeb, 0xdb, 0xb2).into(),
            }
        }
    }

    #[derive(Debug, Clone, Copy, Default)]
    pub enum Container {
        #[default]
        Default,
        Bordered,
        WhiteBackground
    }

    impl container::StyleSheet for Theme {
        type Style = Container;

        fn appearance(&self, style: &Self::Style) -> container::Appearance {
            match style {
                Container::Default => container::Appearance::default(),
                Container::Bordered => container::Appearance {
                    border_color: color!(0x45, 0x85, 0x88),
                    border_width: 1.0,
                    border_radius: 4.0,
                    ..Default::default()
                },
                Container::WhiteBackground => container::Appearance{
                    background: Some(iced::Background::Color(Color::from_rgba(0.8, 0.2, 0.3, 1.0))),
                    ..Default::default()
                }
            }
        }
    }

    #[derive(Debug, Clone, Copy, Default)]
    pub enum Button {
        #[default]
        Primary,
        Secondary,
    }

    impl button::StyleSheet for Theme {
        type Style = Button;

        fn active(&self, style: &Self::Style) -> button::Appearance {
            match style {
                Button::Primary => button::Appearance {
                    background: color!(0x28, 0x28, 0x28).into(),
                    border_radius: 4.0,
                    border_width: 1.0,
                    border_color: color!(0x45, 0x85, 0x88),
                    ..Default::default()
                },
                Button::Secondary => button::Appearance {
                    background: color!(0x3c, 0x38, 0x36).into(),
                    ..Default::default()
                },
            }
        }
    }
}


impl Application for App {
    type Executor = executor::Default;
    type Message = Message;
    type Theme = Theme;
    // type Flags = (Sender<i32>, Receiver<i32>);
    type Flags = ();

    fn new(_flags: Self::Flags) -> (Self, Command<Message>) {
    // fn new(_flags: ()) -> (App, Command<Message>) {  
        (App{state:State{content: "default state".to_string()}},Command::none())
    }

    // fn new(_flags: ()) -> (App, Command<Message>) {
    //     (
    //         App {
    //             list_button: button::State::new(),
    //             route: Route::List,
    //             posts: None,
    //             post: None,
    //             comments: None,
    //         },
    //         Command::perform(data::Post::fetch_all(), Message::PostsFound),
    //     )
    // }

    fn title(&self) -> String {
        "Custom Theme".into()
    }

    fn update(&mut self, message: Message) -> Command<Message> {
        match message {
            Message::ButtonPress(m) => {
                println!("The value of the button press is {:?}", m);
                self.state.content = m;
                println!("The new value of the state is {:?}", self.state.content);
            }
        }
        Command::none()
    }

    fn view(&self) -> Element<Message> {
        container(
            container(
                row![
                    button(text("primary"))
                        .style(theme::Button::Primary)
                        .on_press(Message::ButtonPress("primary".to_string())),
                    button(text("secondary"))
                        .style(theme::Button::Secondary)
                        .on_press(Message::ButtonPress("secondary".to_string())),
                    container(text("hello"))
                        .style(theme::Container::WhiteBackground),
                    text("The value of the button pressed is : "),
                    text(&self.state.content)
                ]
                .spacing(10),
            )
            .padding(20)
            .style(theme::Container::Bordered),
        )
        .width(Length::Fill)
        .height(Length::Fill)
        .center_x()
        .center_y()
        .into()
    }
}

pub fn data_handler(){

    let args: Vec<String> = env::args().collect();
    println!("value of args {:?}", args);
    let (to_child, from_parent): (IpcSender<Data>, IpcReceiver<Data>) = ipc::channel().unwrap();
    let (to_parent, from_child): (IpcSender<Data>, IpcReceiver<Data>) = ipc::channel().unwrap();
    let bootstrap = IpcSender::connect(args[1].clone()).unwrap();
    bootstrap.send((to_child, from_child)).unwrap();
    let data = from_parent.recv().unwrap();
    println!("child received {:?}", data);
    to_parent.send(vec![("Dagne".to_string(), "8".to_string())]);

    loop {
        match from_parent.try_recv() {
            Ok(res) => {
                println!("Received data in gui...{:?}", res);
                break;
            },
            Err(_) => {
                println!("Still waiting in gui...");
                std::thread::sleep_ms(1000);
            }
        }
    }
}


// fn build_ui(app: &Application) {
//     // Create a window and set the title
//     let window = ApplicationWindow::builder()
//         .application(app)
//         .title("My GTK App")
//         .build();

//     // Present window
//     window.present();
// }

// fn gtk_fn(){
//     // Create a new application
//     let app = Application::builder().application_id(APP_ID).build();

//     // Connect to "activate" signal of `app`
//     app.connect_activate(build_ui);

//     // Run the application
//     app.run();  
// }

fn main() {
    println!("Inside GUI process");
    // gtk_fn();    

    let (tx, rx): (Sender<i32>, Receiver<i32>) = mpsc::channel();

    let thread_join_handle = thread::spawn(move || {
        data_handler();
    });



    // let (tx, rx): (Sender<i32>, Receiver<i32>) = mpsc::channel();
    // App::run(Settings::new(tx, rx)).unwrap();

    App::run(Settings::default()).unwrap();
    // some work here
    // let res = thread_join_handle.join();
}

[13r0ck]

Look at the websocket example. You want to create a subscription that connects to external data, and your then your subscription and app can communicate via messages

[patientplatypus6]

Because I want to write to the webview and back if I'm using sockets over localhost then this would be too slow - and I don't think a webview can be served in the same way that a web page can.

[patientplatypus6]

So I could probably write to a served top level cargo over a socket layer and save state as you describe, but I believe that I need to use the ports because 1) webview can't be served and 2) writing over the socket layer would be too slow because both the webview and the rust/iced are running an event loop and I believe that port serving over IPC would be faster. Or am I totally off base?

[13r0ck]

I'm not saying to use websocket over IPC, IPC is fine. All i'm saying is that you are trying to connect to external data that isnt a REST API. So you need to put that logic in a subscription. The websocket example takes all of the logic of a websocket communication and bundles it into a subscription. You will need to do the same with your IPC.

[patientplatypus6]

I'm not sure I follow. I need a way to escape from the event loop for App:run(Settings.default()). Here you are doing that by calling a websocket server by this:

https://github.com/iced-rs/iced/blob/master/examples/websocket/src/main.rs#L41
which calls this; https://github.com/iced-rs/iced/blob/master/examples/websocket/src/echo/server.rs#L34

Can I escape the event loop and call a function with the command function that isn't specifically running another server? The last time I tried this the command function said there was a problem because I wasn't calling a function that returned a future. I need to be able to access the IPC layer and escape the event loop entirely, not call a websocket as a subthread of the event loop process.

I want to use this library: https://github.com/tauri-apps/wry which needs to run on it's own event loop and can't be called via a websocket.

[13r0ck]

There is not "escape the event loop" in iced. You can think of it as a separate application (literally a separate thread if using tokio). You create this separate loop (called a subscription in iced), then attach that by implementing subscription() on your app. Then the two can communicate via messages via an mpsc.