Struct tauri::InvokeResolver

pub struct InvokeResolver<R: Runtime = Wry> { /* private fields */ }

Resolver of a invoke message.

Implementations

impl<R: Runtime> InvokeResolver<R>

pub fn respond_async<T, F>(self, task: F)where
    T: Serialize,
    F: Future<Output = Result<T, InvokeError>> + Send + 'static,

Reply to the invoke promise with an async task.

Examples found in repository

src/endpoints.rs (lines 114-119)

  fn run<R: Runtime>(
    self,
    window: Window<R>,
    resolver: InvokeResolver<R>,
    config: Arc<Config>,
    package_info: PackageInfo,
  ) {
    let context = InvokeContext {
      window,
      config,
      package_info,
    };
    match self {
      Self::App(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      #[cfg(process_any)]
      Self::Process(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      #[cfg(fs_any)]
      Self::Fs(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      #[cfg(path_any)]
      Self::Path(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      #[cfg(os_any)]
      Self::Os(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      Self::Window(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .await
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      #[cfg(shell_any)]
      Self::Shell(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      Self::Event(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      #[cfg(dialog_any)]
      Self::Dialog(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      #[cfg(cli)]
      Self::Cli(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      Self::Notification(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      #[cfg(http_any)]
      Self::Http(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .await
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      #[cfg(global_shortcut_any)]
      Self::GlobalShortcut(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
      #[cfg(clipboard_any)]
      Self::Clipboard(cmd) => resolver.respond_async(async move {
        cmd
          .run(context)
          .and_then(|r| r.json)
          .map_err(InvokeError::from_anyhow)
      }),
    }
  }

pub fn respond_async_serialized<F>(self, task: F)where
    F: Future<Output = Result<JsonValue, InvokeError>> + Send + 'static,

Reply to the invoke promise with an async task which is already serialized.

pub fn respond<T: Serialize>(self, value: Result<T, InvokeError>)

Reply to the invoke promise with a serializable value.

Examples found in repository

src/command.rs (line 189)

    pub fn block<R, T>(self, value: T, resolver: InvokeResolver<R>)
    where
      R: Runtime,
      T: Serialize,
    {
      resolver.respond(Ok(value))
    }

    #[inline(always)]
    pub fn future<T>(self, value: T) -> impl Future<Output = Result<Value, InvokeError>>
    where
      T: Serialize,
    {
      std::future::ready(serde_json::to_value(value).map_err(InvokeError::from_serde_json))
    }
  }

  // ===== Result<impl Serialize, impl Into<InvokeError>> =====

  pub struct ResultTag;

  pub trait ResultKind {
    #[inline(always)]
    fn blocking_kind(&self) -> ResultTag {
      ResultTag
    }

    #[inline(always)]
    fn async_kind(&self) -> ResultTag {
      ResultTag
    }
  }

  impl<T: Serialize, E: Into<InvokeError>> ResultKind for Result<T, E> {}

  impl ResultTag {
    #[inline(always)]
    pub fn block<R, T, E>(self, value: Result<T, E>, resolver: InvokeResolver<R>)
    where
      R: Runtime,
      T: Serialize,
      E: Into<InvokeError>,
    {
      resolver.respond(value.map_err(Into::into))
    }

pub fn resolve<T: Serialize>(self, value: T)

Resolve the invoke promise with a value.

pub fn reject<T: Serialize>(self, value: T)

Reject the invoke promise with a value.

Examples found in repository

src/plugin.rs (line 591)

  pub(crate) fn extend_api(&mut self, mut invoke: Invoke<R>) {
    let command = invoke.message.command.replace("plugin:", "");
    let mut tokens = command.split('|');
    // safe to unwrap: split always has a least one item
    let target = tokens.next().unwrap();

    if let Some(plugin) = self.store.get_mut(target) {
      invoke.message.command = tokens
        .next()
        .map(|c| c.to_string())
        .unwrap_or_else(String::new);
      plugin.extend_api(invoke);
    } else {
      invoke
        .resolver
        .reject(format!("plugin {} not found", target));
    }
  }

src/endpoints.rs (lines 240-243)

pub(crate) fn handle<R: Runtime>(
  module: String,
  invoke: Invoke<R>,
  config: Arc<Config>,
  package_info: &PackageInfo,
) {
  let Invoke { message, resolver } = invoke;
  let InvokeMessage {
    mut payload,
    window,
    ..
  } = message;

  if let JsonValue::Object(ref mut obj) = payload {
    obj.insert("module".to_string(), JsonValue::String(module.clone()));
  }

  match serde_json::from_value::<Module>(payload) {
    Ok(module) => module.run(window, resolver, config, package_info.clone()),
    Err(e) => {
      let message = e.to_string();
      if message.starts_with("unknown variant") {
        let mut s = message.split('`');
        s.next();
        if let Some(unknown_variant_name) = s.next() {
          if unknown_variant_name == module {
            return resolver.reject(format!(
              "The `{}` module is not enabled. You must enable one of its APIs in the allowlist.",
              module
            ));
          } else if module == "Window" {
            return resolver.reject(window::into_allowlist_error(unknown_variant_name).to_string());
          }
        }
      }
      resolver.reject(message);
    }
  }
}

pub fn invoke_error(self, error: InvokeError)

Reject the invoke promise with an InvokeError.

pub async fn return_task<T, F>(
    window: Window<R>,
    task: F,
    success_callback: CallbackFn,
    error_callback: CallbackFn
)where
    T: Serialize,
    F: Future<Output = Result<T, InvokeError>> + Send + 'static,

Asynchronously executes the given task and evaluates its Result to the JS promise described by the success_callback and error_callback function names.

If the Result is_ok(), the callback will be the success_callback function name and the argument will be the Ok value. If the Result is_err(), the callback will be the error_callback function name and the argument will be the Err value.

Examples found in repository

src/hooks.rs (line 186)

  pub fn respond_async<T, F>(self, task: F)
  where
    T: Serialize,
    F: Future<Output = Result<T, InvokeError>> + Send + 'static,
  {
    crate::async_runtime::spawn(async move {
      Self::return_task(self.window, task, self.callback, self.error).await;
    });
  }

Trait Implementations

impl<R: Debug + Runtime> Debug for InvokeResolver<R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.