fix: AppHandle::restart() may not send RunEvent::Exit event

.changes/restart-may-not-publish-exit-event.md

@@ -0,0 +1,5 @@
+---
+"tauri": patch:bug
+---
+
+`AppHandle::restart()` may not send `RunEvent::Exit` event before exiting the application.

crates/tauri/src/app.rs

@@ -475,6 +475,7 @@ impl<R: Runtime> AppHandle<R> {
     if self.runtime_handle.request_exit(RESTART_EXIT_CODE).is_err() {
       self.cleanup_before_exit();
     }
+    let _impede = self.manager.wait_for_event_loop_exit();
     crate::process::restart(&self.env());
   }
 
@@ -1155,6 +1156,7 @@ impl<R: Runtime> App<R> {
         let event = on_event_loop_event(&app_handle, RuntimeRunEvent::Exit, &manager);
         callback(&app_handle, event);
         app_handle.cleanup_before_exit();
+        manager.notify_event_loop_exit();
       }
       _ => {
         let event = on_event_loop_event(&app_handle, event, &manager);

crates/tauri/src/manager/mod.rs

@@ -221,6 +221,13 @@ pub struct AppManager<R: Runtime> {
   pub(crate) invoke_key: String,
 
   pub(crate) channel_interceptor: Option<ChannelInterceptor<R>>,
+
+  // the value is set to true when the event loop is already exited
+  event_loop_exit_mutex: Mutex<bool>,
+  event_loop_exit_condvar: std::sync::Condvar,
+  // number of threads that request to NOT exit process
+  impede_exit_count: Mutex<usize>,
+  impede_exit_condvar: std::sync::Condvar,
 }
 
 impl<R: Runtime> fmt::Debug for AppManager<R> {
@@ -315,6 +322,10 @@ impl<R: Runtime> AppManager<R> {
       pattern: Arc::new(context.pattern),
       plugin_global_api_scripts: Arc::new(context.plugin_global_api_scripts),
       resources_table: Arc::default(),
+      event_loop_exit_mutex: Mutex::new(false),
+      event_loop_exit_condvar: std::sync::Condvar::new(),
+      impede_exit_count: Mutex::new(0),
+      impede_exit_condvar: std::sync::Condvar::new(),
       invoke_key,
       channel_interceptor,
     }
@@ -690,6 +701,55 @@ impl<R: Runtime> AppManager<R> {
   pub(crate) fn invoke_key(&self) -> &str {
     &self.invoke_key
   }
+
+  pub(crate) fn notify_event_loop_exit(&self) {
+    let mut exit = self.event_loop_exit_mutex.lock().unwrap();
+    *exit = true;
+    self.event_loop_exit_condvar.notify_all();
+    drop(exit);
+
+    self.wait_impede();
+  }
+
+  pub(crate) fn wait_for_event_loop_exit(self: &Arc<Self>) -> ImpedeScope<R> {
+    let impede = self.impede_quit();
+    let mut exit = self.event_loop_exit_mutex.lock().unwrap();
+    while !*exit {
+      exit = self.event_loop_exit_condvar.wait(exit).unwrap();
+    }
+    impede
+  }
+
+  /// When the main loop exits, most runtime would exit the process, so we need to impede the exit
+  /// if we're going to restart the application.
+  fn impede_quit(self: &Arc<Self>) -> ImpedeScope<R> {
+    let mut pend_exit_threads = self.impede_exit_count.lock().unwrap();
+    *pend_exit_threads += 1;
+    ImpedeScope {
+      app_manager: self.clone(),
+    }
+  }
+
+  fn wait_impede(&self) {
+    let mut pend_exit_threads = self.impede_exit_count.lock().unwrap();
+    while *pend_exit_threads > 0 {
+      pend_exit_threads = self.impede_exit_condvar.wait(pend_exit_threads).unwrap();
+    }
+  }
+}
+
+pub struct ImpedeScope<R: Runtime> {
+  app_manager: Arc<AppManager<R>>,
+}
+
+impl<R: Runtime> Drop for ImpedeScope<R> {
+  fn drop(&mut self) {
+    let mut pend_exit_threads = self.app_manager.impede_exit_count.lock().unwrap();
+    *pend_exit_threads -= 1;
+    if *pend_exit_threads == 0 {
+      self.app_manager.impede_exit_condvar.notify_all();
+    }
+  }
 }
 
 #[cfg(desktop)]