Support an OpenURL event on macOS

src/event.rs

@@ -54,10 +54,17 @@
     ///
     /// This event type is useful as a place to put code that should be done before you start
     /// processing events, such as updating frame timing information for benchmarking or checking
     /// the [`StartCause`][crate::event::StartCause] to see if a timer set by
     /// [`ControlFlow::WaitUntil`](crate::event_loop::ControlFlow::WaitUntil) has elapsed.
     NewEvents(StartCause),
 
+    /// Emitted if a user has requested to open an application specific URL that is registered with the OS
+    ///
+    /// # Portability
+    ///
+    /// This event is only ever delivered on MacOS currently
+    OpenURL { url: String },
+
     /// Emitted when the OS sends an event to a winit window.
     WindowEvent {
         window_id: WindowId,
@@ -184,7 +191,7 @@
     /// state-changing events have been handled and you want to do stuff (updating state, performing
     /// calculations, etc) that happens as the "main body" of your event loop. If your program only draws
     /// graphics when something changes, it's usually better to do it in response to
     /// [`Event::RedrawRequested`](crate::event::Event::RedrawRequested), which gets emitted
     /// immediately after this event. Programs that draw graphics continuously, like most games,
     /// can render here unconditionally for simplicity.
     MainEventsCleared,
@@ -235,6 +242,7 @@
     fn clone(&self) -> Self {
         use self::Event::*;
         match self {
+            OpenURL { url } => OpenURL { url: url.clone() },
             WindowEvent { window_id, event } => WindowEvent {
                 window_id: *window_id,
                 event: event.clone(),
@@ -260,6 +268,7 @@
         use self::Event::*;
         match self {
             UserEvent(_) => Err(self),
+            OpenURL { url } => Ok(OpenURL { url }),
             WindowEvent { window_id, event } => Ok(WindowEvent { window_id, event }),
             DeviceEvent { device_id, event } => Ok(DeviceEvent { device_id, event }),
             NewEvents(cause) => Ok(NewEvents(cause)),
@@ -277,6 +286,7 @@
     pub fn to_static(self) -> Option<Event<'static, T>> {
         use self::Event::*;
         match self {
+            OpenURL { url } => Some(OpenURL { url }),
             WindowEvent { window_id, event } => event
                 .to_static()
                 .map(|event| WindowEvent { window_id, event }),

src/platform_impl/macos/app_delegate.rs

@@ -1,10 +1,32 @@
-use objc2::foundation::NSObject;
+use objc2::foundation::{NSArray, NSObject, NSString};
 use objc2::rc::{Id, Shared};
 use objc2::runtime::Object;
-use objc2::{declare_class, msg_send, msg_send_id, ClassType};
+use objc2::{declare_class, extern_class, extern_methods, msg_send, msg_send_id, ClassType};
+
+use crate::event::Event;
 
 use super::app_state::AppState;
 use super::appkit::NSApplicationActivationPolicy;
+use super::event::EventWrapper;
+
+extern_class!(
+    #[derive(Debug)]
+    struct NSURL;
+    unsafe impl ClassType for NSURL {
+        type Super = NSObject;
+    }
+);
+
+unsafe impl Send for NSURL {}
+unsafe impl Sync for NSURL {}
+
+extern_methods!(
+    unsafe impl NSURL {
+        pub fn absolute_string(&self) -> Option<Id<NSString, Shared>> {
+            unsafe { msg_send_id![self, absoluteString] }
+        }
+    }
+);
 
 declare_class!(
     #[derive(Debug)]
@@ -52,6 +74,17 @@ declare_class!(
             // TODO: Notify every window that it will be destroyed, like done in iOS?
             AppState::exit();
         }
+
+        #[sel(application:openURLs:)]
+        fn application_open_urls(&self, _application: &NSObject, urls: &NSArray<NSURL>) {
+            for url in urls {
+                if let Some(url) = url.absolute_string() {
+                    AppState::queue_event(EventWrapper::StaticEvent(Event::OpenURL {
+                        url: url.to_string(),
+                    }));
+                }
+            }
+        }
     }
 );
 

src/platform_impl/macos/view.rs

@@ -4,8 +4,8 @@ use std::{boxed::Box, os::raw::*, ptr, str, sync::Mutex};
 
 use objc2::declare::{Ivar, IvarDrop};
 use objc2::foundation::{
-    NSArray, NSAttributedString, NSAttributedStringKey, NSCopying,
-    NSMutableAttributedString, NSObject, NSPoint, NSRange, NSRect, NSSize, NSString, NSUInteger,
+    NSArray, NSAttributedString, NSAttributedStringKey, NSCopying, NSMutableAttributedString,
+    NSObject, NSPoint, NSRange, NSRect, NSSize, NSString, NSUInteger,
 };
 use objc2::rc::{Id, Owned, Shared, WeakId};
 use objc2::runtime::{Object, Sel};