Merge ffi/wrappers: sc_retained! macro + null-checked constructors

Consolidates ~21 hand-written retain/release impls into the audited
sc_retained! macro and folds 10 raw-pointer call sites onto
from_retained_ptr (None-on-null). SCStream and SCRecordingOutput keep
their hand-written Drop/Clone (teardown ordering / delegate refcount).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 1313

src/content_sharing_picker.rs

@@ -285,25 +285,12 @@ impl Default for SCContentSharingPickerConfiguration {
     }
 }
 
-impl Clone for SCContentSharingPickerConfiguration {
-    fn clone(&self) -> Self {
-        unsafe {
-            Self {
-                ptr: crate::ffi::sc_content_sharing_picker_configuration_retain(self.ptr),
-            }
-        }
-    }
-}
-
-impl Drop for SCContentSharingPickerConfiguration {
-    fn drop(&mut self) {
-        if !self.ptr.is_null() {
-            unsafe {
-                crate::ffi::sc_content_sharing_picker_configuration_release(self.ptr);
-            }
-        }
-    }
-}
+crate::utils::retained::sc_retained!(
+    SCContentSharingPickerConfiguration,
+    field = ptr,
+    retain = crate::ffi::sc_content_sharing_picker_configuration_retain,
+    release = crate::ffi::sc_content_sharing_picker_configuration_release,
+);
 
 impl std::fmt::Debug for SCContentSharingPickerConfiguration {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -441,11 +428,7 @@ impl SCPickerResult {
         (0..count)
             .filter_map(|i| {
                 let ptr = unsafe { crate::ffi::sc_picker_result_get_window_at(self.ptr, i) };
-                if ptr.is_null() {
-                    None
-                } else {
-                    Some(crate::shareable_content::SCWindow::from_ffi_owned(ptr))
-                }
+                unsafe { crate::shareable_content::SCWindow::from_retained_ptr(ptr) }
             })
             .collect()
     }
@@ -479,11 +462,7 @@ impl SCPickerResult {
         (0..count)
             .filter_map(|i| {
                 let ptr = unsafe { crate::ffi::sc_picker_result_get_display_at(self.ptr, i) };
-                if ptr.is_null() {
-                    None
-                } else {
-                    Some(crate::shareable_content::SCDisplay::from_ffi_owned(ptr))
-                }
+                unsafe { crate::shareable_content::SCDisplay::from_retained_ptr(ptr) }
             })
             .collect()
     }
@@ -497,11 +476,7 @@ impl SCPickerResult {
         (0..count)
             .filter_map(|i| {
                 let ptr = unsafe { crate::ffi::sc_picker_result_get_application_at(self.ptr, i) };
-                if ptr.is_null() {
-                    None
-                } else {
-                    Some(crate::shareable_content::SCRunningApplication::from_ffi_owned(ptr))
-                }
+                unsafe { crate::shareable_content::SCRunningApplication::from_retained_ptr(ptr) }
             })
             .collect()
     }
@@ -543,15 +518,11 @@ impl SCPickerResult {
     }
 }
 
-impl Drop for SCPickerResult {
-    fn drop(&mut self) {
-        if !self.ptr.is_null() {
-            unsafe {
-                crate::ffi::sc_picker_result_release(self.ptr);
-            }
-        }
-    }
-}
+crate::utils::retained::sc_retained!(
+    SCPickerResult,
+    field = ptr,
+    release = crate::ffi::sc_picker_result_release,
+);
 
 impl std::fmt::Debug for SCPickerResult {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

src/recording_output.rs

@@ -259,25 +259,12 @@ impl Default for SCRecordingOutputConfiguration {
     }
 }
 
-impl Clone for SCRecordingOutputConfiguration {
-    fn clone(&self) -> Self {
-        unsafe {
-            Self {
-                ptr: crate::ffi::sc_recording_output_configuration_retain(self.ptr),
-            }
-        }
-    }
-}
-
-impl Drop for SCRecordingOutputConfiguration {
-    fn drop(&mut self) {
-        if !self.ptr.is_null() {
-            unsafe {
-                crate::ffi::sc_recording_output_configuration_release(self.ptr);
-            }
-        }
-    }
-}
+crate::utils::retained::sc_retained!(
+    SCRecordingOutputConfiguration,
+    field = ptr,
+    retain = crate::ffi::sc_recording_output_configuration_retain,
+    release = crate::ffi::sc_recording_output_configuration_release,
+);
 
 impl std::fmt::Debug for SCRecordingOutputConfiguration {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

src/screenshot_manager.rs

@@ -1031,15 +1031,11 @@ impl Default for SCScreenshotConfiguration {
 }
 
 #[cfg(feature = "macos_26_0")]
-impl Drop for SCScreenshotConfiguration {
-    fn drop(&mut self) {
-        if !self.ptr.is_null() {
-            unsafe {
-                crate::ffi::sc_screenshot_configuration_release(self.ptr);
-            }
-        }
-    }
-}
+crate::utils::retained::sc_retained!(
+    SCScreenshotConfiguration,
+    field = ptr,
+    release = crate::ffi::sc_screenshot_configuration_release,
+);
 
 #[cfg(feature = "macos_26_0")]
 unsafe impl Send for SCScreenshotConfiguration {}
@@ -1116,15 +1112,11 @@ impl std::fmt::Debug for SCScreenshotOutput {
 }
 
 #[cfg(feature = "macos_26_0")]
-impl Drop for SCScreenshotOutput {
-    fn drop(&mut self) {
-        if !self.ptr.is_null() {
-            unsafe {
-                crate::ffi::sc_screenshot_output_release(self.ptr);
-            }
-        }
-    }
-}
+crate::utils::retained::sc_retained!(
+    SCScreenshotOutput,
+    field = ptr,
+    release = crate::ffi::sc_screenshot_output_release,
+);
 
 #[cfg(feature = "macos_26_0")]
 unsafe impl Send for SCScreenshotOutput {}

src/shareable_content/display.rs

@@ -46,10 +46,17 @@ impl SCDisplay {
         Self(ptr)
     }
 
-    /// Create from FFI-owned pointer (caller transfers ownership)
-    #[allow(dead_code)]
-    pub(crate) fn from_ffi_owned(ptr: *const c_void) -> Self {
-        Self(ptr)
+    /// Create from an FFI-owned (retained) pointer, returning `None` if null.
+    ///
+    /// # Safety
+    /// `ptr` must be null or a valid retained `SCDisplay` pointer transferred
+    /// from the Swift FFI bridge (ownership moves into the returned wrapper).
+    pub(crate) unsafe fn from_retained_ptr(ptr: *const c_void) -> Option<Self> {
+        if ptr.is_null() {
+            None
+        } else {
+            Some(unsafe { Self::from_ptr(ptr) })
+        }
     }
 
     /// Get the raw pointer (used internally)
@@ -125,21 +132,11 @@ impl SCDisplay {
     }
 }
 
-impl Drop for SCDisplay {
-    fn drop(&mut self) {
-        if !self.0.is_null() {
-            unsafe {
-                crate::ffi::sc_display_release(self.0);
-            }
-        }
-    }
-}
-
-impl Clone for SCDisplay {
-    fn clone(&self) -> Self {
-        unsafe { Self(crate::ffi::sc_display_retain(self.0)) }
-    }
-}
+crate::utils::retained::sc_retained!(
+    SCDisplay,
+    retain = crate::ffi::sc_display_retain,
+    release = crate::ffi::sc_display_release,
+);
 
 unsafe impl Send for SCDisplay {}
 unsafe impl Sync for SCDisplay {}

src/shareable_content/mod.rs

@@ -130,12 +130,6 @@ impl std::hash::Hash for SCShareableContent {
     }
 }
 
-impl Clone for SCShareableContent {
-    fn clone(&self) -> Self {
-        unsafe { Self(crate::ffi::sc_shareable_content_retain(self.0)) }
-    }
-}
-
 impl SCShareableContent {
     /// Create from raw pointer (used internally)
     ///
@@ -212,9 +206,7 @@ impl SCShareableContent {
 
             for i in 0..count {
                 let display_ptr = crate::ffi::sc_shareable_content_get_display_at(self.0, i);
-                if !display_ptr.is_null() {
-                    displays.push(SCDisplay::from_ptr(display_ptr));
-                }
+                displays.extend(SCDisplay::from_retained_ptr(display_ptr));
             }
 
             displays
@@ -247,9 +239,7 @@ impl SCShareableContent {
 
             for i in 0..count {
                 let window_ptr = crate::ffi::sc_shareable_content_get_window_at(self.0, i);
-                if !window_ptr.is_null() {
-                    windows.push(SCWindow::from_ptr(window_ptr));
-                }
+                windows.extend(SCWindow::from_retained_ptr(window_ptr));
             }
 
             windows
@@ -280,9 +270,7 @@ impl SCShareableContent {
 
             for i in 0..count {
                 let app_ptr = crate::ffi::sc_shareable_content_get_application_at(self.0, i);
-                if !app_ptr.is_null() {
-                    apps.push(SCRunningApplication::from_ptr(app_ptr));
-                }
+                apps.extend(SCRunningApplication::from_retained_ptr(app_ptr));
             }
 
             apps
@@ -321,15 +309,11 @@ impl SCShareableContent {
     }
 }
 
-impl Drop for SCShareableContent {
-    fn drop(&mut self) {
-        if !self.0.is_null() {
-            unsafe {
-                crate::ffi::sc_shareable_content_release(self.0);
-            }
-        }
-    }
-}
+crate::utils::retained::sc_retained!(
+    SCShareableContent,
+    retain = crate::ffi::sc_shareable_content_retain,
+    release = crate::ffi::sc_shareable_content_release,
+);
 
 impl fmt::Debug for SCShareableContent {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -586,22 +570,11 @@ impl SCShareableContentInfo {
 }
 
 #[cfg(feature = "macos_14_0")]
-impl Drop for SCShareableContentInfo {
-    fn drop(&mut self) {
-        if !self.0.is_null() {
-            unsafe {
-                crate::ffi::sc_shareable_content_info_release(self.0);
-            }
-        }
-    }
-}
-
-#[cfg(feature = "macos_14_0")]
-impl Clone for SCShareableContentInfo {
-    fn clone(&self) -> Self {
-        unsafe { Self(crate::ffi::sc_shareable_content_info_retain(self.0)) }
-    }
-}
+crate::utils::retained::sc_retained!(
+    SCShareableContentInfo,
+    retain = crate::ffi::sc_shareable_content_info_retain,
+    release = crate::ffi::sc_shareable_content_info_release,
+);
 
 #[cfg(feature = "macos_14_0")]
 impl fmt::Debug for SCShareableContentInfo {

src/shareable_content/running_application.rs

@@ -46,10 +46,17 @@ impl SCRunningApplication {
         Self(ptr)
     }
 
-    /// Create from FFI-owned pointer (caller transfers ownership)
-    #[allow(dead_code)]
-    pub(crate) fn from_ffi_owned(ptr: *const c_void) -> Self {
-        Self(ptr)
+    /// Create from an FFI-owned (retained) pointer, returning `None` if null.
+    ///
+    /// # Safety
+    /// `ptr` must be null or a valid retained `SCRunningApplication` pointer
+    /// transferred from the Swift FFI bridge (ownership moves into the wrapper).
+    pub(crate) unsafe fn from_retained_ptr(ptr: *const c_void) -> Option<Self> {
+        if ptr.is_null() {
+            None
+        } else {
+            Some(unsafe { Self::from_ptr(ptr) })
+        }
     }
 
     /// Get the raw pointer (used internally)
@@ -81,21 +88,11 @@ impl SCRunningApplication {
     }
 }
 
-impl Drop for SCRunningApplication {
-    fn drop(&mut self) {
-        if !self.0.is_null() {
-            unsafe {
-                crate::ffi::sc_running_application_release(self.0);
-            }
-        }
-    }
-}
-
-impl Clone for SCRunningApplication {
-    fn clone(&self) -> Self {
-        unsafe { Self(crate::ffi::sc_running_application_retain(self.0)) }
-    }
-}
+crate::utils::retained::sc_retained!(
+    SCRunningApplication,
+    retain = crate::ffi::sc_running_application_retain,
+    release = crate::ffi::sc_running_application_release,
+);
 
 impl fmt::Debug for SCRunningApplication {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {