Make handle fields private

This allows structs to define additional safety invariants (which would
otherwise be trivial to override by modifying the field).

This allows done one of:
- Adding reference-counting to platform handles.
- Combining `WindowHandle<'_>` and `RawWindowHandle`.

Depending on what we want to do in the future.

Author: madsmtm

src/android.rs

@@ -47,14 +47,12 @@ impl DisplayHandle<'static> {
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct AndroidNdkWindowHandle {
-    /// A pointer to an `ANativeWindow`.
-    pub a_native_window: NonNull<c_void>,
+    a_native_window: NonNull<c_void>,
 }
 
 impl AndroidNdkWindowHandle {
     /// Create a new handle to an `ANativeWindow`.
     ///
-    ///
     /// # Example
     ///
     /// ```
@@ -69,4 +67,21 @@ impl AndroidNdkWindowHandle {
     pub fn new(a_native_window: NonNull<c_void>) -> Self {
         Self { a_native_window }
     }
+
+    /// A pointer to an `ANativeWindow`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use core::ptr::NonNull;
+    /// # use raw_window_handle::AndroidNdkWindowHandle;
+    /// # type ANativeWindow = ();
+    /// #
+    /// # let handle = AndroidNdkWindowHandle::new(NonNull::dangling());
+    /// let ptr = handle.a_native_window();
+    /// let ptr = ptr.cast::<ANativeWindow>();
+    /// ```
+    pub fn a_native_window(&self) -> NonNull<c_void> {
+        self.a_native_window
+    }
 }

src/appkit.rs

@@ -48,46 +48,10 @@ impl DisplayHandle<'static> {
 /// Note that `NSView` can only be accessed from the main thread of the
 /// application. This struct is `!Send` and `!Sync` to help with ensuring
 /// that.
-///
-/// # Example
-///
-/// Getting the view from a [`WindowHandle`][crate::WindowHandle].
-///
-/// ```no_run
-/// # fn inner() {
-/// #![cfg(target_os = "macos")]
-/// # #[cfg(requires_objc2)]
-/// use objc2::MainThreadMarker;
-/// # #[cfg(requires_objc2)]
-/// use objc2::rc::Retained;
-/// # #[cfg(requires_objc2)]
-/// use objc2_app_kit::NSView;
-/// use raw_window_handle::{WindowHandle, RawWindowHandle};
-///
-/// let handle: WindowHandle<'_>; // Get the window handle from somewhere else
-/// # handle = unimplemented!();
-/// match handle.as_raw() {
-///     # #[cfg(requires_objc2)]
-///     RawWindowHandle::AppKit(handle) => {
-///         assert!(MainThreadMarker::new().is_some(), "can only access AppKit handles on the main thread");
-///         let ns_view = handle.ns_view.as_ptr();
-///         // SAFETY: The pointer came from `WindowHandle`, which ensures
-///         // that the `AppKitWindowHandle` contains a valid pointer to an
-///         // `NSView`.
-///         // Unwrap is fine, since the pointer came from `NonNull`.
-///         let ns_view: Retained<NSView> = unsafe { Retained::retain(ns_view.cast()) }.unwrap();
-///         // Do something with the NSView here, like getting the `NSWindow`
-///         let ns_window = ns_view.window().expect("view was not installed in a window");
-///     }
-///     handle => unreachable!("unknown handle {handle:?} for platform"),
-/// }
-/// # }
-/// ```
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct AppKitWindowHandle {
-    /// A pointer to an `NSView` object.
-    pub ns_view: NonNull<c_void>,
+    ns_view: NonNull<c_void>,
 }
 
 impl AppKitWindowHandle {
@@ -112,4 +76,44 @@ impl AppKitWindowHandle {
     pub fn new(ns_view: NonNull<c_void>) -> Self {
         Self { ns_view }
     }
+
+    /// A pointer to an `NSView` object.
+    ///
+    /// # Example
+    ///
+    /// Getting the view from a [`WindowHandle`][crate::WindowHandle].
+    ///
+    /// ```no_run
+    /// # fn inner() {
+    /// #![cfg(target_os = "macos")]
+    /// # #[cfg(requires_objc2)]
+    /// use objc2::MainThreadMarker;
+    /// # #[cfg(requires_objc2)]
+    /// use objc2::rc::Retained;
+    /// # #[cfg(requires_objc2)]
+    /// use objc2_app_kit::NSView;
+    /// use raw_window_handle::{WindowHandle, RawWindowHandle};
+    ///
+    /// let handle: WindowHandle<'_>; // Get the window handle from somewhere else
+    /// # handle = unimplemented!();
+    /// match handle.as_raw() {
+    ///     # #[cfg(requires_objc2)]
+    ///     RawWindowHandle::AppKit(handle) => {
+    ///         assert!(MainThreadMarker::new().is_some(), "can only access AppKit handles on the main thread");
+    ///         let ns_view = handle.ns_view().as_ptr();
+    ///         // SAFETY: The pointer came from `WindowHandle`, which ensures
+    ///         // that the `AppKitWindowHandle` contains a valid pointer to an
+    ///         // `NSView`.
+    ///         // Unwrap is fine, since the pointer came from `NonNull`.
+    ///         let ns_view: Retained<NSView> = unsafe { Retained::retain(ns_view.cast()) }.unwrap();
+    ///         // Do something with the NSView here, like getting the `NSWindow`
+    ///         let ns_window = ns_view.window().expect("view was not installed in a window");
+    ///     }
+    ///     handle => unreachable!("unknown handle {handle:?} for platform"),
+    /// }
+    /// # }
+    /// ```
+    pub fn ns_view(&self) -> NonNull<c_void> {
+        self.ns_view
+    }
 }