参数、返回值与 InvokeResolver

impl<'de, D: Deserialize<'de>, R: Runtime> CommandArg<'de, R> for D {
  fn from_command(command: CommandItem<'de, R>) -> Result<D, InvokeError> {
    let name = command.name;
    let arg = command.key;
    #[cfg(feature = "tracing")]
    let _span = tracing::trace_span!("ipc::request::deserialize_arg", arg = arg).entered();
    Self::deserialize(command).map_err(|e| crate::Error::InvalidArgs(name, arg, e).into())
  }
}

  fn deserialize_json(self) -> serde_json::Result<&'a serde_json::Value> {
    if self.key.is_empty() {
      return Err(serde_json::Error::custom(format!(
        "command {} has an argument with no name with a non-optional value",
        self.name
      )));
    }

    match &self.message.payload {
      InvokeBody::Raw(_body) => Err(serde_json::Error::custom(format!(
        "command {} expected a value for key {} but the IPC call used a bytes payload",
        self.name, self.key
      ))),
      InvokeBody::Json(v) => match v.get(self.key) {
        Some(value) => Ok(value),
        None => Err(serde_json::Error::custom(format!(
          "command {} missing required key {}",
          self.name, self.key
        ))),
      },
    }
  }

#[derive(Debug, Deserialize)]
struct Query {
  page_size: u32,
  tag: Option<String>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct QueryCamel {
  page_size: u32,
}

#[tauri::command]
fn args(user_id: u32, note: Option<String>) -> String {
  format!("user_id={user_id} note={note:?}")
}

#[tauri::command(rename_all = "snake_case")]
fn args_snake(user_id: u32) -> u32 {
  user_id
}

#[tauri::command]
fn nested(query: Query) -> String {
  format!("{query:?}")
}

#[tauri::command]
fn nested_camel(query: QueryCamel) -> u32 {
  query.page_size
}

#[tauri::command]
fn small(n: u8) -> u8 {
  n
}

#[tauri::command]
fn opt_only(note: Option<String>) -> String {
  format!("{note:?}")
}

#[tauri::command]
fn unnamed(_: u32) {}

args {"userId":1,"note":"hi"} => Ok(Json "user_id=1 note=Some(\"hi\")")
args {"userId":1} => Ok(Json "user_id=1 note=None")
args {"userId":1,"note":null} => Ok(Json "user_id=1 note=None")
args {"user_id":1} => Err("invalid args `userId` for command `args`: command args missing required key userId")
args {"userId":"1"} => Err("invalid args `userId` for command `args`: invalid type: string \"1\", expected u32")
args {"userId":-1} => Err("invalid args `userId` for command `args`: invalid value: integer `-1`, expected u32")
args {"userId":1.5} => Err("invalid args `userId` for command `args`: invalid type: floating point `1.5`, expected u32")
args {"userId":1,"note":5} => Err("invalid args `note` for command `args`: invalid type: integer `5`, expected a string")
args {"userId":1,"extra":true} => Ok(Json "user_id=1 note=None")
args [1,"hi"] => Err("invalid args `userId` for command `args`: command args missing required key userId")
args_snake {"user_id":7} => Ok(Json 7)
args_snake {"userId":7} => Err("invalid args `user_id` for command `args_snake`: command args_snake missing required key user_id")
nested {"query":{"page_size":10}} => Ok(Json "Query { page_size: 10, tag: None }")
nested {"query":{"pageSize":10}} => Err("invalid args `query` for command `nested`: missing field `page_size`")
nested {"query":{"page_size":10,"tag":"x"}} => Ok(Json "Query { page_size: 10, tag: Some(\"x\") }")
nested_camel {"query":{"pageSize":10}} => Ok(Json 10)
small {"n":300} => Err("invalid args `n` for command `small`: invalid value: integer `300`, expected u8")
small {"n":null} => Err("invalid args `n` for command `small`: invalid type: null, expected u8")
unnamed {"":1} => Err("invalid args `` for command `unnamed`: command unnamed has an argument with no name with a non-optional value")
...
args <3 bytes> => Err("invalid args `userId` for command `args`: command args expected a value for key userId but the IPC call used a bytes payload")
opt_only <3 bytes> => Err("invalid args `note` for command `opt_only`: command opt_only expected a value for key note but the IPC call used a bytes payload")
opt_only {} => Ok(Json "None")

#[tauri::command]
fn raw_in(request: Request<'_>) -> String {
  let ct = request
    .headers()
    .get("content-type")
    .and_then(|v| v.to_str().ok())
    .unwrap_or("-")
    .to_string();
  match request.body() {
    InvokeBody::Raw(b) => format!("Raw {:?} content-type={ct}", &b[..b.len().min(8)]),
    InvokeBody::Json(v) => format!("Json {v} content-type={ct}"),
  }
}

  out.rawU8 = await attempt('raw_in', new Uint8Array([1, 2, 3]));
  out.rawBuf = await attempt('raw_in', new Uint8Array([4, 5]).buffer);
  out.rawArray = await attempt('raw_in', [1, 2, 3]);
  out.u8InObject = await attempt('raw_in', { data: new Uint8Array([1, 2, 3]) });

  "rawU8": {
   "ok": "Raw [1, 2, 3] content-type=application/octet-stream"
  },
  "rawBuf": {
   "ok": "Raw [4, 5] content-type=application/octet-stream"
  },
  "rawArray": {
   "ok": "Raw [49, 44, 50, 44, 51] content-type=application/octet-stream"
  },
  "u8InObject": {
   "ok": "Json {\"data\":[1,2,3]} content-type=application/json"
  },

impl<T: Serialize> IpcResponse for T {
  fn body(self) -> crate::Result<InvokeResponseBody> {
    serde_json::to_string(&self)
      .map(Into::into)
      .map_err(Into::into)
  }
}

/// The IPC response.
pub struct Response {
  body: InvokeResponseBody,
}

impl IpcResponse for Response {
  fn body(self) -> crate::Result<InvokeResponseBody> {
    Ok(self.body)
  }
}

#[tauri::command]
fn raw_out(n: usize) -> Response {
  Response::new(vec![7u8; n])
}

#[tauri::command]
fn bytes_out(n: usize) -> Vec<u8> {
  vec![7u8; n]
}

  "rawOut": {
   "ok": "ArrayBuffer(5)"
  },
  "bytesOut": {
   "ok": [
    7,
    7,
    7,
    7,
    7
   ]
  }

bad_ok {} => Err("JSON error: key must be a string")

impl<T: Serialize> From<T> for InvokeError {
  #[inline]
  fn from(value: T) -> Self {
    serde_json::to_value(value)
      .map(Self)
      .unwrap_or_else(Self::from_error)
  }
}

#[derive(Debug, Serialize)]
#[serde(tag = "kind", content = "message")]
enum MyError {
  NotFound(String),
  Denied { user: String },
}

#[tauri::command]
fn fail(which: &str) -> Result<String, MyError> {
  match which {
    "nf" => Err(MyError::NotFound(format!("no item {which}"))),
    "denied" => Err(MyError::Denied { user: "rie".into() }),
    _ => Ok("fine".into()),
  }
}

  "failNf": {
   "err": {
    "kind": "NotFound",
    "message": "no item nf"
   },
   "type": "object"
  },
  "failDenied": {
   "err": {
    "kind": "Denied",
    "message": {
     "user": "rie"
    }
   },
   "type": "object"
  },
  "missing": {
   "err": "invalid args `name` for command `greet`: command greet missing required key name",
   "type": "string"
  },

error[E0599]: the method `blocking_kind` exists for reference `&Result<Vec<u8>, std::io::Error>`, but its trait bounds were not satisfied
   --> src/main.rs:129:1
    |
129 |   #[tauri::command]
    |   ^^^^^^^^^^^^^^^^^ method cannot be called on `&Result<Vec<u8>, std::io::Error>` due to unsatisfied trait bounds
...
    = note: the following trait bounds were not satisfied:
            `std::io::Error: Into<InvokeError>`
            which is required by `Result<Vec<u8>, std::io::Error>: tauri::ipc::private::ResultKind`
            `Result<Vec<u8>, std::io::Error>: IpcResponse`
            which is required by `&Result<Vec<u8>, std::io::Error>: tauri::ipc::private::ResponseKind`
    = note: this error originates in the macro `__cmd__io_direct` which comes from the expansion of the macro `tauri::generate_handler` (in Nightly builds, run with -Z macro-backtrace for more info)

#[derive(Debug)]
struct IoError(std::io::Error);

impl Serialize for IoError {
  fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
    s.serialize_str(&self.0.to_string())
  }
}

fail_io {} => Err("No such file or directory (os error 2)")
fail_string {} => Err("plain string")
bad_err {} => Err("key must be a string")

    (responder.lock().unwrap().take().expect("resolver consumed"))(
      webview,
      cmd,
      response,
      success_callback,
      error_callback,
    );

  pub fn respond_async_serialized<F>(self, task: F)
  where
    F: Future<Output = Result<InvokeResponseBody, InvokeError>> + Send + 'static,
  {
    // Dynamic dispatch the call in dev for a faster compile time
    // TODO: Revisit this and see if we can do this for the release build as well if the performance hit is not a problem
    #[cfg(debug_assertions)]
    {
      self.respond_async_serialized_dyn(Box::pin(task))
    }
    #[cfg(not(debug_assertions))]
    {
      self.respond_async_serialized_inner(task)
    }
  }

#[tauri::command]
fn sleep_sync(ms: u64) -> String {
  std::thread::sleep(std::time::Duration::from_millis(ms));
  format!("slept {ms} ms on {}", thread_name())
}

#[tauri::command]
async fn sleep_async(ms: u64) -> String {
  std::thread::sleep(std::time::Duration::from_millis(ms));
  format!("slept {ms} ms on {}", thread_name())
}

function spin(ms) {
  // count event-loop turns with MessageChannel (setTimeout is throttled in a hidden window)
  return new Promise((resolve) => {
    const mc = new MessageChannel();
    let n = 0;
    const until = performance.now() + ms;
    mc.port1.onmessage = () => {
      n++;
      if (performance.now() < until) mc.port2.postMessage(0); else resolve(n);
    };
    mc.port2.postMessage(0);
  });
}
async function blockTest(cmd) {
  let ticks = 0;
  const id = setInterval(() => ticks++, 10);
  const idleTurns = await spin(300);
  const idleTicks = ticks;
  ticks = 0;
  const t0 = performance.now();
  const p = inv(cmd, { ms: 1000 });
  await new Promise(r => setTimeout(r, 0));
  const g0 = performance.now();
  const gp = inv('greet', { name: 'x' }).then(() => Math.round(performance.now() - g0));
  const ap = fetch('tauri://localhost/index.html').then(r => r.text()).then(() => Math.round(performance.now() - g0));
  const busyTurns = await spin(300);
  // ... 等 p、gp、ap 全部落定后记录
}

REPORT {
 "mode": "block",
 "data": [
  {
   "cmd": "sleep_sync",
   "result": "slept 1000 ms on main",
   "totalMs": 1002,
   "eventLoopTurnsIn300msIdle": 16291,
   "eventLoopTurnsIn300msDuring": 17099,
   "setInterval10msTicksIdle300ms": 6,
   "setInterval10msTicksDuring": 1,
   "greetLatencyMs": 1002,
   "assetLatencyMs": 1002
  },
  {
   "cmd": "sleep_async",
   "result": "slept 1000 ms on tokio-rt-worker",
   "totalMs": 1006,
   "eventLoopTurnsIn300msIdle": 7356,
   "eventLoopTurnsIn300msDuring": 4627,
   "setInterval10msTicksIdle300ms": 6,
   "setInterval10msTicksDuring": 1,
   "greetLatencyMs": 1,
   "assetLatencyMs": 1
  }
 ]
}

   "cmd": "sleep_sync",
...
   "greetLatencyMs": 1002,
   "assetLatencyMs": 1002