Handle URLs for macOS

src/application.rs

@@ -222,4 +222,13 @@ pub trait ApplicationHandler<T: 'static = ()> {
     fn memory_warning(&mut self, event_loop: &ActiveEventLoop) {
         let _ = event_loop;
     }
+
+    /// Emitted when the application has received a URL, through a
+    /// custom URL handler.
+    ///
+    /// Only supported on macOS.
+    fn received_url(&mut self, event_loop: &ActiveEventLoop, url: String) {
+        let _ = event_loop;
+        let _ = url;
+    }
 }

src/event.rs

@@ -103,6 +103,21 @@ pub enum Event<T: 'static> {
     ///
     /// [`ApplicationHandler::memory_warning`]: crate::application::ApplicationHandler::memory_warning
     MemoryWarning,
+
+    /// Emitted when the event loop receives an event that only occurs on some specific platform.
+    PlatformSpecific(PlatformSpecific),
+}
+
+/// Describes an event from some specific platform.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PlatformSpecific {
+    MacOS(MacOS),
+}
+
+/// Describes an event that only happens in `MacOS`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum MacOS {
+    ReceivedUrl(String),
 }
 
 impl<T> Event<T> {
@@ -119,6 +134,7 @@ impl<T> Event<T> {
             Suspended => Ok(Suspended),
             Resumed => Ok(Resumed),
             MemoryWarning => Ok(MemoryWarning),
+            PlatformSpecific(event) => Ok(PlatformSpecific(event)),
         }
     }
 }

src/event_loop.rs

@@ -20,7 +20,7 @@ use web_time::{Duration, Instant};
 
 use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, OsError};
-use crate::event::Event;
+use crate::event::{self, Event};
 use crate::monitor::MonitorHandle;
 use crate::platform_impl;
 use crate::window::{CustomCursor, CustomCursorSource, Window, WindowAttributes};
@@ -633,5 +633,8 @@ pub(crate) fn dispatch_event_for_app<T: 'static, A: ApplicationHandler<T>>(
         Event::AboutToWait => app.about_to_wait(event_loop),
         Event::LoopExiting => app.exiting(event_loop),
         Event::MemoryWarning => app.memory_warning(event_loop),
+        Event::PlatformSpecific(event::PlatformSpecific::MacOS(event::MacOS::ReceivedUrl(url))) => {
+            app.received_url(event_loop, url)
+        },
     }
 }

src/platform_impl/macos/app_delegate.rs

@@ -7,7 +7,9 @@ use std::time::Instant;
 
 use objc2::rc::Id;
 use objc2::runtime::AnyObject;
-use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
+use objc2::{
+    class, declare_class, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass,
+};
 use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSApplicationDelegate};
 use objc2_foundation::{MainThreadMarker, NSObject, NSObjectProtocol, NSSize};
 
@@ -17,7 +19,9 @@ use super::observer::{EventLoopWaker, RunLoop};
 use super::window::WinitWindow;
 use super::{menu, WindowId, DEVICE_ID};
 use crate::dpi::PhysicalSize;
-use crate::event::{DeviceEvent, Event, InnerSizeWriter, StartCause, WindowEvent};
+use crate::event::{
+    DeviceEvent, Event, InnerSizeWriter, MacOS, PlatformSpecific, StartCause, WindowEvent,
+};
 use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
 use crate::window::WindowId as RootWindowId;
 
@@ -54,6 +58,14 @@ pub(super) struct State {
     pending_redraw: RefCell<Vec<WindowId>>,
 }
 
+/// Apple constants
+#[allow(non_upper_case_globals)]
+pub const kInternetEventClass: u32 = 0x4755524c;
+#[allow(non_upper_case_globals)]
+pub const kAEGetURL: u32 = 0x4755524c;
+#[allow(non_upper_case_globals)]
+pub const keyDirectObject: u32 = 0x2d2d2d2d;
+
 declare_class!(
     #[derive(Debug)]
     pub(super) struct ApplicationDelegate;
@@ -116,6 +128,33 @@ declare_class!(
             }
         }
 
+        #[method(applicationWillFinishLaunching:)]
+        fn will_finish_launching(&self, _sender: Option<&AnyObject>) {
+            trace_scope!("applicationWillFinishLaunching");
+
+            unsafe {
+                let event_manager = class!(NSAppleEventManager);
+                let shared_manager: *mut AnyObject =
+                    msg_send![event_manager, sharedAppleEventManager];
+
+                let () = msg_send![shared_manager,
+                    setEventHandler: self
+                    andSelector: sel!(handleEvent:withReplyEvent:)
+                    forEventClass: kInternetEventClass
+                    andEventID: kAEGetURL
+                ];
+            }
+        }
+
+        #[method(handleEvent:withReplyEvent:)]
+        fn handle_url(&self, event: *mut AnyObject, _reply: u64) {
+            if let Some(string) = parse_url(event) {
+                self.handle_event(Event::PlatformSpecific(PlatformSpecific::MacOS(
+                    MacOS::ReceivedUrl(string),
+                )));
+            }
+        }
+
         #[method(applicationWillTerminate:)]
         fn will_terminate(&self, _sender: Option<&AnyObject>) {
             trace_scope!("applicationWillTerminate:");
@@ -459,3 +498,21 @@ fn window_activation_hack(app: &NSApplication) {
         }
     })
 }
+
+fn parse_url(event: *mut AnyObject) -> Option<String> {
+    unsafe {
+        let class: u32 = msg_send![event, eventClass];
+        let id: u32 = msg_send![event, eventID];
+        if class != kInternetEventClass || id != kAEGetURL {
+            return None;
+        }
+        let subevent: *mut AnyObject = msg_send![event, paramDescriptorForKeyword: keyDirectObject];
+        let nsstring: *mut AnyObject = msg_send![subevent, stringValue];
+        let cstr: *const i8 = msg_send![nsstring, UTF8String];
+        if !cstr.is_null() {
+            Some(std::ffi::CStr::from_ptr(cstr).to_string_lossy().into_owned())
+        } else {
+            None
+        }
+    }
+}