Differences between approaches to IPC with large data

[tomasz13nocon]

There seems to be a few approaches I've found to send large data from rust to js.

1. Channels
2. Custom uri scheme protocol
3. ipc::Response (as recommended here)

However they're not exactly well documented, in fact Channels seem to be the only one mentioned in the docs. Information about these seems to be scattered in various github threads.

What are the differences between these approaches?
Which one should I use if I want to send small to medium files (pdf files, images), and which one if I want to stream large files (4k video)?

[FabianLars]

2 and 3 are essentially the same since the ipc that powers commands uses custom protocols for data transfers. 2 may be a tinyyy bit faster because it has fewer "layers". probably not noticable.

1 can only be slower than 2 and 3 because there's some indirection happening iirc (the sender tells the receiver to pull the data) due to webview api (performance) limitations. it's supposed to still be reasonable fast but there's either a bug or i misunderstood the team because it's a bit slower than expected.
also apart from performance, this does not sound like a usecase for a channel api wise. they typically only make sense for usecases where you need to push data (more than once).

[mcitem]

Could you clarify whether the ipc::Channel interface supports message reception from JavaScript on the Rust side? I have been unable to locate comprehensive documentation regarding this specific functionality.

[FabianLars]

Yes that should be possible. I'll try to find docs or an example later when I'm back home

[FabianLars]

i don't have a good example on hand yet, just this convoluted shit:

tauri/examples/api/src-tauri/src/lib.rs

Line 88 in 06c75fd

on_event: Channel::new(|event| {

But the idea is fairly simple, you create a Channel via https://docs.rs/tauri/latest/tauri/ipc/struct.Channel.html#method.new and simply send it over the IPC as a tauri::Command return value or via tauri events (emit)

[mcitem]

I tried looking into the purpose of this Channel::new(..) It seems its functionality is Rust -> Rust oriented, acting like a simple completion callback. Unfortunately, it's not what I need for JS -> Rust communication. It appears channels might not be capable of receiving messages from JavaScript.

tauri/examples/api/src-tauri/tauri-plugin-sample/src/lib.rs

Lines 52 to 68 in 06c75fd

	#[tauri::command]
	fn ping<R: tauri::Runtime>(
	app: tauri::AppHandle<R>,
	value: Option<String>,
	scope: tauri::ipc::CommandScope<PingScope>,
	global_scope: tauri::ipc::GlobalScope<SampleScope>,
	) -> std::result::Result<PingResponse, String> {
	println!("local scope {:?}", scope);
	println!("global scope {:?}", global_scope);
	app
	.sample()
	.ping(PingRequest {
	value,
	on_event: tauri::ipc::Channel::new(|_| Ok(())),
	})
	.map_err(|e| e.to_string())
	}

tauri/examples/api/src-tauri/tauri-plugin-sample/src/desktop.rs

Lines 17 to 30 in 06c75fd

	/// A helper class to access the sample APIs.
	pub struct Sample<R: Runtime>(AppHandle<R>);
	impl<R: Runtime> Sample<R> {
	pub fn ping(&self, payload: PingRequest) -> crate::Result<PingResponse> {
	payload.on_event.send(Event {
	kind: "ping".to_string(),
	value: payload.value.clone(),
	})?;
	Ok(PingResponse {
	value: payload.value,
	})
	}
	}

[FabianLars]

I could've sworn that we have a send() method on the js side as well but we don't, sry about the confusion.