tauri-runtime 的抽象

pub enum EventLoopMessage {
  /// An event from a menu item, could be on the window menu bar, application menu bar (on macOS) or tray icon menu.
  #[cfg(desktop)]
  MenuEvent(menu::MenuEvent),
  /// An event from a menu item, could be on the window menu bar, application menu bar (on macOS) or tray icon menu.
  #[cfg(all(desktop, feature = "tray-icon"))]
  #[cfg_attr(docsrs, doc(cfg(all(desktop, feature = "tray-icon"))))]
  TrayIconEvent(tray::TrayIconEvent),
}

/// The webview runtime interface. A wrapper around [`runtime::Runtime`] with the proper user event type associated.
pub trait Runtime: runtime::Runtime<EventLoopMessage> {}
/// The webview runtime handle. A wrapper around [`runtime::RuntimeHandle`] with the proper user event type associated.
pub trait RuntimeHandle: runtime::RuntimeHandle<EventLoopMessage> {}

impl<W: runtime::Runtime<EventLoopMessage>> Runtime for W {}
impl<R: runtime::RuntimeHandle<EventLoopMessage>> RuntimeHandle for R {}

pub trait Runtime<T: UserEvent>: Debug + Sized + 'static {
  /// The window message dispatcher.
  type WindowDispatcher: WindowDispatch<T, Runtime = Self>;
  /// The webview message dispatcher.
  type WebviewDispatcher: WebviewDispatch<T, Runtime = Self>;
  /// The runtime handle type.
  type Handle: RuntimeHandle<T, Runtime = Self>;
  /// The proxy type.
  type EventLoopProxy: EventLoopProxy<T>;

  /// Creates a new webview runtime. Must be used on the main thread.
  fn new(args: RuntimeInitArgs) -> Result<Self>;
  // ...
  /// Create a new window.
  fn create_window<F: Fn(RawWindow) + Send + 'static>(
    &self,
    pending: PendingWindow<T, Self>,
    after_window_creation: Option<F>,
  ) -> Result<DetachedWindow<T, Self>>;
  // ...
  /// Runs an iteration of the runtime event loop and returns control flow to the caller.
  #[cfg(desktop)]
  fn run_iteration<F: FnMut(RunEvent<T>) + 'static>(&mut self, callback: F);

  /// Equivalent to [`Runtime::run`] but returns the exit code instead of exiting the process.
  fn run_return<F: FnMut(RunEvent<T>) + 'static>(self, callback: F) -> i32;

  /// Run the webview runtime.
  fn run<F: FnMut(RunEvent<T>) + 'static>(self, callback: F);
}

pub struct PendingWindow<T: UserEvent, R: Runtime<T>> {
  /// The label that the window will be named.
  pub label: String,

  /// The [`WindowBuilder`] that the window will be created with.
  pub window_builder: <R::WindowDispatcher as WindowDispatch<T>>::WindowBuilder,

  /// The webview that gets added to the window. Optional in case you want to use child webviews or other window content instead.
  pub webview: Option<PendingWebview<T, R>>,
}

pub struct PendingWebview<T: UserEvent, R: Runtime<T>> {
  /// The label that the webview will be named.
  pub label: String,

  /// The [`WebviewAttributes`] that the webview will be created with.
  pub webview_attributes: WebviewAttributes,

  /// Custom protocols to register on the webview
  pub uri_scheme_protocols: HashMap<String, Box<UriSchemeProtocolHandler>>,

  /// How to handle IPC calls on the webview.
  pub ipc_handler: Option<WebviewIpcHandler<T, R>>,

  /// A handler to decide if incoming url is allowed to navigate.
  pub navigation_handler: Option<Box<NavigationHandler>>,
  // ...
  /// The resolved URL to load on the webview.
  pub url: String,
  // ...
}

type UriSchemeProtocolHandler = dyn Fn(&str, http::Request<Vec<u8>>, Box<dyn FnOnce(http::Response<Cow<'static, [u8]>>) + Send>)
  + Send
  + Sync
  + 'static;

pub struct DetachedWindow<T: UserEvent, R: Runtime<T>> {
  /// The identifier of the window.
  pub id: WindowId,
  /// Name of the window
  pub label: String,

  /// The [`WindowDispatch`] associated with the window.
  pub dispatcher: R::WindowDispatcher,

  /// The webview dispatcher in case this window has an attached webview.
  pub webview: Option<DetachedWindowWebview<T, R>>,
}

  fn send_message(&self, message: Message) -> Result<()> {
    if std::thread::current().id() == self.main_thread_id {
      if let Message::Task(task) = message {
        task();
        return Ok(());
      }
    }
    if self.is_running.load(Ordering::Relaxed) {
      self
        .run_tx
        .send(message)
        .map_err(|_| Error::FailedToSendMessage)
    } else {
      match message {
        Message::Task(task) => task(),
        Message::CloseWindow(id) | Message::DestroyWindow(id) => {
          self.windows.borrow_mut().remove(&id);
        }
      }
      Ok(())
    }
  }

// Records the order in which "before", "inside" and "after" happen.
fn order_probe<R: tauri::Runtime>(w: &WebviewWindow<R>, tag: &str) -> Arc<Mutex<Vec<String>>> {
  let log = Arc::new(Mutex::new(Vec::new()));
  log.lock().unwrap().push("before".to_string());
  let l = log.clone();
  let tag_ = tag.to_string();
  w.run_on_main_thread(move || {
    l.lock().unwrap().push("inside".to_string());
    println!("[{tag_}] run_on_main_thread closure on {}", th());
  })
  .unwrap();
  log.lock().unwrap().push("after".to_string());
  log
}

// The same generic code runs on Wry and on MockRuntime.
fn describe<R: tauri::Runtime>(w: &WebviewWindow<R>) -> String {
  format!(
    "title={:?} inner_size={:?} url={:?}",
    w.title(),
    w.inner_size().map(|s| (s.width, s.height)),
    w.url().map(|u| u.to_string())
  )
}

[setup] on main/ThreadId(1)
[setup] run_on_main_thread closure on main/ThreadId(1)
[setup] order=["before", "inside", "after"]
[setup] describe: title=Ok("base") inner_size=Ok((800, 600)) url=Ok("tauri://localhost")

    let w2 = w.clone();
    thread::Builder::new()
      .name("other".into())
      .spawn(move || {
        let log = order_probe(&w2, "other");
        println!("[other] order={:?}", log.lock().unwrap());
      })
      .unwrap()
      .join()
      .unwrap();

[test] on tests::mock_runtime/ThreadId(2)
[test] describe: title=Ok("") inner_size=Ok((0, 0)) url=Ok("tauri://localhost")

[test] run_on_main_thread closure on tests::mock_runtime/ThreadId(2)
[test] order=["before", "inside", "after"]
[other] run_on_main_thread closure on other/ThreadId(3)
[other] order=["before", "inside", "after"]