use std::{cell::RefCell, fmt, sync::Arc};
use crate::core::{ElementRect, ElementRef};
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct Share {
pub url: String,
pub title: Option<String>,
pub text: Option<String>,
pub at: Option<ElementRect>,
}
impl Share {
pub fn url(url: impl Into<String>) -> Self {
Self {
url: url.into(),
title: None,
text: None,
at: None,
}
}
pub fn title(mut self, title: impl Into<String>) -> Self {
self.title = Some(title.into());
self
}
pub fn text(mut self, text: impl Into<String>) -> Self {
self.text = Some(text.into());
self
}
pub fn at(self, element: &ElementRef) -> Self {
if element.is_attached() {
self.at_rect(element.bounds())
} else {
self
}
}
pub fn at_rect(mut self, rect: ElementRect) -> Self {
self.at = Some(rect);
self
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ShareError {
NotAnAddress,
Unsupported,
Failed(String),
}
impl fmt::Display for ShareError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NotAnAddress => f.write_str("it is not an address the system shares"),
Self::Unsupported => f.write_str("this platform has no share sheet"),
Self::Failed(reason) => f.write_str(reason),
}
}
}
impl std::error::Error for ShareError {}
type Sharer = Arc<dyn Fn(&Share) + Send + Sync>;
thread_local! {
static STAND_IN: RefCell<Option<Sharer>> = const { RefCell::new(None) };
}
pub fn stand_in(sharer: impl Fn(&Share) + Send + Sync + 'static) -> StandIn {
let before = STAND_IN.with(|held| held.borrow_mut().replace(Arc::new(sharer)));
StandIn { before }
}
#[must_use = "the stand-in is taken away when this is dropped"]
pub struct StandIn {
before: Option<Sharer>,
}
impl Drop for StandIn {
fn drop(&mut self) {
let before = self.before.take();
STAND_IN.with(|held| *held.borrow_mut() = before);
}
}
pub fn supported() -> bool {
STAND_IN.with(|held| held.borrow().is_some()) || system::supported()
}
pub(crate) enum Asked {
Done,
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
Shell(Share),
}
pub(crate) fn ask(mut share: Share) -> Result<Asked, ShareError> {
share.url = share.url.trim().to_owned();
if !super::open_url::has_scheme(&share.url) {
return Err(ShareError::NotAnAddress);
}
share.title = share.title.filter(|title| !title.trim().is_empty());
share.text = share.text.filter(|text| !text.trim().is_empty());
if let Some(sharer) = STAND_IN.with(|held| held.borrow().clone()) {
sharer(&share);
return Ok(Asked::Done);
}
if !system::supported() {
return Err(ShareError::Unsupported);
}
#[cfg(target_arch = "wasm32")]
{
show(None, &share).map(|()| Asked::Done)
}
#[cfg(not(target_arch = "wasm32"))]
Ok(Asked::Shell(share))
}
#[cfg_attr(not(any(feature = "winit", target_arch = "wasm32")), allow(dead_code))]
pub(crate) fn show(window: Option<raw_window_handle::RawWindowHandle>, share: &Share) -> Result<(), ShareError> {
system::show(window, share)
}
#[cfg(windows)]
mod system {
use std::{cell::RefCell, ffi::c_void};
use raw_window_handle::RawWindowHandle;
use windows::{
ApplicationModel::DataTransfer::{DataRequestedEventArgs, DataTransferManager},
Foundation::{TypedEventHandler, Uri},
Win32::{Foundation::HWND, UI::Shell::IDataTransferManagerInterop},
core::{HSTRING, Ref, factory},
};
use super::{Share, ShareError};
thread_local! {
static ASKED: RefCell<Option<(DataTransferManager, i64)>> = const { RefCell::new(None) };
}
pub(super) fn supported() -> bool {
DataTransferManager::IsSupported().unwrap_or(false)
}
pub(super) fn show(window: Option<RawWindowHandle>, share: &Share) -> Result<(), ShareError> {
let Some(RawWindowHandle::Win32(handle)) = window else {
return Err(ShareError::Failed("the window has no handle of the system".to_owned()));
};
let window = HWND(handle.hwnd.get() as *mut c_void);
let failed = |error: windows::core::Error| ShareError::Failed(error.to_string());
let interop = factory::<DataTransferManager, IDataTransferManagerInterop>().map_err(failed)?;
let manager: DataTransferManager = unsafe { interop.GetForWindow(window) }.map_err(failed)?;
if let Some((before, token)) = ASKED.with(|asked| asked.borrow_mut().take()) {
let _ = before.RemoveDataRequested(token);
}
let shared = share.clone();
let token = manager
.DataRequested(&TypedEventHandler::new(
move |_: Ref<DataTransferManager>, args: Ref<DataRequestedEventArgs>| {
let Some(args) = args.as_ref() else {
return Ok(());
};
let data = args.Request()?.Data()?;
let properties = data.Properties()?;
properties.SetTitle(&HSTRING::from(shared.title.as_deref().unwrap_or(&shared.url)))?;
if let Some(text) = &shared.text {
properties.SetDescription(&HSTRING::from(text))?;
}
let address = HSTRING::from(&shared.url);
let web = ["http://", "https://"]
.iter()
.any(|scheme| shared.url.to_ascii_lowercase().starts_with(scheme));
match Uri::CreateUri(&address) {
Ok(uri) if web => data.SetWebLink(&uri),
_ => data.SetText(&address),
}
},
))
.map_err(failed)?;
ASKED.with(|asked| *asked.borrow_mut() = Some((manager, token)));
unsafe { interop.ShowShareUIForWindow(window) }.map_err(failed)
}
}
#[cfg(any(target_os = "macos", target_os = "ios"))]
mod geometry {
#[repr(C)]
#[derive(Clone, Copy)]
pub(super) struct Rect {
pub(super) origin: Point,
pub(super) size: Size,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub(super) struct Point {
pub(super) x: f64,
pub(super) y: f64,
}
#[repr(C)]
#[derive(Clone, Copy)]
pub(super) struct Size {
pub(super) width: f64,
pub(super) height: f64,
}
unsafe impl objc2::Encode for Point {
const ENCODING: objc2::Encoding = objc2::Encoding::Struct("CGPoint", &[f64::ENCODING, f64::ENCODING]);
}
unsafe impl objc2::Encode for Size {
const ENCODING: objc2::Encoding = objc2::Encoding::Struct("CGSize", &[f64::ENCODING, f64::ENCODING]);
}
unsafe impl objc2::Encode for Rect {
const ENCODING: objc2::Encoding = objc2::Encoding::Struct("CGRect", &[Point::ENCODING, Size::ENCODING]);
}
pub(super) fn place(at: Option<crate::core::ElementRect>, bounds: Rect, flipped: bool) -> Rect {
let Some(at) = at else {
return Rect {
origin: Point {
x: bounds.origin.x + bounds.size.width / 2.0,
y: bounds.origin.y + bounds.size.height / 2.0,
},
size: Size {
width: 1.0,
height: 1.0,
},
};
};
let (y, height) = (f64::from(at.y), f64::from(at.height));
Rect {
origin: Point {
x: f64::from(at.x),
y: if flipped { y } else { bounds.size.height - y - height },
},
size: Size {
width: f64::from(at.width),
height,
},
}
}
}
#[cfg(target_os = "macos")]
mod system {
use std::ffi::c_void;
use objc2::{
class, msg_send,
rc::{Allocated, Retained},
runtime::AnyObject,
};
use objc2_foundation::{NSArray, NSString, NSURL};
use raw_window_handle::RawWindowHandle;
use super::{
Share, ShareError,
geometry::{Rect, place},
};
pub(super) fn supported() -> bool {
true
}
struct Asked {
view: Retained<AnyObject>,
share: Share,
}
unsafe impl Send for Asked {}
pub(super) fn show(window: Option<RawWindowHandle>, share: &Share) -> Result<(), ShareError> {
let Some(RawWindowHandle::AppKit(handle)) = window else {
return Err(ShareError::Failed("the window has no view of the system".to_owned()));
};
if NSURL::URLWithString(&NSString::from_str(&share.url)).is_none() {
return Err(ShareError::NotAnAddress);
}
let Some(view) = (unsafe { Retained::retain(handle.ns_view.as_ptr().cast::<AnyObject>()) }) else {
return Err(ShareError::Failed("the window has no view of the system".to_owned()));
};
let asked = Asked {
view,
share: share.clone(),
};
on_main(Box::new(move || pick(&asked)));
Ok(())
}
fn pick(asked: &Asked) {
let Some(address) = NSURL::URLWithString(&NSString::from_str(&asked.share.url)) else {
return;
};
let mut items: Vec<Retained<AnyObject>> = vec![Retained::into_super(Retained::into_super(address))];
if let Some(text) = &asked.share.text {
items.push(Retained::into_super(Retained::into_super(NSString::from_str(text))));
}
let items = NSArray::from_retained_slice(&items);
unsafe {
let picker: Allocated<AnyObject> = msg_send![class!(NSSharingServicePicker), alloc];
let picker: Retained<AnyObject> = msg_send![picker, initWithItems: &*items];
let bounds: Rect = msg_send![&*asked.view, bounds];
let flipped: bool = msg_send![&*asked.view, isFlipped];
let rect = place(asked.share.at, bounds, flipped);
let under: usize = if flipped { 3 } else { 1 };
let _: () = msg_send![&*picker, showRelativeToRect: rect, ofView: &*asked.view, preferredEdge: under];
}
}
unsafe extern "C" {
static _dispatch_main_q: c_void;
fn dispatch_async_f(queue: *const c_void, context: *mut c_void, work: extern "C" fn(*mut c_void));
}
fn on_main(work: Box<dyn FnOnce() + Send>) {
extern "C" fn run(context: *mut c_void) {
let work = unsafe { Box::from_raw(context.cast::<Box<dyn FnOnce() + Send>>()) };
work();
}
let context = Box::into_raw(Box::new(work)).cast::<c_void>();
unsafe { dispatch_async_f(&raw const _dispatch_main_q, context, run) };
}
}
#[cfg(target_os = "ios")]
mod system {
use std::{ffi::c_void, sync::Mutex};
use objc2::{
ClassType, class, msg_send,
rc::{Allocated, Retained},
runtime::{AnyClass, AnyObject, AnyProtocol, Bool, ClassBuilder, Sel},
sel,
};
use objc2_foundation::{NSArray, NSObject, NSString, NSURL};
use raw_window_handle::RawWindowHandle;
use super::{
Share, ShareError,
geometry::{Rect, place},
};
static SHARED: Mutex<Option<(String, String)>> = Mutex::new(None);
pub(super) fn supported() -> bool {
true
}
pub(super) fn show(window: Option<RawWindowHandle>, share: &Share) -> Result<(), ShareError> {
let Some(RawWindowHandle::UiKit(handle)) = window else {
return Err(ShareError::Failed("the window has no view of the system".to_owned()));
};
if objc2::MainThreadMarker::new().is_none() {
return Err(ShareError::Failed("the sheet is shown from the main thread".to_owned()));
}
if NSURL::URLWithString(&NSString::from_str(&share.url)).is_none() {
return Err(ShareError::NotAnAddress);
}
unsafe {
let view: &AnyObject = handle.ui_view.cast::<AnyObject>().as_ref();
let window: Option<Retained<AnyObject>> = msg_send![view, window];
let root: Option<Retained<AnyObject>> = match &window {
Some(window) => msg_send![&**window, rootViewController],
None => None,
};
let Some(mut over) = root else {
return Err(ShareError::Failed("the window has no view controller".to_owned()));
};
loop {
let presented: Option<Retained<AnyObject>> = msg_send![&*over, presentedViewController];
match presented {
Some(presented) => over = presented,
None => break,
}
}
*SHARED.lock().unwrap() = Some((share.url.clone(), share.title.clone().unwrap_or_default()));
let item: Retained<AnyObject> = msg_send![item_class(), new];
let mut items = vec![item];
if let Some(text) = &share.text {
items.push(Retained::into_super(Retained::into_super(NSString::from_str(text))));
}
let items = NSArray::from_retained_slice(&items);
let sheet: Allocated<AnyObject> = msg_send![class!(UIActivityViewController), alloc];
let sheet: Retained<AnyObject> = msg_send![
sheet,
initWithActivityItems: &*items,
applicationActivities: None::<&NSArray<AnyObject>>
];
let popover: Option<Retained<AnyObject>> = msg_send![&*sheet, popoverPresentationController];
if let Some(popover) = popover {
let bounds: Rect = msg_send![view, bounds];
let _: () = msg_send![&*popover, setSourceView: view];
let _: () = msg_send![&*popover, setSourceRect: place(share.at, bounds, true)];
if share.at.is_none() {
let _: () = msg_send![&*popover, setPermittedArrowDirections: 0usize];
}
}
let _: () =
msg_send![&*over, presentViewController: &*sheet, animated: Bool::YES, completion: std::ptr::null::<c_void>()];
}
Ok(())
}
fn address() -> *mut AnyObject {
let shared = SHARED.lock().unwrap();
let address = shared
.as_ref()
.and_then(|(address, _)| NSURL::URLWithString(&NSString::from_str(address)));
match address {
Some(address) => Retained::autorelease_ptr(Retained::into_super(Retained::into_super(address))),
None => std::ptr::null_mut(),
}
}
extern "C-unwind" fn placeholder(_this: &AnyObject, _cmd: Sel, _sheet: *mut AnyObject) -> *mut AnyObject {
address()
}
extern "C-unwind" fn item(
_this: &AnyObject,
_cmd: Sel,
_sheet: *mut AnyObject,
_activity: *mut AnyObject,
) -> *mut AnyObject {
address()
}
extern "C-unwind" fn subject(
_this: &AnyObject,
_cmd: Sel,
_sheet: *mut AnyObject,
_activity: *mut AnyObject,
) -> *mut AnyObject {
let shared = SHARED.lock().unwrap();
let title = shared.as_ref().map_or("", |(_, title)| title.as_str());
Retained::autorelease_ptr(Retained::into_super(Retained::into_super(NSString::from_str(title))))
}
fn item_class() -> &'static AnyClass {
if let Some(class) = AnyClass::get(c"LurqShareItem") {
return class;
}
let mut builder = ClassBuilder::new(c"LurqShareItem", NSObject::class()).expect("a class name of its own");
if let Some(protocol) = AnyProtocol::get(c"UIActivityItemSource") {
builder.add_protocol(protocol);
}
unsafe {
builder.add_method(
sel!(activityViewControllerPlaceholderItem:),
placeholder as extern "C-unwind" fn(_, _, _) -> _,
);
builder.add_method(
sel!(activityViewController:itemForActivityType:),
item as extern "C-unwind" fn(_, _, _, _) -> _,
);
builder.add_method(
sel!(activityViewController:subjectForActivityType:),
subject as extern "C-unwind" fn(_, _, _, _) -> _,
);
}
builder.register()
}
}
#[cfg(target_arch = "wasm32")]
mod system {
use raw_window_handle::RawWindowHandle;
use wasm_bindgen::{JsCast, JsValue};
use super::{Share, ShareError};
fn sharing() -> Option<(web_sys::Navigator, js_sys::Function)> {
let navigator = web_sys::window()?.navigator();
let share = js_sys::Reflect::get(&navigator, &JsValue::from_str("share")).ok()?;
share
.dyn_into::<js_sys::Function>()
.ok()
.map(|share| (navigator, share))
}
pub(super) fn supported() -> bool {
sharing().is_some()
}
pub(super) fn show(_window: Option<RawWindowHandle>, share: &Share) -> Result<(), ShareError> {
let (navigator, function) = sharing().ok_or(ShareError::Unsupported)?;
let data = js_sys::Object::new();
let say = |name: &str, value: &str| {
let _ = js_sys::Reflect::set(&data, &JsValue::from_str(name), &JsValue::from_str(value));
};
say("url", &share.url);
if let Some(title) = &share.title {
say("title", title);
}
if let Some(text) = &share.text {
say("text", text);
}
let answer = function
.call1(&navigator, &data)
.map_err(|error| ShareError::Failed(format!("{error:?}")))?;
if let Ok(promise) = answer.dyn_into::<js_sys::Promise>() {
wasm_bindgen_futures::spawn_local(async move {
let _ = wasm_bindgen_futures::JsFuture::from(promise).await;
});
}
Ok(())
}
}
#[cfg(not(any(windows, target_os = "macos", target_os = "ios", target_arch = "wasm32")))]
mod system {
use raw_window_handle::RawWindowHandle;
use super::{Share, ShareError};
pub(super) fn supported() -> bool {
false
}
pub(super) fn show(_window: Option<RawWindowHandle>, _share: &Share) -> Result<(), ShareError> {
Err(ShareError::Unsupported)
}
}
#[cfg(test)]
mod tests {
use std::sync::Mutex;
use super::*;
fn given() -> (Arc<Mutex<Vec<String>>>, StandIn) {
let shared = Arc::new(Mutex::new(Vec::<String>::new()));
let log = shared.clone();
let held = stand_in(move |share| {
log
.lock()
.unwrap()
.push(format!("{} | {:?} | {:?}", share.url, share.title, share.text));
});
(shared, held)
}
#[test]
fn a_stand_in_is_given_what_is_shared_with_its_address_trimmed() {
let (shared, _held) = given();
assert!(supported());
let asked = ask(Share::url(" https://lurq.dev/a ").title("The docs").text("Read this"));
assert!(matches!(asked, Ok(Asked::Done)));
assert!(matches!(
ask(Share::url("mailto:ivan@lurq.dev").title(" ")),
Ok(Asked::Done)
));
assert_eq!(
*shared.lock().unwrap(),
[
"https://lurq.dev/a | Some(\"The docs\") | Some(\"Read this\")",
"mailto:ivan@lurq.dev | None | None",
]
);
}
#[test]
fn only_an_address_with_a_scheme_is_shared() {
let (shared, _held) = given();
for url in ["", "lurq.dev", "C:\\Users\\notes.txt", "file:///etc/passwd"] {
assert!(matches!(ask(Share::url(url)), Err(ShareError::NotAnAddress)), "{url:?}");
}
assert!(shared.lock().unwrap().is_empty(), "nothing was given on");
}
#[test]
fn the_stand_in_before_is_back_once_one_is_dropped() {
let (outer, _held) = given();
{
let (inner, _held) = given();
let _ = ask(Share::url("https://lurq.dev/inner"));
assert_eq!(inner.lock().unwrap().len(), 1);
}
let _ = ask(Share::url("https://lurq.dev/outer"));
assert_eq!(*outer.lock().unwrap(), ["https://lurq.dev/outer | None | None"]);
}
#[test]
fn a_share_takes_the_place_of_the_element_it_comes_from() {
let rect = ElementRect {
x: 10.0,
y: 20.0,
relative_x: 0.0,
relative_y: 0.0,
width: 30.0,
height: 40.0,
};
assert_eq!(Share::url("https://lurq.dev").at_rect(rect).at, Some(rect));
assert_eq!(Share::url("https://lurq.dev").at(&ElementRef::new()).at, None);
}
}