objc2_sensitive_content_analysis/generated/

SCVideoStreamAnalyzer.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-av-foundation")]
use objc2_av_foundation::*;
#[cfg(feature = "objc2-core-video")]
use objc2_core_video::*;
use objc2_foundation::*;
#[cfg(feature = "objc2-video-toolbox")]
use objc2_video_toolbox::*;

use crate::*;

/// Options for the different types of analyzed video streams.
///
/// Pass this enum into the ``SCVideoStreamAnalyzer/init(participantUUID:streamDirection:)`` initializer when creating an ``SCVideoStreamAnalyzer`` to analyze video streams.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/sensitivecontentanalysis/scvideostreamanalyzerstreamdirection?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SCVideoStreamAnalyzerStreamDirection(pub NSInteger);
impl SCVideoStreamAnalyzerStreamDirection {
    /// An option that refers to a video stream sent to another device.
    ///
    /// This option refers to the stream that originates from the device's camera.
    #[doc(alias = "SCVideoStreamAnalyzerStreamDirectionOutgoing")]
    pub const Outgoing: Self = Self(1);
    /// An option that indicates a video stream from another device.
    ///
    /// This option refers to a video stream that the device receives over the network from another device's camera.
    #[doc(alias = "SCVideoStreamAnalyzerStreamDirectionIncoming")]
    pub const Incoming: Self = Self(2);
}

unsafe impl Encode for SCVideoStreamAnalyzerStreamDirection {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

unsafe impl RefEncode for SCVideoStreamAnalyzerStreamDirection {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

/// A handler your app provides to receive video-stream analysis results.
///
/// Your app implements this handler and the framework calls it when the analyzer's video stream detects sensitive content, or an error providing corresponding analysis, or error as input parameters.
///
/// This handler receives an instance of ``SCSensitivityAnalysis``, and an
/// <doc
/// ://com.apple.documentation/documentation/swift/error>, for example:
///
/// ```swift
/// analyzer.analysisChangedHandler = { analysis, error in
/// self.analysis = analysis
/// if analysis.shouldInterruptVideo {
/// // ...
/// }
/// if analysis.shouldIndicateSensitivity {
/// // ...
/// }
/// if analysis.shouldMuteAudio {
/// // ...
/// }
/// }
/// ```
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/sensitivecontentanalysis/scvideostreamanalysischangehandler?language=objc)
#[cfg(all(feature = "SCSensitivityAnalysis", feature = "block2"))]
pub type SCVideoStreamAnalysisChangeHandler =
    *mut block2::DynBlock<dyn Fn(*mut SCSensitivityAnalysis, *mut NSError)>;

extern_class!(
    /// Monitors a stream of video by analyzing frames for sensitive content.
    ///
    /// Use this class to detect senstive content in a video stream, such as on a conference call that your app implements. The class detects senstive content in the video stream from either the device's camera or the remote device(s) signed into the call, depending on how you configure the analyzer.
    ///
    /// Create an instance of this class for each video stream in the call.
    ///
    /// To begin analyzing the stream, pass it to either ``beginAnalysis(of:)-(AVCaptureDeviceInput)`` (
    /// <doc
    /// ://com.apple.documentation/documentation/avfoundation/avcapturedeviceinput>) or ``beginAnalysis(of:)-(VTDecompressionSession)`` (
    /// <doc
    /// ://com.apple.documentation/documentation/videotoolbox/vtdecompressionsession>), depending on your video playback implementation.
    ///
    /// - Important: This class works only when the Communication Safety parental control in Screen Time is enabled, or when Sensitive Content Warnings is on in Settings. The initializers of this class throw an error if both settings are off.
    ///
    /// ### React to sensitive content
    ///
    /// When the framework detects sensitive content in the stream, it calls ``analysisChangedHandler`` immediately with an ``SCSensitivityAnalysis`` object that includes information about the detection.
    ///
    /// You implement the ``analysisChangedHandler`` callback to inspect the detection results, which includes confirmation that content is sensitve as well as guidance on next steps your app can take. The framework offers your app suggestions in the handler, which include:
    ///
    /// - Alerting the person to the presence of sensitive content (``SCSensitivityAnalysis/shouldIndicateSensitivity``)
    /// - Interrupting video playback (``SCSensitivityAnalysis/shouldInterruptVideo``)
    /// - Muting audio (``SCSensitivityAnalysis/shouldMuteAudio``)
    ///
    /// To stop analyzing the stream, call ``endAnalysis()``. If your app implements a custom stream decoder, you can analyze individual frames by passing pixel buffers to ``analyze(_:)``.
    ///
    /// In the event of an error during analysis, the handler receives an error object that details what went wrong. For more information, see: ``SCVideoStreamAnalysisChangeHandler``.
    ///
    /// ### Add the app entitlement
    ///
    /// To use this class, the system requires the
    /// <doc
    /// ://com.apple.documentation/documentation/bundleresources/entitlements/com.apple.developer.sensitivecontentanalysis.client> entitlement in your app's code signature. Calls to the framework fail to return positive results without it. You can can add this entitlement to your app by enabling the Sensitive Content Analysis capability in Xcode; see
    /// <doc
    /// ://com.apple.documentation/documentation/xcode/adding-capabilities-to-your-app>.
    ///
    /// For more information, see
    /// <doc
    /// :detecting-nudity-in-media-and-providing-intervention-options>.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensitivecontentanalysis/scvideostreamanalyzer?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SCVideoStreamAnalyzer;
);

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

impl SCVideoStreamAnalyzer {
    extern_methods!(
        #[cfg(feature = "SCSensitivityAnalysis")]
        /// The results of the first detected sensitive video frame.
        ///
        /// The analysis also includes suggestions for the app based on the nature of the sensitive content, specifically: ``SCSensitivityAnalysis/shouldInterruptVideo``, ``SCSensitivityAnalysis/shouldIndicateSensitivity`` and ``SCSensitivityAnalysis/shouldMuteAudio``.
        #[unsafe(method(analysis))]
        #[unsafe(method_family = none)]
        pub unsafe fn analysis(&self) -> Option<Retained<SCSensitivityAnalysis>>;

        #[cfg(all(feature = "SCSensitivityAnalysis", feature = "block2"))]
        /// A handler that your app provides to react to sensitive content detection.
        ///
        /// The system invokes all analyzer handlers on the same conference call with the updated analysis or error.
        ///
        /// # Safety
        ///
        /// - The returned block's argument 1 must be a valid pointer or null.
        /// - The returned block's argument 2 must be a valid pointer or null.
        #[unsafe(method(analysisChangedHandler))]
        #[unsafe(method_family = none)]
        pub unsafe fn analysisChangedHandler(&self) -> SCVideoStreamAnalysisChangeHandler;

        #[cfg(all(feature = "SCSensitivityAnalysis", feature = "block2"))]
        /// Setter for [`analysisChangedHandler`][Self::analysisChangedHandler].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        ///
        /// # Safety
        ///
        /// `analysis_changed_handler` must be a valid pointer or null.
        #[unsafe(method(setAnalysisChangedHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setAnalysisChangedHandler(
            &self,
            analysis_changed_handler: SCVideoStreamAnalysisChangeHandler,
        );

        /// Creates a video stream analyzer for the given call participant and stream option.
        ///
        /// - parameter participantUUID: A unique identifier that you provide to distinguish among multiple individuals on a conference call. Set this argument to the same value per person on the call, if your app supports multiple streams per person.
        /// - parameter streamDirection: An option that indicates whether the stream comes from the device's camera or from a remote individual signed in to the call.
        /// - parameter error: An error that occurs while intializing a video stream analyzer.
        ///
        /// - Important: This class works only when the Communication Safety parental control in Screen Time is enabled, or when Sensitive Content Warnings is on in Settings. This method throws an error if both settings are off, or if the device doesn't support analysis for the specified stream direction.
        #[unsafe(method(initWithParticipantUUID:streamDirection:error:_))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithParticipantUUID_streamDirection_error(
            this: Allocated<Self>,
            participant_uuid: &NSString,
            stream_direction: SCVideoStreamAnalyzerStreamDirection,
        ) -> Result<Retained<Self>, Retained<NSError>>;

        #[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(&self) -> Retained<Self>;

        #[cfg(feature = "objc2-core-video")]
        /// Analyzes individual video-stream frames for sensitive content.
        ///
        /// This method analyzes a specific video frame and updates ``analysis`` according to the results. If your app implements a custom stream decoder, you can call this method for each video frame.
        #[unsafe(method(analyzePixelBuffer:))]
        #[unsafe(method_family = none)]
        pub unsafe fn analyzePixelBuffer(&self, pixel_buffer: &CVPixelBuffer);
    );
}

/// Methods declared on superclass `NSObject`.
impl SCVideoStreamAnalyzer {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new_class() -> Retained<Self>;
    );
}

/// SessionManagement.
impl SCVideoStreamAnalyzer {
    extern_methods!(
        #[cfg(feature = "objc2-video-toolbox")]
        /// Analyzes video frames for the given decompression session.
        ///
        /// - parameter decompressionSession: An object that provides video frames for your app to analyze for sensitive content.
        /// - parameter error: An error object that describes an issue that occurs while providing the video decompression session.
        /// - returns: `YES` if the method succeeds; otherwise, `NO`.
        ///
        /// If the framework detects sensitive content in the video stream, the
        /// <doc
        /// ://com.apple.documentation/documentation/videotoolbox/vtdecompressionsession> produces blank frames to effectively censor the video stream on the person's behalf. When your app is ready to show the video stream again, resume analysis by calling ``continueStream``.
        #[unsafe(method(beginAnalysisOfDecompressionSession:error:_))]
        #[unsafe(method_family = none)]
        pub unsafe fn beginAnalysisOfDecompressionSession_error(
            &self,
            decompression_session: &VTDecompressionSession,
        ) -> Result<(), Retained<NSError>>;

        #[cfg(feature = "objc2-av-foundation")]
        /// Analyzes video frames for the given capture device input.
        ///
        /// - parameter captureDeviceInput: An object that contains information about the specific camera and its captured content in the video stream.
        /// - parameter error: An error object that describes an issue that occurs while processing the capture device input.
        /// - returns: `YES` if the method succeeds; otherwise, `NO`.
        ///
        /// Call this method to begin analyzing a video stream from the given
        /// <doc
        /// ://com.apple.documentation/documentation/avfoundation/avcapturedeviceinput>. If the framework detects sensitive content in the video stream, the capture-device-input interrupts subsequent frames with the `AVCaptureSessionInterruptionReasonSensitiveContentMitigationActivated` interruption reason to effectively censor the video stream on the person's behalf. When your app is ready to show the video stream again, resume analysis by calling ``continueStream``.
        #[unsafe(method(beginAnalysisOfCaptureDeviceInput:error:_))]
        #[unsafe(method_family = none)]
        pub unsafe fn beginAnalysisOfCaptureDeviceInput_error(
            &self,
            capture_device_input: &AVCaptureDeviceInput,
        ) -> Result<(), Retained<NSError>>;

        /// Stops stream analysis.
        ///
        /// This method stops analyzing the video stream in reference to the most recent call to `beginAnalysis`.
        #[unsafe(method(endAnalysis))]
        #[unsafe(method_family = none)]
        pub unsafe fn endAnalysis(&self);

        /// Indicates that your app is ready to resume video stream analysis.
        ///
        /// When the framework detects sensitive content in the video stream, it pauses analysis and begins censoring the stream's video frames. Call this method to resume analysis and stop censoring video frames when your app is ready to show the stream again.
        #[unsafe(method(continueStream))]
        #[unsafe(method_family = none)]
        pub unsafe fn continueStream(&self);
    );
}

/// VideoStreamAnalysis.
///
/// Intervention guidance that the framework recommends based on the nature of the detected sensitive content.
#[cfg(feature = "SCSensitivityAnalysis")]
impl SCSensitivityAnalysis {
    extern_methods!(
        /// Intervention guidance that suggests the app interrupt the video stream.
        #[unsafe(method(shouldInterruptVideo))]
        #[unsafe(method_family = none)]
        pub unsafe fn shouldInterruptVideo(&self) -> bool;

        /// Intervention guidance that suggests the app indicate the presence of sensitive content.
        #[unsafe(method(shouldIndicateSensitivity))]
        #[unsafe(method_family = none)]
        pub unsafe fn shouldIndicateSensitivity(&self) -> bool;

        /// Intervention guidance that suggests the app mute the audio of the current video stream.
        #[unsafe(method(shouldMuteAudio))]
        #[unsafe(method_family = none)]
        pub unsafe fn shouldMuteAudio(&self) -> bool;
    );
}