fix init and window creation flow for iOS and disabled multiscene

Author: lucasfernog

Cargo.toml

@@ -155,7 +155,6 @@ scopeguard = "1.2"
 [target."cfg(target_os = \"ios\")".dependencies]
 objc2-ui-kit = { version = "0.3", features = ["UIResponder"] }
 objc2-foundation = { version = "0.3", default-features = false }
-dispatch = "0.2"
 
 [target."cfg(any(target_os = \"linux\", target_os = \"dragonfly\", target_os = \"freebsd\", target_os = \"openbsd\", target_os = \"netbsd\"))".dependencies]
 gtk = "0.18"

src/platform_impl/ios/app_state.rs

@@ -28,7 +28,7 @@ use crate::{
       CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate, CGRect, CGSize, NSInteger,
       NSOperatingSystemVersion, NSUInteger,
     },
-    scene::app_supports_multiple_scenes,
+    scene::multiple_scenes_enabled,
   },
   window::WindowId as RootWindowId,
 };
@@ -504,17 +504,15 @@ pub unsafe fn scene_by_id(id: &str) -> Option<Retained<UIScene>> {
 }
 
 pub unsafe fn connect_scene(scene: &UIScene) {
+  eprintln!("connect scene");
   let did_first_scene_connect = AppState::get_mut().did_first_scene_connect;
   // on scene mode, we run on_app_ready() when the main scene is connected
   // instead of on AppDelegate::didFinishLaunching
   // this optimizes app startup, since the first created window can immediately see the main scene
   // instead of having to create a new one (since it can't synchronously wait for it to be connected)
   if !did_first_scene_connect {
     AppState::get_mut().did_first_scene_connect = true;
-    // run it a bit later so the scene is actually marked as connected
-    // otherwise UIWindowScene::windows returns 0, never connects the window
-    // and the main scene gets in a weird state where it can't snapshot when we create additional windows
-    dispatch::Queue::main().exec_async(|| unsafe { on_app_ready() });
+    on_app_ready();
   }
 
   if let Some(window_scene) = scene.downcast_ref::<UIWindowScene>() {
@@ -607,8 +605,8 @@ pub unsafe fn will_launch(queued_event_handler: Box<dyn EventHandler>) {
 
 // requires main thread
 pub unsafe fn did_finish_launching() {
-  // when app supports multiple scenes, we defer the did_finish_launching call to the first scene setup
-  if !app_supports_multiple_scenes() {
+  // when app is run in scenes lifecycle mode, we defer the did_finish_launching call to the first scene setup
+  if !multiple_scenes_enabled() {
     on_app_ready();
   }
 }

src/platform_impl/ios/scene.rs

@@ -1,47 +1,50 @@
 // Copyright 2021-2025 Tauri Programme within The Commons Conservancy
 // SPDX-License-Identifier: Apache-2.0
 
-use objc2::{define_class, rc::Retained, MainThreadOnly};
+use objc2::{define_class, rc::Retained, MainThreadMarker, MainThreadOnly};
 use objc2_foundation::{
   NSBundle, NSDictionary, NSError, NSNumber, NSObject, NSObjectProtocol, NSSet, NSString,
   NSUserActivity,
 };
 use objc2_ui_kit::{
-  UIOpenURLContext, UIScene, UISceneConnectionOptions, UISceneDelegate, UISceneSession,
-  UIWindowScene,
+  UIApplication, UIOpenURLContext, UIScene, UISceneConnectionOptions, UISceneDelegate,
+  UISceneSession, UIWindowScene,
 };
 
 use crate::{
   event::{Event, WindowEvent},
-  platform_impl::platform::{app_state, event_loop::EventWrapper, ffi::id},
+  platform_impl::platform::{app_state, event_loop::EventWrapper},
   window::WindowId as RootWindowId,
 };
 
+// true when the system allows the app to display multiple scenes and multiple_scenes_enabled() returns true
+// https://developer.apple.com/documentation/uikit/uiapplication/supportsmultiplescenes?language=objc
 pub unsafe fn app_supports_multiple_scenes() -> bool {
-  let application: id = msg_send![class!(UIApplication), sharedApplication];
-  // this function can be called before the UIApplication is set up (class delegate registration)
-  if application == std::ptr::null_mut() {
-    let bundle = NSBundle::mainBundle();
-    let Some(info) = bundle.infoDictionary() else {
-      return false;
-    };
-
-    let key = NSString::from_str("UIApplicationSceneManifest");
-    let Some(manifest) = (*info).objectForKey(&key) else {
-      return false;
-    };
-
-    let manifest_dict = Retained::cast_unchecked::<NSDictionary<NSString, NSObject>>(manifest);
-    let supports_key = NSString::from_str("UIApplicationSupportsMultipleScenes");
-    let Some(value) = (*manifest_dict).objectForKey(&supports_key) else {
-      return false;
-    };
-
-    let num = Retained::cast_unchecked::<NSNumber>(value);
-    (*num).as_bool()
-  } else {
-    msg_send![application, supportsMultipleScenes]
-  }
+  let mtm = MainThreadMarker::new().unwrap();
+  let application = UIApplication::sharedApplication(mtm);
+  application.supportsMultipleScenes()
+}
+
+// check whether the app's Info.plist enabled multiple scenes
+pub unsafe fn multiple_scenes_enabled() -> bool {
+  let bundle = NSBundle::mainBundle();
+  let Some(info) = bundle.infoDictionary() else {
+    return false;
+  };
+
+  let key = NSString::from_str("UIApplicationSceneManifest");
+  let Some(manifest) = (*info).objectForKey(&key) else {
+    return false;
+  };
+
+  let manifest_dict = Retained::cast_unchecked::<NSDictionary<NSString, NSObject>>(manifest);
+  let supports_key = NSString::from_str("UIApplicationSupportsMultipleScenes");
+  let Some(value) = (*manifest_dict).objectForKey(&supports_key) else {
+    return false;
+  };
+
+  let num = Retained::cast_unchecked::<NSNumber>(value);
+  (*num).as_bool()
 }
 
 define_class!(
@@ -131,7 +134,6 @@ define_class!(
       &self,
       _scene: &UIScene,
     ) -> Option<std::ptr::NonNull<NSUserActivity>> {
-      log::info!("scene erstore");
       None
     }
 
@@ -141,7 +143,6 @@ define_class!(
       _scene: &UIScene,
       _state_restoration_activity: &NSUserActivity,
     ) {
-      log::info!("scene erstorasdasdsade");
     }
 
     #[unsafe(method(scene:willContinueUserActivityWithType:))]
@@ -150,13 +151,10 @@ define_class!(
       _scene: &UIScene,
       _user_activity_type: &NSString,
     ) {
-      log::info!("scene erstore ytype");
     }
 
     #[unsafe(method(scene:continueUserActivity:))]
-    fn scene_continueUserActivity(&self, _scene: &UIScene, _user_activity: &NSUserActivity) {
-      log::info!("scene continue");
-    }
+    fn scene_continueUserActivity(&self, _scene: &UIScene, _user_activity: &NSUserActivity) {}
 
     #[unsafe(method(scene:didFailToContinueUserActivityWithType:error:))]
     fn scene_didFailToContinueUserActivityWithType_error(
@@ -165,12 +163,9 @@ define_class!(
       _user_activity_type: &NSString,
       _error: &NSError,
     ) {
-      log::info!("scene fail");
     }
 
     #[unsafe(method(scene:didUpdateUserActivity:))]
-    fn scene_didUpdateUserActivity(&self, _scene: &UIScene, _user_activity: &NSUserActivity) {
-      log::info!("scene updated");
-    }
+    fn scene_didUpdateUserActivity(&self, _scene: &UIScene, _user_activity: &NSUserActivity) {}
   }
 );

src/platform_impl/ios/view.rs

@@ -26,7 +26,7 @@ use crate::{
       id, nil, CGFloat, CGPoint, CGRect, UIForceTouchCapability, UIInterfaceOrientationMask,
       UIRectEdge, UITouchPhase, UITouchType, BOOL, NO, YES,
     },
-    scene::app_supports_multiple_scenes,
+    scene::{app_supports_multiple_scenes, multiple_scenes_enabled},
     window::PlatformSpecificWindowBuilderAttributes,
     DeviceId,
   },
@@ -534,10 +534,28 @@ pub unsafe fn create_window(
     "Failed to initialize `UIWindow` instance"
   );
 
-  if app_supports_multiple_scenes() {
+  if multiple_scenes_enabled() {
+    // if multiple scenes is enabled in Info.plist, we need to assign it
+    // regarless of whether the device supports multiple scenes or not
     if let Some(scene) = app_state::unitialized_scene() {
       let _: () = msg_send![window, setWindowScene: Retained::as_ptr(&scene)];
+    } else if !app_supports_multiple_scenes() {
+      // if there's no unitialized scene and the app does not support multiple scenes
+      // we need to move this window to the main scene, otherwise it won't be visible
+      let scene = unsafe {
+        let mtm = MainThreadMarker::new().unwrap();
+        let application = UIApplication::sharedApplication(mtm);
+        application.connectedScenes().iter().next()
+      };
+      let scene = scene
+        .as_ref()
+        .map(|s| Retained::as_ptr(s))
+        .unwrap_or(std::ptr::null_mut());
+
+      let _: () = msg_send![window, setWindowScene: scene];
     } else {
+      // only request a new scene if the system actually supports it
+      // otherwise it is silently ignored
       unsafe {
         let mtm = MainThreadMarker::new().unwrap();
         let application = UIApplication::sharedApplication(mtm);
@@ -552,6 +570,8 @@ pub unsafe fn create_window(
           options.setRequestingScene(Some(&scene));
         }
 
+        // alternative function is iOS 17+
+        #[allow(deprecated)]
         application.requestSceneSessionActivation_userActivity_options_errorHandler(
           None,
           None,
@@ -716,7 +736,7 @@ pub fn create_delegate_class() {
       did_finish_launching as extern "C" fn(_, _, _, _) -> _,
     );
 
-    if app_supports_multiple_scenes() {
+    if multiple_scenes_enabled() {
       decl.add_method(
         sel!(application:configurationForConnectingSceneSession:options:),
         configuration_for_connecting_scene_session as extern "C" fn(_, _, _, _, _) -> _,