objc2_background_tasks/generated/

BGTaskRequest.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::*;
use objc2_foundation::*;

use crate::*;

extern_class!(
    /// An abstract class that represents a request for the app to be launched in the background to perform work.
    /// Do not instantiate instances of this class directly. Instead, use one of its concrete subclasses.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/backgroundtasks/bgtaskrequest?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct BGTaskRequest;
);

extern_conformance!(
    unsafe impl NSCopying for BGTaskRequest {}
);

unsafe impl CopyingHelper for BGTaskRequest {
    type Result = Self;
}

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

impl BGTaskRequest {
    extern_methods!(
        /// The identifier of the task associated with the request.
        #[unsafe(method(identifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn identifier(&self) -> Retained<NSString>;

        /// The earliest date and time at which to run the task.
        ///
        /// Specify `nil` for no start delay.
        ///
        /// Setting the property indicates that the background task shouldn’t start any
        /// earlier than this date. However, the system doesn’t guarantee launching the
        /// task at the specified date, but only that it won’t begin sooner.
        #[unsafe(method(earliestBeginDate))]
        #[unsafe(method_family = none)]
        pub unsafe fn earliestBeginDate(&self) -> Option<Retained<NSDate>>;

        /// Setter for [`earliestBeginDate`][Self::earliestBeginDate].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setEarliestBeginDate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setEarliestBeginDate(&self, earliest_begin_date: Option<&NSDate>);

        #[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 request to launch your app in the background to execute a short refresh task.
    ///
    /// Schedule a refresh task request to ask that the system launch your app briefly so that you can download data and
    /// keep your app's contents up-to-date. The system will fulfill this request intelligently based on system conditions
    /// and app usage.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/backgroundtasks/bgapprefreshtaskrequest?language=objc)
    #[unsafe(super(BGTaskRequest, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct BGAppRefreshTaskRequest;
);

extern_conformance!(
    unsafe impl NSCopying for BGAppRefreshTaskRequest {}
);

unsafe impl CopyingHelper for BGAppRefreshTaskRequest {
    type Result = Self;
}

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

impl BGAppRefreshTaskRequest {
    extern_methods!(
        /// Return a new refresh task request for the specified identifier.
        ///
        /// - Parameters:
        /// - identifier: The string identifier of the refresh task associated with the request.
        #[unsafe(method(initWithIdentifier:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithIdentifier(
            this: Allocated<Self>,
            identifier: &NSString,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `BGTaskRequest`.
impl BGAppRefreshTaskRequest {
    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 request to launch your app in the background to execute a processing task that can take minutes to complete.
    ///
    /// Schedule a processing task request to ask that the system launch your app when conditions are favorable for battery
    /// life to handle deferrable, longer-running processing, such as syncing, database maintenance, or similar tasks. The
    /// system will attempt to fulfill this request to the best of its ability within the next two days as long as the user
    /// has used your app within the past week.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/backgroundtasks/bgprocessingtaskrequest?language=objc)
    #[unsafe(super(BGTaskRequest, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct BGProcessingTaskRequest;
);

extern_conformance!(
    unsafe impl NSCopying for BGProcessingTaskRequest {}
);

unsafe impl CopyingHelper for BGProcessingTaskRequest {
    type Result = Self;
}

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

impl BGProcessingTaskRequest {
    extern_methods!(
        /// Return a new processing task request for the specified identifier.
        ///
        /// - Parameters:
        /// - identifier: The string identifier of the processing task associated with the request.
        #[unsafe(method(initWithIdentifier:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithIdentifier(
            this: Allocated<Self>,
            identifier: &NSString,
        ) -> Retained<Self>;

        /// A Boolean specifying if the processing task requires network connectivity.
        ///
        /// If this property is set to YES, the system will only launch your app to fulfill this request when the device has a
        /// network connection. If this is set to NO, your app may not have network access.
        /// - Note: The default value is `NO`.
        #[unsafe(method(requiresNetworkConnectivity))]
        #[unsafe(method_family = none)]
        pub unsafe fn requiresNetworkConnectivity(&self) -> bool;

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

        /// Whether the background task represented by this request should only be done while the device is connected to
        /// external power.
        ///
        /// If this property is set to `YES`, the system will launch your app to fulfill this request only while the device is
        /// connected to external power. Setting this to `YES` will also disable the CPU Monitor feature. Specify `YES` if this
        /// task is resource intensive to minimize impact to battery life. Please note that, even if this value is `NO`, the
        /// system will not necessarily schedule this task while the device is on battery power, depending on the type of
        /// device and system conditions.
        /// - Note: The default value is `NO`.
        #[unsafe(method(requiresExternalPower))]
        #[unsafe(method_family = none)]
        pub unsafe fn requiresExternalPower(&self) -> bool;

        /// Setter for [`requiresExternalPower`][Self::requiresExternalPower].
        #[unsafe(method(setRequiresExternalPower:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setRequiresExternalPower(&self, requires_external_power: bool);
    );
}

/// Methods declared on superclass `BGTaskRequest`.
impl BGProcessingTaskRequest {
    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 request to launch your app in the background to execute a health research task for studies a user has opted into
    /// and that can take minutes to complete.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/backgroundtasks/bghealthresearchtaskrequest?language=objc)
    #[unsafe(super(BGProcessingTaskRequest, BGTaskRequest, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct BGHealthResearchTaskRequest;
);

extern_conformance!(
    unsafe impl NSCopying for BGHealthResearchTaskRequest {}
);

unsafe impl CopyingHelper for BGHealthResearchTaskRequest {
    type Result = Self;
}

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

impl BGHealthResearchTaskRequest {
    extern_methods!(
        /// A String indicating file protection availability required for processing.
        ///
        /// Update this property to indicate what type of data needs to be accessible when the task is run. The default value
        /// is `NSFileProtectionCompleteUntilFirstUserAuthentication`
        ///
        /// # Safety
        ///
        /// This is not retained internally, you must ensure the object is still alive.
        #[unsafe(method(protectionTypeOfRequiredData))]
        #[unsafe(method_family = none)]
        pub unsafe fn protectionTypeOfRequiredData(&self) -> Retained<NSFileProtectionType>;

        /// Setter for [`protectionTypeOfRequiredData`][Self::protectionTypeOfRequiredData].
        ///
        /// # Safety
        ///
        /// This is unretained, you must ensure the object is kept alive while in use.
        #[unsafe(method(setProtectionTypeOfRequiredData:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setProtectionTypeOfRequiredData(
            &self,
            protection_type_of_required_data: &NSFileProtectionType,
        );
    );
}

/// Methods declared on superclass `BGProcessingTaskRequest`.
impl BGHealthResearchTaskRequest {
    extern_methods!(
        /// Return a new processing task request for the specified identifier.
        ///
        /// - Parameters:
        /// - identifier: The string identifier of the processing task associated with the request.
        #[unsafe(method(initWithIdentifier:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithIdentifier(
            this: Allocated<Self>,
            identifier: &NSString,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `BGTaskRequest`.
impl BGHealthResearchTaskRequest {
    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>;
    );
}

/// [Apple's documentation](https://developer.apple.com/documentation/backgroundtasks/bgcontinuedprocessingtaskrequestsubmissionstrategy?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct BGContinuedProcessingTaskRequestSubmissionStrategy(pub NSInteger);
impl BGContinuedProcessingTaskRequestSubmissionStrategy {
    /// Fail the submission if there is no room for the task request, or if the system is under substantial load and is
    /// unable immediately run the task.
    #[doc(alias = "BGContinuedProcessingTaskRequestSubmissionStrategyFail")]
    pub const Fail: Self = Self(0);
    /// Add the request to the back of a queue if there is no room for the submitted task or if the system is under
    /// substantial load and is unable to immediately run the task. Queued ``BGContinuedProcessingTaskRequest``s will be
    /// cancelled when the user removes your app from the app switcher.
    #[doc(alias = "BGContinuedProcessingTaskRequestSubmissionStrategyQueue")]
    pub const Queue: Self = Self(1);
}

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

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

/// [Apple's documentation](https://developer.apple.com/documentation/backgroundtasks/bgcontinuedprocessingtaskrequestresources?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct BGContinuedProcessingTaskRequestResources(pub NSInteger);
bitflags::bitflags! {
    impl BGContinuedProcessingTaskRequestResources: NSInteger {
/// No special system resources required.
///
/// Unless informed otherwise, the scheduler assumes the default resources, allowing background CPU and network
/// access.
        #[doc(alias = "BGContinuedProcessingTaskRequestResourcesDefault")]
        const Default = 0;
/// Indicate to the scheduler that the workload will require background GPU utilization.
///
/// Task submissions will be rejected if the submitting app does not have the correct entitlement. Background GPU
/// execution is not supported on all devices. Additionally, if a device is experiencing heavy GPU contention
/// backgrounded workloads are not guaranteed runtime.
///
/// - Important: Applications must have the `com.apple.developer.background-tasks.continued-processing.gpu`  entitlement to submit a task request with this resource.
        #[doc(alias = "BGContinuedProcessingTaskRequestResourcesGPU")]
        const GPU = 1<<0;
    }
}

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

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

extern_class!(
    /// A request to begin a workload immediately, or shortly after submission, which is allowed to continue running even if
    /// the app is backgrounded.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/backgroundtasks/bgcontinuedprocessingtaskrequest?language=objc)
    #[unsafe(super(BGTaskRequest, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct BGContinuedProcessingTaskRequest;
);

extern_conformance!(
    unsafe impl NSCopying for BGContinuedProcessingTaskRequest {}
);

unsafe impl CopyingHelper for BGContinuedProcessingTaskRequest {
    type Result = Self;
}

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

impl BGContinuedProcessingTaskRequest {
    extern_methods!(
        /// The localized title displayed to the user.
        #[unsafe(method(title))]
        #[unsafe(method_family = none)]
        pub unsafe fn title(&self) -> Retained<NSString>;

        /// Setter for [`title`][Self::title].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setTitle:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setTitle(&self, title: &NSString);

        /// The localized subtitle displayed to the user.
        #[unsafe(method(subtitle))]
        #[unsafe(method_family = none)]
        pub unsafe fn subtitle(&self) -> Retained<NSString>;

        /// Setter for [`subtitle`][Self::subtitle].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setSubtitle:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSubtitle(&self, subtitle: &NSString);

        /// The submission strategy for the scheduler to abide by.
        ///
        /// Defaults to ``BGContinuedProcessingTaskRequestSubmissionStrategy/BGContinuedProcessingTaskRequestSubmissionStrategyQueue``.
        #[unsafe(method(strategy))]
        #[unsafe(method_family = none)]
        pub unsafe fn strategy(&self) -> BGContinuedProcessingTaskRequestSubmissionStrategy;

        /// Setter for [`strategy`][Self::strategy].
        #[unsafe(method(setStrategy:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setStrategy(
            &self,
            strategy: BGContinuedProcessingTaskRequestSubmissionStrategy,
        );

        /// Inform the scheduler that the task will be requesting additional system resources.
        ///
        /// Defaults to ``BGContinuedProcessingTaskRequestResources/BGContinuedProcessingTaskRequestResourcesDefault``.
        #[unsafe(method(requiredResources))]
        #[unsafe(method_family = none)]
        pub unsafe fn requiredResources(&self) -> BGContinuedProcessingTaskRequestResources;

        /// Setter for [`requiredResources`][Self::requiredResources].
        #[unsafe(method(setRequiredResources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setRequiredResources(
            &self,
            required_resources: BGContinuedProcessingTaskRequestResources,
        );

        /// Creates an instance on behalf of the currently foregrounded app.
        ///
        /// Apps and their extensions should use this method to initialize any tasks due to the underlying association to the
        /// currently foregrounded app. Please note that ``BGTaskRequest/earliestBeginDate`` will be outright ignored by the
        /// scheduler in favor of `NSDate.now`.
        ///
        /// The identifier ought to use wildcard notation, where the prefix of the identifier must at least contain the bundle
        /// ID of the submitting application, followed by optional semantic context, and finally ending with `.*`. An example:
        /// `
        /// <MainBundle
        /// >.
        /// <SemanticContext
        /// >.*` which would transform to `com.foo.MyApplication.continuedProcessingTask.*`. Thus,
        /// a submitted identifier would be of the form `com.foo.MyApplication.continuedProcessingTask.HD830D`.
        ///
        /// - Parameters:
        /// - identifier: The task identifier.
        /// - title: The localized title displayed to the user before the task begins running.
        /// - subtitle: The localized subtitle displayed to the user before the task begins running.
        /// - Warning: Successful creation of this object does not guarantee successful submission to the scheduler.
        #[unsafe(method(initWithIdentifier:title:subtitle:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithIdentifier_title_subtitle(
            this: Allocated<Self>,
            identifier: &NSString,
            title: &NSString,
            subtitle: &NSString,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `BGTaskRequest`.
impl BGContinuedProcessingTaskRequest {
    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>;
    );
}