on_message 与分发

  fn is_local_url(&self, current_url: &Url) -> bool {
    let uses_https = current_url.scheme() == "https";

    // if from `tauri://` custom protocol
    ({
      let protocol_url = self.manager().tauri_protocol_url(uses_https);
      current_url.scheme() == protocol_url.scheme()
      && current_url.domain() == protocol_url.domain()
    }) ||

    // or if relative to `devUrl` or `frontendDist`
      self
          .manager()
          .get_app_url(uses_https)
          .make_relative(current_url)
          .is_some()

      // or from a custom protocol registered by the user
      || ({
        let scheme = current_url.scheme();
        let protocols = self.manager().webview.uri_scheme_protocols.lock().unwrap();

        #[cfg(all(not(windows), not(target_os = "android")))]
        let local = protocols.contains_key(scheme);
        // ...
        local
      })
  }

    let plugin_command = request.cmd.strip_prefix("plugin:").map(|raw_command| {
      let mut tokens = raw_command.split('|');
      // safe to unwrap: split always has a least one item
      let plugin = tokens.next().unwrap();
      let command = tokens.next().map(|c| c.to_string()).unwrap_or_default();
      (plugin, command)
    });

    // Check ACL on plugin commands, when the app defined its ACL manifest,
    // or when the request comes from a non-local (remote) origin.  This
    // ensures remote content can never reach custom commands unless an
    // explicit `remote` capability has been configured for them.
    if (plugin_command.is_some() || has_app_acl_manifest || !is_local)
      // TODO: Remove this special check in v3
      && request.cmd != crate::ipc::channel::FETCH_CHANNEL_DATA_COMMAND
      && invoke.acl.is_none()
    {
      #[cfg(debug_assertions)]
      {
        // ...
        invoke.resolver.reject(
          manager
            .runtime_authority
            .lock()
            .unwrap()
            .resolve_access_message(
              key,
              &command_name,
              invoke.message.webview.window().label(),
              invoke.message.webview.label(),
              &acl_origin,
            ),
        );
      }
      #[cfg(not(debug_assertions))]
      invoke
        .resolver
        .reject(format!("Command {} not allowed by ACL", request.cmd));
      return;
    }

#[tauri::command]
fn greet(name: &str) -> String {
  format!("hello, {name}")
}

#[tauri::command]
fn secret() -> &'static str {
  "the secret"
}

#[tauri::command]
fn hidden() -> &'static str {
  "not in the app manifest"
}

#[tauri::command]
fn report(app: tauri::AppHandle, msg: String) {
  println!("REPORT {msg}");
  app.exit(0);
}

fn main() {
  // ... 15 秒看门狗
  tauri::Builder::default()
    .invoke_handler(tauri::generate_handler![greet, secret, hidden, report])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");
}

<script>
(async () => {
  const inv = window.__TAURI_INTERNALS__.invoke;
  const out = {};
  for (const [cmd, args] of [['greet', { name: 'rie' }], ['secret', {}], ['hidden', {}], ['nope', {}], ['plugin:event|nope', {}]]) {
    try { out[cmd] = { ok: await inv(cmd, args) }; } catch (e) { out[cmd] = { err: e }; }
  }
  await inv('report', { msg: JSON.stringify(out, null, 1) });
})();
</script>

fn main() {
  let attributes = tauri_build::Attributes::new()
    .app_manifest(tauri_build::AppManifest::new().commands(&["greet", "secret", "report"]));
  tauri_build::try_build(attributes).expect("failed to run tauri-build");
}

{
  "identifier": "default",
  "windows": ["main"],
  "permissions": ["core:default", "allow-greet", "allow-report"]
}

REPORT {
 "greet": {
  "ok": "hello, rie"
 },
 "secret": {
  "ok": "the secret"
 },
 "hidden": {
  "ok": "not in the app manifest"
 },
 "nope": {
  "err": "Command nope not found"
 },
 "plugin:event|nope": {
  "err": "event.nope not allowed. Command not found"
 }
}

REPORT {
 "greet": {
  "ok": "hello, rie"
 },
 "secret": {
  "err": "secret not allowed. Permissions associated with this command: allow-secret"
 },
 "hidden": {
  "err": "hidden not allowed. Command not found"
 },
 "nope": {
  "err": "nope not allowed. Command not found"
 },
 "plugin:event|nope": {
  "err": "event.nope not allowed. Command not found"
 }
}

REPORT {
 "greet": {
  "ok": "hello, rie"
 },
 "secret": {
  "err": "Command secret not allowed by ACL"
 },
 "hidden": {
  "err": "Command hidden not allowed by ACL"
 },
 "nope": {
  "err": "Command nope not allowed by ACL"
 },
 "plugin:event|nope": {
  "err": "Command plugin:event|nope not allowed by ACL"
 }
}

fn demo<R: Runtime>() -> TauriPlugin<R> {
  tauri::plugin::Builder::new("demo")
    .invoke_handler(tauri::generate_handler![ping])
    .build()
}

  fn app_with(allow: &[&str], app_acl: bool) -> (tauri::App<MockRuntime>, WebviewWindow<MockRuntime>) {
    let mut ctx = mock_context(noop_assets());
    if app_acl {
      *ctx.runtime_authority_mut() = RuntimeAuthority::new(
        Default::default(),
        Resolved {
          has_app_acl: true,
          ..Default::default()
        },
      );
    }
    for c in allow {
      ctx
        .runtime_authority_mut()
        .__allow_command(c.to_string(), ExecutionContext::Local);
    }
    let app = handlers(mock_builder()).build(ctx).unwrap();
    let w = WebviewWindowBuilder::new(&app, "main", Default::default())
      .build()
      .unwrap();
    (app, w)
  }

== dispatch (release), no app ACL manifest, nothing allowed
greet        local  => Ok(Json "hello, rie")
greet        remote => Err("Command greet not allowed by ACL")
nope         local  => Err("Command nope not found")
nope         remote => Err("Command nope not allowed by ACL")
plugin:demo|ping    local  => Err("Command plugin:demo|ping not allowed by ACL")
plugin:__TAURI_CHANNEL__|fetch local  => Err("missing channel id header")
plugin:__TAURI_CHANNEL__|fetch remote => Err("missing channel id header")
== dispatch (release), plugin commands allowed for local
plugin:demo|ping    local  => Ok(Json "pong")
plugin:demo|ping    remote => Err("Command plugin:demo|ping not allowed by ACL")
plugin:demo|missing local  => Err("Command missing not found")
plugin:ghost|x      local  => Err("plugin ghost not found")
plugin:demo         local  => Err("Command  not found")
== dispatch (release), has_app_acl = true
greet        local  => Err("Command greet not allowed by ACL")
nope         local  => Err("Command nope not allowed by ACL")
greet (allowed) local => Ok(Json "hello, rie")

    if let Some((plugin, command_name)) = plugin_command {
      invoke.message.command = command_name;

      #[cfg(desktop)]
      let command = invoke.message.command.clone();
      // ...
      #[allow(unused_mut)]
      let mut handled = manager.run_plugin_invoke_handler(plugin, invoke);

      if handled {
        return;
      }
      // ... (mobile: 交给 Android / iOS 插件)
      #[cfg(desktop)]
      resolver.reject(format!("Command {command} not found"));
    } else {
      let command = invoke.message.command.clone();
      let handled = manager.run_invoke_handler(invoke);
      if !handled {
        resolver.reject(format!("Command {command} not found"));
      }
    }

 "nope": {
  "err": "Command nope not allowed by ACL"
 },

 "nope": {
  "err": "Command nope not found"
 },