objc2-io-bluetooth 0.3.2

//! 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 crate::*;

extern_protocol!(
    /// [Apple's documentation](https://developer.apple.com/documentation/iobluetooth/iobluetoothdevicepairdelegate?language=objc)
    pub unsafe trait IOBluetoothDevicePairDelegate: NSObjectProtocol {
        /// Indicates that the pairing has started.
        ///
        /// Parameter `sender`: The IOBluetoothDevicePair object.
        ///
        /// # Safety
        ///
        /// - `sender` should be of the correct type.
        /// - `sender` might not allow `None`.
        #[optional]
        #[unsafe(method(devicePairingStarted:))]
        #[unsafe(method_family = none)]
        unsafe fn devicePairingStarted(&self, sender: Option<&AnyObject>);

        /// Indicates to the delegate that the pairing object is making the device (baseband) connection.
        ///
        /// Parameter `sender`: The IOBluetoothDevicePair object.
        ///
        /// # Safety
        ///
        /// - `sender` should be of the correct type.
        /// - `sender` might not allow `None`.
        #[optional]
        #[unsafe(method(devicePairingConnecting:))]
        #[unsafe(method_family = none)]
        unsafe fn devicePairingConnecting(&self, sender: Option<&AnyObject>);

        /// Indicates to the delegate that the pairing object is connected the device (baseband).
        ///
        /// Parameter `sender`: The IOBluetoothDevicePair object.
        ///
        /// # Safety
        ///
        /// - `sender` should be of the correct type.
        /// - `sender` might not allow `None`.
        #[optional]
        #[unsafe(method(devicePairingConnected:))]
        #[unsafe(method_family = none)]
        unsafe fn devicePairingConnected(&self, sender: Option<&AnyObject>);

        /// Indicates to the delegate that the pairing object has made the device (baseband) connection and is
        /// awaiting the PIN code (if specified) to be entered on the device. Thus, when you recieve this message,
        /// you should display to the user that they should enter the PIN code on the device.
        /// The method replyPINCode must be invoked in response and happen before the timeout period of the device.
        ///
        /// Parameter `sender`: The IOBluetoothDevicePair object.
        ///
        /// # Safety
        ///
        /// - `sender` should be of the correct type.
        /// - `sender` might not allow `None`.
        #[optional]
        #[unsafe(method(devicePairingPINCodeRequest:))]
        #[unsafe(method_family = none)]
        unsafe fn devicePairingPINCodeRequest(&self, sender: Option<&AnyObject>);

        #[cfg(feature = "Bluetooth")]
        /// Indicates to the delegate that the pairing object has made the device (baseband) connection and is
        /// awaiting the a yes/no answer for the Simple Secure Pairing numeric comparison. Thus, when you recieve this message,
        /// you should display to the user the numeric value and then accept the yes/no answer if it matches the value
        /// on the other device.
        /// The method replyUserConfirmation must be invoked in response and happen before the timeout period of the device.
        ///
        /// Parameter `sender`: The IOBluetoothDevicePair object.
        ///
        /// Parameter `numericValue`: Numeric value to be displayed.
        ///
        /// # Safety
        ///
        /// - `sender` should be of the correct type.
        /// - `sender` might not allow `None`.
        #[optional]
        #[unsafe(method(devicePairingUserConfirmationRequest:numericValue:))]
        #[unsafe(method_family = none)]
        unsafe fn devicePairingUserConfirmationRequest_numericValue(
            &self,
            sender: Option<&AnyObject>,
            numeric_value: BluetoothNumericValue,
        );

        #[cfg(feature = "Bluetooth")]
        /// Indicates to the delegate that the pairing object has made the device (baseband) connection and is
        /// awaiting the passkey (if specified) to be entered on the device for the Secure Simple Pairing.
        /// Thus, when you recieve this message, you should display to the user that they should enter
        /// the passkey on the device.
        ///
        /// Parameter `sender`: The IOBluetoothDevicePair object.
        ///
        /// Parameter `passkey`: Passkey to be displayed.
        ///
        /// # Safety
        ///
        /// - `sender` should be of the correct type.
        /// - `sender` might not allow `None`.
        #[optional]
        #[unsafe(method(devicePairingUserPasskeyNotification:passkey:))]
        #[unsafe(method_family = none)]
        unsafe fn devicePairingUserPasskeyNotification_passkey(
            &self,
            sender: Option<&AnyObject>,
            passkey: BluetoothPasskey,
        );

        /// Indicates to the delegate that the pairing object has fully completed the process. Can tell the delegate
        /// when and error occurred during the attempt to pair with the device.
        ///
        /// The error passed to your delegate could be kBluetoothHCIErrorAuthenticationFailure,
        /// kBluetoothHCIErrorLMPResponseTimeout, etc. See Bluetooth.h for all the possibilities.
        ///
        /// Parameter `sender`: The IOBluetoothDevicePair object.
        ///
        /// Parameter `error`: An IOReturn or Bluetooth error code.
        ///
        /// # Safety
        ///
        /// - `sender` should be of the correct type.
        /// - `sender` might not allow `None`.
        #[optional]
        #[unsafe(method(devicePairingFinished:error:))]
        #[unsafe(method_family = none)]
        unsafe fn devicePairingFinished_error(&self, sender: Option<&AnyObject>, error: IOReturn);

        #[cfg(feature = "Bluetooth")]
        /// Indicates to the delegate that the pairing object has fully completed the simple pairing process. Can tell the delegate
        /// when and error occurred during the attempt to pair with the device.
        ///
        /// The status passed to your delegate could be BluetoothHCIEventStatus, etc. See Bluetooth.h for all the possibilities.
        ///
        /// Parameter `sender`: The IOBluetoothDevicePair object.
        ///
        /// Parameter `status`: A simple pairing complete error code.
        ///
        /// # Safety
        ///
        /// - `sender` should be of the correct type.
        /// - `sender` might not allow `None`.
        #[optional]
        #[unsafe(method(deviceSimplePairingComplete:status:))]
        #[unsafe(method_family = none)]
        unsafe fn deviceSimplePairingComplete_status(
            &self,
            sender: Option<&AnyObject>,
            status: BluetoothHCIEventStatus,
        );
    }
);

extern_class!(
    /// An instance of IOBluetoothDevicePair represents a pairing attempt to a remote Bluetooth device.
    ///
    /// Use the IOBluetoothDevicePair object to attempt to pair with any Bluetooth device. Once -start is invoked
    /// on it, progress is returned to the delegate via the messages defined below. This object enables you to
    /// pair with devices within your application without having to use the standard panels provided by the
    /// IOBluetoothUI framework, allowing you to write custom UI to select devices, and still handle the ability
    /// to perform device pairings.
    ///
    /// Of note is that this object MAY attempt to perform two low-level pairings, depending on the type of device
    /// you are attempting to pair. This is inconsequential to your code, however, as it occurs automatically and
    /// does not change the messaging.
    ///
    /// Once started, the pairing can be stopped. This will set the delegate to nil and then attempt to disconnect
    /// from the device if already connected.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/iobluetooth/iobluetoothdevicepair?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct IOBluetoothDevicePair;
);

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

impl IOBluetoothDevicePair {
    extern_methods!(
        #[unsafe(method(delegate))]
        #[unsafe(method_family = none)]
        pub unsafe fn delegate(&self) -> Option<Retained<AnyObject>>;

        /// Setter for [`delegate`][Self::delegate].
        ///
        /// This is a [weak property][objc2::topics::weak_property].
        ///
        /// # Safety
        ///
        /// - `delegate` should be of the correct type.
        /// - `delegate` might not allow `None`.
        #[unsafe(method(setDelegate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDelegate(&self, delegate: Option<&AnyObject>);

        #[cfg(all(feature = "IOBluetoothDevice", feature = "IOBluetoothObject"))]
        /// Creates an autorelease IOBluetoothDevicePair object with a device as the pairing target.
        ///
        /// Parameter `device`: An IOBluetoothDevice to attept to pair with. The device is retained.
        ///
        /// Returns: Returns an IOReturn or Bluetooth error code, if the pairing could not be started.
        ///
        /// # Safety
        ///
        /// `device` might not allow `None`.
        #[unsafe(method(pairWithDevice:))]
        #[unsafe(method_family = none)]
        pub unsafe fn pairWithDevice(device: Option<&IOBluetoothDevice>) -> Option<Retained<Self>>;

        /// Kicks off the pairing with the device.
        ///
        /// Returns: Returns an IOReturn or Bluetooth error code, if the pairing could not be started.
        #[unsafe(method(start))]
        #[unsafe(method_family = none)]
        pub unsafe fn start(&self) -> IOReturn;

        /// Stops the current pairing. Removes the delegate and disconnects if device was connected.
        #[unsafe(method(stop))]
        #[unsafe(method_family = none)]
        pub unsafe fn stop(&self);

        #[cfg(all(feature = "IOBluetoothDevice", feature = "IOBluetoothObject"))]
        /// Get the IOBluetoothDevice being used by the object.
        ///
        /// Returns: device        The IOBluetoothDevice object that the IOBluetoothDevicePair object is pairing with, as
        /// specified in -setDevice: or pairWithDevice:
        #[unsafe(method(device))]
        #[unsafe(method_family = none)]
        pub unsafe fn device(&self) -> Option<Retained<IOBluetoothDevice>>;

        #[cfg(all(feature = "IOBluetoothDevice", feature = "IOBluetoothObject"))]
        /// Set the device object to pair with. It is retained by the object.
        ///
        /// Parameter `device`: The IOBluetoothDevice object that the IOBluetoothDevicePair object with which to perform a pairing.
        ///
        /// # Safety
        ///
        /// `in_device` might not allow `None`.
        #[unsafe(method(setDevice:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDevice(&self, in_device: Option<&IOBluetoothDevice>);

        #[cfg(feature = "Bluetooth")]
        /// This is the required reply to the devicePairingPINCodeRequest delegate message.
        /// Set the PIN code to use during pairing if required.
        ///
        /// Parameter `PINCodeSize`: The PIN code length in octets (8 bits).
        ///
        /// Parameter `PINcode`: PIN code for the device.  Can be up to a maximum of 128 bits.
        ///
        /// # Safety
        ///
        /// `pin_code` must be a valid pointer.
        #[unsafe(method(replyPINCode:PINCode:))]
        #[unsafe(method_family = none)]
        pub unsafe fn replyPINCode_PINCode(
            &self,
            pin_code_size: ByteCount,
            pin_code: *mut BluetoothPINCode,
        );

        /// This is the required reply to the devicePairingUserConfirmationRequest delegate message.
        ///
        /// Parameter `reply`: A yes/no answer provide by the user to the numeric comparison presented.
        #[unsafe(method(replyUserConfirmation:))]
        #[unsafe(method_family = none)]
        pub unsafe fn replyUserConfirmation(&self, reply: bool);
    );
}

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