feat: introduce App::run_return

crates/tauri-runtime-wry/src/lib.rs

@@ -2830,7 +2830,9 @@ impl<T: UserEvent> Runtime<T> for Wry<T> {
       });
   }
 
-  fn run<F: FnMut(RunEvent<T>) + 'static>(self, mut callback: F) {
+  fn run_return<F: FnMut(RunEvent<T>) + 'static>(&mut self, callback: F) -> i32 {
+    use tao::platform::run_return::EventLoopExtRunReturn;
+
     let windows = self.context.main_thread.windows.clone();
     let window_id_map = self.context.window_id_map.clone();
     let web_context = self.context.main_thread.web_context;
@@ -2840,12 +2842,31 @@ impl<T: UserEvent> Runtime<T> for Wry<T> {
     let active_tracing_spans = self.context.main_thread.active_tracing_spans.clone();
     let proxy = self.event_loop.create_proxy();
 
-    self.event_loop.run(move |event, event_loop, control_flow| {
-      for p in plugins.lock().unwrap().iter_mut() {
-        let prevent_default = p.on_event(
-          &event,
+    self
+      .event_loop
+      .run_return(move |event, event_loop, control_flow| {
+        for p in plugins.lock().unwrap().iter_mut() {
+          let prevent_default = p.on_event(
+            &event,
+            event_loop,
+            &proxy,
+            control_flow,
+            EventLoopIterationContext {
+              callback: &mut callback,
+              window_id_map: window_id_map.clone(),
+              windows: windows.clone(),
+              #[cfg(feature = "tracing")]
+              active_tracing_spans: active_tracing_spans.clone(),
+            },
+            &web_context,
+          );
+          if prevent_default {
+            return;
+          }
+        }
+        handle_event_loop(
+          event,
           event_loop,
-          &proxy,
           control_flow,
           EventLoopIterationContext {
             callback: &mut callback,
@@ -2854,25 +2875,13 @@ impl<T: UserEvent> Runtime<T> for Wry<T> {
             #[cfg(feature = "tracing")]
             active_tracing_spans: active_tracing_spans.clone(),
           },
-          &web_context,
         );
-        if prevent_default {
-          return;
-        }
-      }
-      handle_event_loop(
-        event,
-        event_loop,
-        control_flow,
-        EventLoopIterationContext {
-          callback: &mut callback,
-          window_id_map: window_id_map.clone(),
-          windows: windows.clone(),
-          #[cfg(feature = "tracing")]
-          active_tracing_spans: active_tracing_spans.clone(),
-        },
-      );
-    })
+      })
+  }
+
+  fn run<F: FnMut(RunEvent<T>) + 'static>(mut self, mut callback: F) {
+    let exit_code = self.run_return(callback);
+    std::process::exit(exit_code);
   }
 }
 

crates/tauri-runtime/src/lib.rs

@@ -437,6 +437,10 @@ pub trait Runtime<T: UserEvent>: Debug + Sized + 'static {
   #[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.
+  #[cfg(desktop)]
+  fn run_return<F: FnMut(RunEvent<T>) + 'static>(&mut self, callback: F) -> i32;
+
   /// Run the webview runtime.
   fn run<F: FnMut(RunEvent<T>) + 'static>(self, callback: F);
 }

crates/tauri/src/app.rs

@@ -1092,6 +1092,43 @@ impl<R: Runtime> App<R> {
     });
   }
 
+  /// Runs the application, returning the exit code to use.
+  ///
+  /// # Examples
+  /// ```,no_run
+  /// let app = tauri::Builder::default()
+  ///   // on an actual app, remove the string argument
+  ///   .build(tauri::generate_context!("test/fixture/src-tauri/tauri.conf.json"))
+  ///   .expect("error while building tauri application");
+  /// let exit_code = app.run_return(|_app_handle, event| match event {
+  ///   tauri::RunEvent::ExitRequested { api, .. } => {
+  ///     api.prevent_exit();
+  ///   }
+  ///   _ => {}
+  /// });
+  ///
+  /// std::process::exit(exit_code);
+  /// ```
+  pub fn run_return<F: FnMut(&AppHandle<R>, RunEvent) + 'static>(mut self, mut callback: F) -> i32 {
+    let manager = self.manager.clone();
+    let app_handle = self.handle().clone();
+
+    if !self.ran_setup {
+      if let Err(e) = setup(&mut self) {
+        panic!("Failed to setup app: {e}");
+      }
+    }
+
+    let exit_code = self.runtime.as_mut().unwrap().run_return(move |event| {
+      let event = on_event_loop_event(&app_handle, event, &manager);
+      callback(&app_handle, event);
+    });
+
+    self.cleanup_before_exit();
+
+    exit_code
+  }
+
   /// Runs an iteration of the runtime event loop and immediately return.
   ///
   /// Note that when using this API, app cleanup is not automatically done.