AppManager 与 Manager trait

pub struct AppManager<R: Runtime> {
  pub runtime_authority: Mutex<RuntimeAuthority>,
  pub window: window::WindowManager<R>,
  pub webview: webview::WebviewManager<R>,
  #[cfg(all(desktop, feature = "tray-icon"))]
  pub tray: tray::TrayManager<R>,
  #[cfg(desktop)]
  pub menu: menu::MenuManager<R>,

  pub(crate) plugins: Mutex<PluginStore<R>>,
  pub listeners: Listeners,
  pub state: Arc<StateManager>,
  pub config: Config,
  #[cfg(dev)]
  pub config_parent: Option<std::path::PathBuf>,
  pub assets: Box<dyn Assets<R>>,

  pub app_icon: Option<Vec<u8>>,

  pub package_info: PackageInfo,

  /// Application pattern.
  pub pattern: Arc<Pattern>,

  /// Global API scripts collected from plugins.
  pub plugin_global_api_scripts: Arc<Option<&'static [&'static str]>>,

  /// Application Resources Table
  pub(crate) resources_table: Arc<Mutex<ResourceTable>>,

  /// Runtime-generated invoke key.
  pub(crate) invoke_key: String,

  pub(crate) channel_interceptor: Option<ChannelInterceptor<R>>,

  /// Sets to true in [`AppHandle::request_restart`] and [`AppHandle::restart`]
  /// and we will call `restart` on the next `RuntimeRunEvent::Exit` event
  pub(crate) restart_on_exit: AtomicBool,
}

pub struct Webview<R: Runtime> {
  pub(crate) window: Arc<Mutex<Window<R>>>,
  /// The webview created by the runtime.
  pub(crate) webview: DetachedWebview<EventLoopMessage, R>,
  /// The manager to associate this webview with.
  pub(crate) manager: Arc<AppManager<R>>,
  pub(crate) app_handle: AppHandle<R>,
  pub(crate) resources_table: Arc<Mutex<ResourceTable>>,
  use_https_scheme: bool,
}

  fn get_webview_window(&self, label: &str) -> Option<WebviewWindow<R>> {
    self.manager().get_webview(label).and_then(|webview| {
      let window = webview.window();
      if window.is_webview_window() {
        Some(WebviewWindow { window, webview })
      } else {
        None
      }
    })
  }

  pub(crate) fn on_window_close(&self, label: &str) {
    let window = self.window.windows_lock().remove(label);
    if let Some(window) = window {
      for webview in window.webviews() {
        self.webview.webviews_lock().remove(webview.label());
        self.listeners().remove_webview_listeners(webview.label());
        self
          .state
          .get::<crate::ipc::channel::ChannelDataIpcQueue>()
          .remove_webview_entries(webview.label());
      }
    }
    // window listeners are removed by the window's own event handler after it emits `tauri://destroyed`,
    // since the run callback (which calls this function) runs before the window event handlers
  }

pub trait Manager<R: Runtime>: sealed::ManagerBase<R> {

pub(crate) mod sealed {
  // ...
  /// A running [`Runtime`] or a dispatcher to it.
  pub enum RuntimeOrDispatch<'r, R: Runtime> {
    /// Reference to the running [`Runtime`].
    Runtime(&'r R),

    /// Handle to the running [`Runtime`].
    RuntimeHandle(R::Handle),

    /// A dispatcher to the running [`Runtime`].
    Dispatch(R::WindowDispatcher),
  }

  /// Managed handle to the application runtime.
  pub trait ManagerBase<R: Runtime> {
    fn manager(&self) -> &AppManager<R>;
    fn manager_owned(&self) -> Arc<AppManager<R>>;
    fn runtime(&self) -> RuntimeOrDispatch<'_, R>;
    fn managed_app_handle(&self) -> &AppHandle<R>;
    // ... android / ios
  }
}

mod sealed_try {
  struct MyManager;
  impl tauri::Manager<tauri::Wry> for MyManager {
    fn resources_table(&self) -> std::sync::MutexGuard<'_, tauri::ResourceTable> {
      unimplemented!()
    }
  }
}

error[E0277]: the trait bound `MyManager: tauri::sealed::ManagerBase<tauri_runtime_wry::Wry<EventLoopMessage>>` is not satisfied
   --> src/main.rs:219:39
    |
219 |   impl tauri::Manager<tauri::Wry> for MyManager {
    |                                       ^^^^^^^^^ unsatisfied trait bound
    |
help: the trait `tauri::sealed::ManagerBase<tauri_runtime_wry::Wry<EventLoopMessage>>` is not implemented for `MyManager`
...
    = note: `Manager` is a "sealed trait", because to implement it you also need to implement `tauri::sealed::ManagerBase`, which is not accessible; this is usually done to force you to use one of the provided types that already implement it
    = help: the following types implement the trait:
              tauri::AppHandle<R>
              tauri::App<R>
              tauri::WebviewWindow<R>
              tauri::Webview<R>
              tauri::Window<R>

  pub fn run_invoke_handler(&self, invoke: Invoke<R>) -> bool {
    (self.webview.invoke_handler)(invoke)
  }

  /// Runs the plugin [`crate::plugin::Plugin::extend_api`] hook if it exists. Returns whether the invoke message was handled or not.
  ///
  /// The message is not handled when the plugin exists **and** the command does not.
  pub fn run_plugin_invoke_handler(&self, plugin: &str, invoke: Invoke<R>) -> bool {
    self
      .plugins
      .lock()
      .expect("poisoned plugin store")
      .run_invoke_handler(plugin, invoke)
  }

  pub(crate) fn emit<S: Serialize>(
    &self,
    event: EventName<&str>,
    payload: EmitPayload<'_, S>,
  ) -> crate::Result<()> {
    #[cfg(feature = "tracing")]
    let _span = tracing::debug_span!("emit::run").entered();
    let emit_args = match payload {
      EmitPayload::Serialize(payload) => EmitArgs::new(event, payload)?,
      EmitPayload::Str(payload) => EmitArgs::new_str(event, payload)?,
    };

    let listeners = self.listeners();

    listeners.emit_js(self.webview.webviews_lock().values(), &emit_args)?;
    listeners.emit(emit_args)?;

    Ok(())
  }

    match self.inner.handlers.try_lock() {
      Err(_) => self.insert_pending(Pending::Emit(emit_args)),
      Ok(lock) => {
        if let Some(handlers) = lock.get(&emit_args.event) {
          let handlers = handlers.iter();
          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()))
          }
        }
      }
    }

    if maybe_pending {
      self.flush_pending()?;
    }

      app.listen("ping-evt", |e| log(format!("rust listener ping-evt {}", e.payload())));
      app.emit("ping-evt", "from setup")?;

#[tauri::command]
async fn async_cmd(app: tauri::AppHandle) -> Result<String, String> {
  log("app command async_cmd, emitting ping-evt");
  app.emit("ping-evt", "from async_cmd").map_err(|e| e.to_string())?;
  Ok("done".into())
}

  await t('plugin:event|emit', () => I.invoke('plugin:event|emit', { event: 'ping-evt', payload: 'from js' }));

  379ms [main] rust listener ping-evt "from setup"
...
  506ms [tokio-rt-worker] app command async_cmd, emitting ping-evt
  506ms [tokio-rt-worker] rust listener ping-evt "from async_cmd"

  507ms [main] plugin command ping
  507ms [tokio-rt-worker] plugin command ping_async
  508ms [tokio-rt-worker] rust listener ping-evt "from js"