feat(core): optimize raw payload in event system, closes #13405

.changes/emit-raw-api.md

@@ -0,0 +1,5 @@
+---
+"@tauri-apps/api": minor:feat
+---
+
+Optimize raw Uint8Array/ArrayBuffer/number[] payloads on the event system via the emit2 and emitTo2 functions.

.changes/event-emit-raw.md

@@ -0,0 +1,5 @@
+---
+"tauri": minor:feat
+---
+
+Allow sending raw binary payloads using the event system through `Emitter::emit_raw` and `Emitter::emit_raw_to`.

.changes/listen-raw-binary-payload.md

@@ -0,0 +1,5 @@
+---
+"tauri": minor:feat
+---
+
+Allow reading raw binary payloads using the event system through [`Event::payload_raw`].

crates/tauri/src/app.rs

@@ -8,7 +8,7 @@ use crate::{
     channel::ChannelDataIpcQueue, CallbackFn, CommandArg, CommandItem, Invoke, InvokeError,
     InvokeHandler, InvokeResponseBody,
   },
-  manager::{webview::UriSchemeProtocol, AppManager, Asset},
+  manager::{webview::UriSchemeProtocol, AppManager, Asset, EventPayloadStore},
   plugin::{Plugin, PluginStore},
   resources::ResourceTable,
   runtime::{
@@ -2260,6 +2260,7 @@ tauri::Builder::default()
     });
 
     app.manage(ChannelDataIpcQueue::default());
+    app.manage(EventPayloadStore::default());
     app.handle.plugin(crate::ipc::channel::plugin())?;
 
     let handle = app.handle();

crates/tauri/src/event/listener.rs

@@ -201,7 +201,11 @@ impl Listeners {
           let handlers = handlers.filter(|(_, h)| match_any_or_filter(&h.target, &filter));
           for (&id, Handler { callback, .. }) in handlers {
             maybe_pending = true;
-            (callback)(Event::new(id, emit_args.payload.clone()))
+            (callback)(Event::new(
+              id,
+              emit_args.payload.clone(),
+              emit_args.raw.clone(),
+            ))
           }
         }
       }
@@ -266,6 +270,37 @@ impl Listeners {
     })
   }
 
+  /// Filters the webviews that are matched by the filter has a JS listener for the given event
+  pub(crate) fn webiews_matching_event_filter<'a, R, I, F>(
+    &self,
+    webviews: I,
+    emit_args: &EmitArgs,
+    filter: Option<F>,
+  ) -> Vec<&'a Webview<R>>
+  where
+    R: Runtime,
+    I: Iterator<Item = &'a Webview<R>>,
+    F: Fn(&EventTarget) -> bool,
+  {
+    let event = &emit_args.event;
+    let js_listeners = self.inner.js_event_listeners.lock().unwrap();
+    webviews
+      .filter(|webview| {
+        if let Some(handlers) = js_listeners.get(webview.label()).and_then(|s| s.get(event)) {
+          let ids = handlers
+            .iter()
+            .filter(|handler| match_any_or_filter(&handler.target, &filter))
+            .map(|handler| handler.id)
+            .collect::<Vec<_>>();
+          if !ids.is_empty() {
+            return true;
+          }
+        }
+        false
+      })
+      .collect()
+  }
+
   pub(crate) fn emit_js_filter<'a, R, I, F>(
     &self,
     mut webviews: I,

crates/tauri/src/event/mod.rs

@@ -13,7 +13,11 @@ mod event_name;
 
 pub(crate) use event_name::EventName;
 
-use crate::ipc::CallbackFn;
+use crate::{
+  event::plugin::{FETCH_EVENT_PAYLOAD_COMMAND, PAYLOAD_ID_HEADER_NAME},
+  ipc::CallbackFn,
+  manager::BINARY_EVENT_PAYLOAD_PREFIX,
+};
 
 /// Unique id of an event.
 pub type EventId = u32;
@@ -119,6 +123,8 @@ pub struct EmitArgs {
   event: EventName,
   /// Serialized payload.
   payload: String,
+  /// Raw payload bytes.
+  raw: Option<Vec<u8>>,
 }
 
 impl EmitArgs {
@@ -128,29 +134,46 @@ impl EmitArgs {
     Ok(EmitArgs {
       event: event.into_owned(),
       payload: serde_json::to_string(payload)?,
+      raw: None,
     })
   }
 
-  pub fn new_str(event: EventName<&str>, payload: String) -> crate::Result<Self> {
+  pub fn new_raw<S: Serialize>(
+    event: EventName<&str>,
+    payload: &S,
+    raw_data: Vec<u8>,
+  ) -> crate::Result<Self> {
     #[cfg(feature = "tracing")]
-    let _span = tracing::debug_span!("window::emit::json").entered();
+    let _span = tracing::debug_span!("window::emit::serialize").entered();
     Ok(EmitArgs {
       event: event.into_owned(),
-      payload,
+      payload: serde_json::to_string(payload)?,
+      raw: Some(raw_data),
     })
   }
+
+  pub fn new_str(event: EventName<&str>, payload: String) -> Self {
+    #[cfg(feature = "tracing")]
+    let _span = tracing::debug_span!("window::emit::json").entered();
+    EmitArgs {
+      event: event.into_owned(),
+      payload,
+      raw: None,
+    }
+  }
 }
 
 /// An event that was emitted.
 #[derive(Debug, Clone)]
 pub struct Event {
   id: EventId,
   data: String,
+  raw: Option<Vec<u8>>,
 }
 
 impl Event {
-  fn new(id: EventId, data: String) -> Self {
-    Self { id, data }
+  fn new(id: EventId, data: String, raw: Option<Vec<u8>>) -> Self {
+    Self { id, data, raw }
   }
 
   /// The [`EventId`] of the handler that was triggered.
@@ -159,9 +182,28 @@ impl Event {
   }
 
   /// The event payload.
+  ///
+  /// Note that you must use [`Self::payload_raw`] for events emitted with a binary payload.
   pub fn payload(&self) -> &str {
     &self.data
   }
+
+  /// Consumes the event and return its payload.
+  ///
+  /// Note that you must use [`Self::into_payload_raw`] for events emitted with a binary payload.
+  pub fn into_payload(self) -> String {
+    self.data
+  }
+
+  /// The event payload bytes.
+  pub fn payload_raw(&self) -> &[u8] {
+    self.raw.as_deref().unwrap_or(self.data.as_bytes())
+  }
+
+  /// Consumes the event and return its payload bytes.
+  pub fn into_payload_raw(self) -> Vec<u8> {
+    self.raw.unwrap_or_else(|| self.data.into_bytes())
+  }
 }
 
 pub(crate) fn listen_js_script(
@@ -224,8 +266,15 @@ pub(crate) fn unlisten_js_script(
 pub(crate) fn event_initialization_script(function_name: &str, listeners: &str) -> String {
   format!(
     "Object.defineProperty(window, '{function_name}', {{
-      value: function (eventData, ids) {{
+      value: async function (eventData, ids) {{
         const listeners = (window['{listeners}'] && window['{listeners}'][eventData.event]) || []
+
+        if (typeof eventData.payload === 'string' && eventData.payload.startsWith('{BINARY_EVENT_PAYLOAD_PREFIX}')) {{
+          const payloadId = eventData.payload.slice('{BINARY_EVENT_PAYLOAD_PREFIX}'.length)
+          const data = await window.__TAURI_INTERNALS__.invoke('{FETCH_EVENT_PAYLOAD_COMMAND}', null, {{ headers: {{ '{PAYLOAD_ID_HEADER_NAME}': payloadId }} }})
+          eventData.payload = data
+        }}
+
         for (const id of ids) {{
           const listener = listeners[id]
           if (listener) {{
@@ -235,7 +284,7 @@ pub(crate) fn event_initialization_script(function_name: &str, listeners: &str)
         }}
       }}
     }});
-  "
+  ",
   )
 }
 

crates/tauri/src/event/plugin.rs

@@ -1,16 +1,23 @@
+use serde::Deserialize;
 // Copyright 2019-2024 Tauri Programme within The Commons Conservancy
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
-use serde_json::Value as JsonValue;
 use serialize_to_javascript::{default_template, DefaultTemplate, Template};
 
+use crate::ipc::{InvokeBody, Request, Response};
+use crate::manager::EventPayloadStore;
 use crate::plugin::{Builder, TauriPlugin};
 use crate::{command, ipc::CallbackFn, EventId, Result, Runtime};
-use crate::{AppHandle, Emitter, Manager, Webview};
+use crate::{AppHandle, Emitter, Manager, State, Webview};
 
 use super::EventName;
 use super::EventTarget;
 
+const EVENT_NAME_HEADER_NAME: &str = "Tauri-Event-Name";
+const EVENT_TARGET_HEADER_NAME: &str = "Tauri-Event-Target";
+pub const FETCH_EVENT_PAYLOAD_COMMAND: &str = "plugin:event|fetch_payload";
+pub const PAYLOAD_ID_HEADER_NAME: &str = "Tauri-Payload-Id";
+
 #[command(root = "crate")]
 async fn listen<R: Runtime>(
   webview: Webview<R>,
@@ -31,22 +38,106 @@ async fn unlisten<R: Runtime>(
 }
 
 #[command(root = "crate")]
-async fn emit<R: Runtime>(
-  app: AppHandle<R>,
+async fn emit<R: Runtime>(app: AppHandle<R>, request: Request<'_>) -> Result<()> {
+  if let Some(event_header) = request
+    .headers()
+    .get(EVENT_NAME_HEADER_NAME)
+    .and_then(|v| v.to_str().ok())
+  {
+    let event = EventName::new(event_header)?;
+    match request.body() {
+      InvokeBody::Json(payload) => app.emit(event.as_str(), payload),
+      InvokeBody::Raw(payload) => app.emit_raw(event.as_str(), payload.clone()),
+    }
+  } else if let InvokeBody::Json(payload) = request.body() {
+    let args: EmitArgs = serde_json::from_value(payload.clone())?;
+    app.emit(args.event.as_str(), args.payload)
+  } else {
+    Err(anyhow::anyhow!("unexpected emit request format").into())
+  }
+}
+
+#[derive(Deserialize)]
+struct EmitArgs {
   event: EventName,
-  payload: Option<JsonValue>,
-) -> Result<()> {
-  app.emit(event.as_str(), payload)
+  payload: Option<serde_json::Value>,
 }
 
 #[command(root = "crate")]
-async fn emit_to<R: Runtime>(
-  app: AppHandle<R>,
-  target: EventTarget,
+async fn emit_to<R: Runtime>(app: AppHandle<R>, request: Request<'_>) -> Result<()> {
+  if let Some(event_header) = request
+    .headers()
+    .get(EVENT_NAME_HEADER_NAME)
+    .and_then(|v| v.to_str().ok())
+  {
+    let event = EventName::new(event_header)?;
+    let target = if let Some(target_header) = request
+      .headers()
+      .get(EVENT_TARGET_HEADER_NAME)
+      .and_then(|v| v.to_str().ok())
+    {
+      serde_json::from_str::<EventTarget>(target_header)?
+    } else {
+      return Err(anyhow::anyhow!("missing event target header").into());
+    };
+
+    match request.body() {
+      InvokeBody::Json(payload) => app.emit_to(target, event.as_str(), payload),
+      InvokeBody::Raw(payload) => app.emit_raw_to(target, event.as_str(), payload.clone()),
+    }
+  } else if let InvokeBody::Json(payload) = request.body() {
+    let args: EmitToArgs = serde_json::from_value(payload.clone())?;
+    app.emit_to(args.target, args.event.as_str(), args.payload)
+  } else {
+    Err(anyhow::anyhow!("unexpected emit request format").into())
+  }
+}
+
+#[derive(Deserialize)]
+struct EmitToArgs {
   event: EventName,
-  payload: Option<JsonValue>,
-) -> Result<()> {
-  app.emit_to(target, event.as_str(), payload)
+  payload: Option<serde_json::Value>,
+  target: EventTarget,
+}
+
+#[command(root = "crate")]
+fn fetch_payload(
+  request: Request<'_>,
+  store: State<'_, EventPayloadStore>,
+) -> std::result::Result<Response, &'static str> {
+  if let Some(id) = request
+    .headers()
+    .get(PAYLOAD_ID_HEADER_NAME)
+    .and_then(|v| v.to_str().ok())
+    .and_then(|id| id.parse().ok())
+  {
+    let r = if let Some(data) = store.0.lock().unwrap().get(&id) {
+      // fetch_add returns the previous value so we must +1
+      let read_count = data
+        .read_count
+        .fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+        + 1;
+
+      Ok((
+        Response::new(data.payload.clone()),
+        read_count == data.target_count,
+      ))
+    } else {
+      Err("data not found")
+    };
+
+    match r {
+      Ok((response, done)) => {
+        if done {
+          store.0.lock().unwrap().remove(&id);
+        }
+        Ok(response)
+      }
+      Err(e) => Err(e),
+    }
+  } else {
+    Err("missing payload id header")
+  }
 }
 
 /// Initializes the event plugin.
@@ -70,7 +161,7 @@ pub(crate) fn init<R: Runtime, M: Manager<R>>(manager: &M) -> TauriPlugin<R> {
   Builder::new("event")
     .invoke_handler(crate::generate_handler![
       #![plugin(event)]
-      listen, unlisten, emit, emit_to
+      listen, unlisten, emit, emit_to, fetch_payload
     ])
     .js_init_script(
       init_script