Make iOS fully thread safe (#3045)

* macOS & iOS: Refactor EventWrapper

* macOS & iOS: Make EventLoopWindowTarget independent of the user event

* iOS: Use MainThreadMarker instead of marking functions unsafe

* Make iOS thread safe

src/platform_impl/ios/event_loop.rs

@@ -15,12 +15,10 @@ use core_foundation::runloop::{
     CFRunLoopSourceInvalidate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
 };
 use icrate::Foundation::{MainThreadMarker, NSString};
-use objc2::rc::Id;
 use objc2::ClassType;
 use raw_window_handle::{RawDisplayHandle, UiKitDisplayHandle};
 
 use crate::{
-    dpi::LogicalSize,
     error::EventLoopError,
     event::Event,
     event_loop::{
@@ -30,38 +28,21 @@ use crate::{
 };
 
 use super::uikit::{UIApplication, UIApplicationMain, UIDevice, UIScreen};
-use super::view::WinitUIWindow;
 use super::{app_state, monitor, view, MonitorHandle};
 
 #[derive(Debug)]
-pub(crate) enum EventWrapper {
-    StaticEvent(Event<Never>),
-    EventProxy(EventProxy),
-}
-
-#[derive(Debug, PartialEq)]
-pub(crate) enum EventProxy {
-    DpiChangedProxy {
-        window: Id<WinitUIWindow>,
-        suggested_size: LogicalSize<f64>,
-        scale_factor: f64,
-    },
-}
-
 pub struct EventLoopWindowTarget<T: 'static> {
-    receiver: Receiver<T>,
-    sender_to_clone: Sender<T>,
+    pub(super) mtm: MainThreadMarker,
+    p: PhantomData<T>,
 }
 
 impl<T: 'static> EventLoopWindowTarget<T> {
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        monitor::uiscreens(MainThreadMarker::new().unwrap())
+        monitor::uiscreens(self.mtm)
     }
 
     pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle::new(UIScreen::main(
-            MainThreadMarker::new().unwrap(),
-        )))
+        Some(MonitorHandle::new(UIScreen::main(self.mtm)))
     }
 
     pub fn raw_display_handle(&self) -> RawDisplayHandle {
@@ -70,6 +51,9 @@ impl<T: 'static> EventLoopWindowTarget<T> {
 }
 
 pub struct EventLoop<T: 'static> {
+    mtm: MainThreadMarker,
+    sender: Sender<T>,
+    receiver: Receiver<T>,
     window_target: RootEventLoopWindowTarget<T>,
 }
 
@@ -80,7 +64,8 @@ impl<T: 'static> EventLoop<T> {
     pub(crate) fn new(
         _: &PlatformSpecificEventLoopAttributes,
     ) -> Result<EventLoop<T>, EventLoopError> {
-        assert_main_thread!("`EventLoop` can only be created on the main thread on iOS");
+        let mtm = MainThreadMarker::new()
+            .expect("On iOS, `EventLoop` must be created on the main thread");
 
         static mut SINGLETON_INIT: bool = false;
         unsafe {
@@ -92,16 +77,19 @@ impl<T: 'static> EventLoop<T> {
             SINGLETON_INIT = true;
         }
 
-        let (sender_to_clone, receiver) = mpsc::channel();
+        let (sender, receiver) = mpsc::channel();
 
         // this line sets up the main run loop before `UIApplicationMain`
         setup_control_flow_observers();
 
         Ok(EventLoop {
+            mtm,
+            sender,
+            receiver,
             window_target: RootEventLoopWindowTarget {
                 p: EventLoopWindowTarget {
-                    receiver,
-                    sender_to_clone,
+                    mtm,
+                    p: PhantomData,
                 },
                 _marker: PhantomData,
             },
@@ -113,7 +101,7 @@ impl<T: 'static> EventLoop<T> {
         F: FnMut(Event<T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
     {
         unsafe {
-            let application = UIApplication::shared(MainThreadMarker::new().unwrap());
+            let application = UIApplication::shared(self.mtm);
             assert!(
                 application.is_none(),
                 "\
@@ -128,10 +116,11 @@ impl<T: 'static> EventLoop<T> {
 
             let handler = EventLoopHandler {
                 f: event_handler,
+                receiver: self.receiver,
                 event_loop: self.window_target,
             };
 
-            app_state::will_launch(Box::new(handler));
+            app_state::will_launch(self.mtm, Box::new(handler));
 
             // Ensure application delegate is initialized
             view::WinitApplicationDelegate::class();
@@ -147,7 +136,7 @@ impl<T: 'static> EventLoop<T> {
     }
 
     pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.window_target.p.sender_to_clone.clone())
+        EventLoopProxy::new(self.sender.clone())
     }
 
     pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {
@@ -158,9 +147,7 @@ impl<T: 'static> EventLoop<T> {
 // EventLoopExtIOS
 impl<T: 'static> EventLoop<T> {
     pub fn idiom(&self) -> Idiom {
-        UIDevice::current(MainThreadMarker::new().unwrap())
-            .userInterfaceIdiom()
-            .into()
+        UIDevice::current(self.mtm).userInterfaceIdiom().into()
     }
 }
 
@@ -238,12 +225,11 @@ fn setup_control_flow_observers() {
             activity: CFRunLoopActivity,
             _: *mut c_void,
         ) {
-            unsafe {
-                #[allow(non_upper_case_globals)]
-                match activity {
-                    kCFRunLoopAfterWaiting => app_state::handle_wakeup_transition(),
-                    _ => unreachable!(),
-                }
+            let mtm = MainThreadMarker::new().unwrap();
+            #[allow(non_upper_case_globals)]
+            match activity {
+                kCFRunLoopAfterWaiting => app_state::handle_wakeup_transition(mtm),
+                _ => unreachable!(),
             }
         }
 
@@ -263,13 +249,12 @@ fn setup_control_flow_observers() {
             activity: CFRunLoopActivity,
             _: *mut c_void,
         ) {
-            unsafe {
-                #[allow(non_upper_case_globals)]
-                match activity {
-                    kCFRunLoopBeforeWaiting => app_state::handle_main_events_cleared(),
-                    kCFRunLoopExit => unimplemented!(), // not expected to ever happen
-                    _ => unreachable!(),
-                }
+            let mtm = MainThreadMarker::new().unwrap();
+            #[allow(non_upper_case_globals)]
+            match activity {
+                kCFRunLoopBeforeWaiting => app_state::handle_main_events_cleared(mtm),
+                kCFRunLoopExit => unimplemented!(), // not expected to ever happen
+                _ => unreachable!(),
             }
         }
 
@@ -279,13 +264,12 @@ fn setup_control_flow_observers() {
             activity: CFRunLoopActivity,
             _: *mut c_void,
         ) {
-            unsafe {
-                #[allow(non_upper_case_globals)]
-                match activity {
-                    kCFRunLoopBeforeWaiting => app_state::handle_events_cleared(),
-                    kCFRunLoopExit => unimplemented!(), // not expected to ever happen
-                    _ => unreachable!(),
-                }
+            let mtm = MainThreadMarker::new().unwrap();
+            #[allow(non_upper_case_globals)]
+            match activity {
+                kCFRunLoopBeforeWaiting => app_state::handle_events_cleared(mtm),
+                kCFRunLoopExit => unimplemented!(), // not expected to ever happen
+                _ => unreachable!(),
             }
         }
 
@@ -336,6 +320,7 @@ pub trait EventHandler: Debug {
 
 struct EventLoopHandler<T: 'static> {
     f: Box<EventHandlerCallback<T>>,
+    receiver: Receiver<T>,
     event_loop: RootEventLoopWindowTarget<T>,
 }
 
@@ -357,7 +342,7 @@ impl<T: 'static> EventHandler for EventLoopHandler<T> {
     }
 
     fn handle_user_events(&mut self, control_flow: &mut ControlFlow) {
-        for event in self.event_loop.p.receiver.try_iter() {
+        for event in self.receiver.try_iter() {
             (self.f)(Event::UserEvent(event), &self.event_loop, control_flow);
         }
     }