feat: introduce App::run_return

.changes/introduce-run-return.md

@@ -0,0 +1,7 @@
+---
+tauri: 'minor:feat'
+tauri-runtime: 'minor:feat'
+tauri-runtime-wry: 'minor:feat'
+---
+
+Add `App::run_return` function. Contrary to `App::run`, this will **not** exit the thread but instead return the requested exit-code. This allows the host app to perform further cleanup after Tauri has exited.

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

@@ -2830,22 +2830,43 @@ 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, mut 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;
+    let web_context = self.context.main_thread.web_context.clone();
     let plugins = self.context.plugins.clone();
 
     #[cfg(feature = "tracing")]
     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, 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,47 @@ 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();
+  ///     }
+  ///      _ => {}
+  ///   })
+  ///   .unwrap();
+  ///
+  /// std::process::exit(exit_code);
+  /// ```
+  #[cfg(desktop)]
+  pub fn run_return<F: FnMut(&AppHandle<R>, RunEvent) + 'static>(
+    mut self,
+    mut callback: F,
+  ) -> std::result::Result<i32, Box<dyn std::error::Error>> {
+    let manager = self.manager.clone();
+    let app_handle = self.handle().clone();
+
+    if !self.ran_setup {
+      setup(&mut self)?;
+    }
+
+    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();
+
+    Ok(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.

crates/tauri/src/test/mock_runtime.rs

@@ -1188,6 +1188,12 @@ impl<T: UserEvent> Runtime<T> for MockRuntime {
   ))]
   fn run_iteration<F: FnMut(RunEvent<T>)>(&mut self, callback: F) {}
 
+  fn run_return<F: FnMut(RunEvent<T>) + 'static>(&mut self, mut callback: F) -> i32 {
+    self.run(callback);
+
+    0
+  }
+
   fn run<F: FnMut(RunEvent<T>) + 'static>(self, mut callback: F) {
     self.is_running.store(true, Ordering::Relaxed);
     callback(RunEvent::Ready);