Function tauri::api::ipc::format_callback

pub fn format_callback<T: Serialize>(
    function_name: CallbackFn,
    arg: &T
) -> Result<String>

Formats a function name and argument to be evaluated as callback.

This will serialize primitive JSON types (e.g. booleans, strings, numbers, etc.) as JavaScript literals, but will serialize arrays and objects whose serialized JSON string is smaller than 1 GB and larger than 10 KiB with JSON.parse('...'). See json-parse-benchmark.

Examples

• With string literals:

use tauri::api::ipc::{CallbackFn, format_callback};
// callback with a string argument
let cb = format_callback(CallbackFn(12345), &"the string response").unwrap();
assert!(cb.contains(r#"window["_12345"]("the string response")"#));

• With types implement serde::Serialize:

use tauri::api::ipc::{CallbackFn, format_callback};
use serde::Serialize;

// callback with large JSON argument
#[derive(Serialize)]
struct MyResponse {
  value: String
}

let cb = format_callback(
  CallbackFn(6789),
  &MyResponse { value: String::from_utf8(vec![b'X'; 10_240]).unwrap()
}).expect("failed to serialize");

assert!(cb.contains(r#"window["_6789"](JSON.parse('{"value":"XXXXXXXXX"#));

Examples found in repository

src/api/ipc.rs (line 217)

pub fn format_callback_result<T: Serialize, E: Serialize>(
  result: Result<T, E>,
  success_callback: CallbackFn,
  error_callback: CallbackFn,
) -> crate::api::Result<String> {
  match result {
    Ok(res) => format_callback(success_callback, &res),
    Err(err) => format_callback(error_callback, &err),
  }
}

src/hooks.rs (line 271)

pub fn window_invoke_responder<R: Runtime>(
  window: Window<R>,
  response: InvokeResponse,
  success_callback: CallbackFn,
  error_callback: CallbackFn,
) {
  let callback_string =
    match format_callback_result(response.into_result(), success_callback, error_callback) {
      Ok(callback_string) => callback_string,
      Err(e) => format_callback(error_callback, &e.to_string())
        .expect("unable to serialize response string to json"),
    };

  let _ = window.eval(&callback_string);
}

src/endpoints/global_shortcut.rs (line 115)

fn register_shortcut<R: Runtime>(
  window: crate::Window<R>,
  manager: &mut R::GlobalShortcutManager,
  shortcut: String,
  handler: CallbackFn,
) -> super::Result<()> {
  let accelerator = shortcut.clone();
  manager
    .register(&shortcut, move || {
      let callback_string = crate::api::ipc::format_callback(handler, &accelerator)
        .expect("unable to serialize shortcut string to json");
      let _ = window.eval(callback_string.as_str());
    })
    .map_err(crate::error::into_anyhow)?;
  Ok(())
}

src/endpoints/shell.rs (line 170)

  fn execute<R: Runtime>(
    context: InvokeContext<R>,
    program: String,
    args: ExecuteArgs,
    on_event_fn: CallbackFn,
    options: CommandOptions,
  ) -> super::Result<ChildId> {
    let mut command = if options.sidecar {
      #[cfg(not(shell_sidecar))]
      return Err(crate::Error::ApiNotAllowlisted("shell > sidecar".to_string()).into_anyhow());
      #[cfg(shell_sidecar)]
      {
        let program = PathBuf::from(program);
        let program_as_string = program.display().to_string();
        let program_no_ext_as_string = program.with_extension("").display().to_string();
        let configured_sidecar = context
          .config
          .tauri
          .bundle
          .external_bin
          .as_ref()
          .map(|bins| {
            bins
              .iter()
              .find(|b| b == &&program_as_string || b == &&program_no_ext_as_string)
          })
          .unwrap_or_default();
        if let Some(sidecar) = configured_sidecar {
          context
            .window
            .state::<Scopes>()
            .shell
            .prepare_sidecar(&program.to_string_lossy(), sidecar, args)
            .map_err(crate::error::into_anyhow)?
        } else {
          return Err(crate::Error::SidecarNotAllowed(program).into_anyhow());
        }
      }
    } else {
      #[cfg(not(shell_execute))]
      return Err(crate::Error::ApiNotAllowlisted("shell > execute".to_string()).into_anyhow());
      #[cfg(shell_execute)]
      match context
        .window
        .state::<Scopes>()
        .shell
        .prepare(&program, args)
      {
        Ok(cmd) => cmd,
        Err(e) => {
          #[cfg(debug_assertions)]
          eprintln!("{}", e);
          return Err(crate::Error::ProgramNotAllowed(PathBuf::from(program)).into_anyhow());
        }
      }
    };
    #[cfg(any(shell_execute, shell_sidecar))]
    {
      if let Some(cwd) = options.cwd {
        command = command.current_dir(cwd);
      }
      if let Some(env) = options.env {
        command = command.envs(env);
      } else {
        command = command.env_clear();
      }
      if let Some(encoding) = options.encoding {
        if let Some(encoding) = crate::api::process::Encoding::for_label(encoding.as_bytes()) {
          command = command.encoding(encoding);
        } else {
          return Err(anyhow::anyhow!(format!("unknown encoding {}", encoding)));
        }
      }
      let (mut rx, child) = command.spawn()?;

      let pid = child.pid();
      command_child_store().lock().unwrap().insert(pid, child);

      crate::async_runtime::spawn(async move {
        while let Some(event) = rx.recv().await {
          if matches!(event, crate::api::process::CommandEvent::Terminated(_)) {
            command_child_store().lock().unwrap().remove(&pid);
          }
          let js = crate::api::ipc::format_callback(on_event_fn, &event)
            .expect("unable to serialize CommandEvent");

          let _ = context.window.eval(js.as_str());
        }
      });

      Ok(pid)
    }
  }