objc2_av_foundation/generated/

AVCaptureExternalDisplayConfigurator.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
#[cfg(feature = "objc2-core-media")]
use objc2_core_media::*;
#[cfg(feature = "objc2-quartz-core")]
#[cfg(not(target_os = "watchos"))]
use objc2_quartz_core::*;

use crate::*;

extern_class!(
    /// A class you use to specify a configuration to your external display configurator.
    ///
    /// Using an ``AVCaptureExternalDisplayConfiguration``, you direct your ``AVCaptureExternalDisplayConfigurator`` how to configure an external display to match your device's active video format.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avcaptureexternaldisplayconfiguration?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct AVCaptureExternalDisplayConfiguration;
);

extern_conformance!(
    unsafe impl NSObjectProtocol for AVCaptureExternalDisplayConfiguration {}
);

impl AVCaptureExternalDisplayConfiguration {
    extern_methods!(
        /// A property indicating whether the frame rate of the external display should be configured to match the camera's frame rate.
        ///
        /// If you want to configure your ``AVCaptureVideoPreviewLayer`` to match its source ``AVCaptureDevice/activeVideoMinFrameDuration``, set ``shouldMatchFrameRate`` to `true`. The default value is `false`.
        #[unsafe(method(shouldMatchFrameRate))]
        #[unsafe(method_family = none)]
        pub unsafe fn shouldMatchFrameRate(&self) -> bool;

        /// Setter for [`shouldMatchFrameRate`][Self::shouldMatchFrameRate].
        #[unsafe(method(setShouldMatchFrameRate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setShouldMatchFrameRate(&self, should_match_frame_rate: bool);

        /// A property indicating whether the color space of the configurator's preview layer should be preserved on the output display by avoiding color space conversions.
        ///
        /// Set ``bypassColorSpaceConversion`` to `true` if you would like the configurator's  ``AVCaptureVideoPreviewLayer`` color space preserved on the output display. This is accomplished by setting the working color space to match the color space of the external display. The color properties of the ``CALayer`` remain untouched. The default value is `false`.
        #[unsafe(method(bypassColorSpaceConversion))]
        #[unsafe(method_family = none)]
        pub unsafe fn bypassColorSpaceConversion(&self) -> bool;

        /// Setter for [`bypassColorSpaceConversion`][Self::bypassColorSpaceConversion].
        #[unsafe(method(setBypassColorSpaceConversion:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setBypassColorSpaceConversion(&self, bypass_color_space_conversion: bool);

        #[cfg(feature = "objc2-core-media")]
        /// Your preferred external display resolution.
        ///
        /// Use ``preferredResolution`` to set your desired resolution of the external display. When left at the default value of { 0, 0 },  the native resolution of the external display is used.
        #[unsafe(method(preferredResolution))]
        #[unsafe(method_family = none)]
        pub unsafe fn preferredResolution(&self) -> CMVideoDimensions;

        #[cfg(feature = "objc2-core-media")]
        /// Setter for [`preferredResolution`][Self::preferredResolution].
        #[unsafe(method(setPreferredResolution:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPreferredResolution(&self, preferred_resolution: CMVideoDimensions);
    );
}

/// Methods declared on superclass `NSObject`.
impl AVCaptureExternalDisplayConfiguration {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// A configurator class allowing you to configure properties of an external display to match the camera's active video format.
    ///
    /// An ``AVCaptureExternalDisplayConfigurator`` allows you to configure a connected external display to output a clean feed using a ``CALayer``. Using the configurator, you can opt into automatic adjustment of the external display’s color space and / or frame rate to match your device’s capture configuration. These adjustments are only applied to the external display, not to the device.
    ///
    /// - Note: Not all displays support the same configuration options as the device’s capture formats. Your adjustments to the external display are applied with utmost effort to accurately represent the capture device. When your capture device's ``AVCaptureDevice/activeFormat`` is unavailable on the external display, the configurator automatically chooses the closest available format.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avcaptureexternaldisplayconfigurator?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct AVCaptureExternalDisplayConfigurator;
);

extern_conformance!(
    unsafe impl NSObjectProtocol for AVCaptureExternalDisplayConfigurator {}
);

impl AVCaptureExternalDisplayConfigurator {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;

        #[cfg(all(feature = "AVCaptureDevice", feature = "objc2-quartz-core"))]
        #[cfg(not(target_os = "watchos"))]
        /// An external display configurator instance that attempts to synchronize the preview layer configuration with the device capture configuration.
        ///
        /// - Parameter device: The device for which to monitor the configuration.
        /// - Parameter previewLayer: The layer that is being used on an external display for displaying the camera preview.
        /// - Parameter configuration: A configuration specifying which aspects of the camera's active format to monitor and configure on the external display.
        /// - Returns: an ``AVCaptureExternalDisplayConfigurator`` instance.
        ///
        /// An ``AVCaptureExternalDisplayConfigurator`` is only applicable to external displays. It determines which properties to configure on the external display based on your provided configuration (see ``AVCaptureExternalDisplayConfiguration``). The configurator observes changes to your camera''s configuration, and when changes are observed, it modifies the external display's properties to match.
        ///
        /// If multiple configurators are linked to the same external display ,the last one created becomes the active configurator for the external display (see ``active``).
        ///
        /// - Important: An `NSInvalidArgumentException` is thrown if any of the ``AVCaptureExternalDisplayConfiguration`` options are not supported.
        #[unsafe(method(initWithDevice:previewLayer:configuration:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithDevice_previewLayer_configuration(
            this: Allocated<Self>,
            device: &AVCaptureDevice,
            preview_layer: &CALayer,
            configuration: &AVCaptureExternalDisplayConfiguration,
        ) -> Retained<Self>;

        #[cfg(feature = "AVCaptureDevice")]
        /// The device for which the coordinator configures the preview layer.
        ///
        /// The value of this property is the ``AVCaptureDevice`` instance you provided when instantiating the configurator. ``AVCaptureExternalDisplayConfigurator`` holds a weak reference to the device. If the device is released, this property returns `nil`.
        #[unsafe(method(device))]
        #[unsafe(method_family = none)]
        pub unsafe fn device(&self) -> Option<Retained<AVCaptureDevice>>;

        #[cfg(feature = "objc2-quartz-core")]
        #[cfg(not(target_os = "watchos"))]
        /// The layer for which the configurator adjusts display properties to match the device's state.
        ///
        /// The value of this property is the ``CALayer`` instance that you provided when instantiating the configurator. You may specify either an ``AVCaptureVideoPreviewLayer`` or another ``CALayer`` instance that displays a camera's video preview. ``AVCaptureExternalDisplayConfigurator``holds a weak reference to the layer. If the layer is released, this property returns `nil`.
        #[unsafe(method(previewLayer))]
        #[unsafe(method_family = none)]
        pub unsafe fn previewLayer(&self) -> Option<Retained<CALayer>>;

        /// This property tells you whether the configurator is actively configuring the external display.
        ///
        /// When this property returns `true`, the external display is successfully configured to match the device. If it returns`false`, the configurator is not making any configuration changes to the external display. If another ``AVCaptureExternalDisplayConfigurator`` instance takes over the configuration of the external display, this property returns `false`.
        #[unsafe(method(isActive))]
        #[unsafe(method_family = none)]
        pub unsafe fn isActive(&self) -> bool;

        /// Forces the external display configurator to asynchronously stop configuring the external display.
        ///
        /// Call ``stop`` to force the ``AVCaptureExternalDisplayConfigurator`` to asynchronously stop configuring the external display. Once stopped, the ``active`` property changes to `false` and the ``activeExternalDisplayFrameRate`` becomes 0.
        #[unsafe(method(stop))]
        #[unsafe(method_family = none)]
        pub unsafe fn stop(&self);

        /// The currently configured frame rate on the external display that's displaying the preview layer.
        ///
        /// Observe this property to determine if the configured frame rate matches the max frame rate (``AVCaptureDevice/activeVideoMinFrameDuration``) of the device. When the ``active`` property becomes `false`, this property changes to 0.
        #[unsafe(method(activeExternalDisplayFrameRate))]
        #[unsafe(method_family = none)]
        pub unsafe fn activeExternalDisplayFrameRate(&self) -> c_double;

        /// Whether the external display supports matching frame rate to a capture device.
        ///
        /// If `true`, you may instantiate a configurator with a configuration specifying ``AVCaptureExternalDisplayConfiguration/shouldMatchFrameRate`` set to `true`.
        #[unsafe(method(isMatchingFrameRateSupported))]
        #[unsafe(method_family = none)]
        pub unsafe fn isMatchingFrameRateSupported() -> bool;

        /// Whether the external display supports bypassing color space conversion.
        ///
        /// If `true`, you may instantiate a configurator with a configuration specifying ``AVCaptureExternalDisplayConfiguration/bypassColorSpaceConversion`` set to `true`.
        #[unsafe(method(isBypassingColorSpaceConversionSupported))]
        #[unsafe(method_family = none)]
        pub unsafe fn isBypassingColorSpaceConversionSupported() -> bool;

        /// Whether the external display supports configuration to your preferred resolution.
        ///
        /// If `true`, you may instantiate a configurator with a configuration specifying ``AVCaptureExternalDisplayConfiguration/preferredResolution`` set to `true`.
        #[unsafe(method(isPreferredResolutionSupported))]
        #[unsafe(method_family = none)]
        pub unsafe fn isPreferredResolutionSupported() -> bool;
    );
}