Struct CBCentralManager

Source

#[repr(C)]
pub struct CBCentralManager { /* private fields */ }

Available on crate features CBCentralManager and CBManager only.

Expand description

Entry point to the central role. Commands should only be issued when its state is CBCentralManagerStatePoweredOn .

Implementations§

Source §

impl CBCentralManager

Source

pub unsafe fn delegate( &self, ) -> Option<Retained<ProtocolObject<dyn CBCentralManagerDelegate>>>

The delegate object that will receive central events.

Source

pub unsafe fn setDelegate( &self, delegate: Option<&ProtocolObject<dyn CBCentralManagerDelegate>>, )

This is a weak property. Setter for delegate.

Source

pub unsafe fn isScanning(&self) -> bool

Whether or not the central is currently scanning.

Source

pub unsafe fn supportsFeatures(features: CBCentralManagerFeature) -> bool

Parameter features: One or more features you would like to check if supported.

Returns a boolean value representing the support for the provided features.

Source

pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>

Source

pub unsafe fn initWithDelegate_queue( this: Allocated<Self>, delegate: Option<&ProtocolObject<dyn CBCentralManagerDelegate>>, queue: Option<&DispatchQueue>, ) -> Retained<Self>

Available on crate feature dispatch2 only.

Parameter delegate: The delegate that will receive central role events.

Parameter queue: The dispatch queue on which the events will be dispatched.

The initialization call. The events of the central role will be dispatched on the provided queue. If nil , the main queue will be used.

Source

pub unsafe fn initWithDelegate_queue_options( this: Allocated<Self>, delegate: Option<&ProtocolObject<dyn CBCentralManagerDelegate>>, queue: Option<&DispatchQueue>, options: Option<&NSDictionary<NSString, AnyObject>>, ) -> Retained<Self>

Available on crate feature dispatch2 only.

Parameter delegate: The delegate that will receive central role events.

Parameter queue: The dispatch queue on which the events will be dispatched.

Parameter options: An optional dictionary specifying options for the manager.

The initialization call. The events of the central role will be dispatched on the provided queue. If nil , the main queue will be used.

See also: CBCentralManagerOptionShowPowerAlertKey

See also: CBCentralManagerOptionRestoreIdentifierKey

Source

pub unsafe fn retrievePeripheralsWithIdentifiers( &self, identifiers: &NSArray<NSUUID>, ) -> Retained<NSArray<CBPeripheral>>

Available on crate features CBPeer and CBPeripheral only.

Parameter identifiers: A list of NSUUID objects.

Attempts to retrieve the CBPeripheral object(s) with the corresponding identifiers .

Returns: A list of CBPeripheral objects.

Source

pub unsafe fn retrieveConnectedPeripheralsWithServices( &self, service_uui_ds: &NSArray<CBUUID>, ) -> Retained<NSArray<CBPeripheral>>

Available on crate features CBPeer and CBPeripheral and CBUUID only.

Retrieves all peripherals that are connected to the system and implement any of the services listed in serviceUUIDs . Note that this set can include peripherals which were connected by other applications, which will need to be connected locally via {

 connectPeripheral:options:} before they can be used.

    @return        A list of <code>CBPeripheral</code> objects.

Source

pub unsafe fn scanForPeripheralsWithServices_options( &self, service_uui_ds: Option<&NSArray<CBUUID>>, options: Option<&NSDictionary<NSString, AnyObject>>, )

Available on crate feature CBUUID only.

Parameter serviceUUIDs: A list of CBUUID objects representing the service(s) to scan for.

Parameter options: An optional dictionary specifying options for the scan.

Starts scanning for peripherals that are advertising any of the services listed in serviceUUIDs . Although strongly discouraged, if serviceUUIDs is nil all discovered peripherals will be returned. If the central is already scanning with different serviceUUIDs or options , the provided parameters will replace them. Applications that have specified the bluetooth-central background mode are allowed to scan while backgrounded, with two caveats: the scan must specify one or more service types in serviceUUIDs , and the CBCentralManagerScanOptionAllowDuplicatesKey scan option will be ignored.

See: centralManager:didDiscoverPeripheral:advertisementData:RSSI:

See also: CBCentralManagerScanOptionAllowDuplicatesKey

See also: CBCentralManagerScanOptionSolicitedServiceUUIDsKey

Source

pub unsafe fn stopScan(&self)

Stops scanning for peripherals.

Source

pub unsafe fn connectPeripheral_options( &self, peripheral: &CBPeripheral, options: Option<&NSDictionary<NSString, AnyObject>>, )

Available on crate features CBPeer and CBPeripheral only.

Parameter peripheral: The CBPeripheral to be connected.

Parameter options: An optional dictionary specifying connection behavior options.

Initiates a connection to peripheral . Connection attempts never time out and, depending on the outcome, will result in a call to either {

 centralManager:didConnectPeripheral:} or {@link centralManager:didFailToConnectPeripheral:error:}.
                      Pending attempts are cancelled automatically upon deallocation of <i>peripheral</i>, and explicitly via {@link cancelPeripheralConnection}.

  @see                centralManager:didConnectPeripheral:
  @see                centralManager:didFailToConnectPeripheral:error:
  @seealso            CBConnectPeripheralOptionNotifyOnConnectionKey
  @seealso            CBConnectPeripheralOptionNotifyOnDisconnectionKey
  @seealso            CBConnectPeripheralOptionNotifyOnNotificationKey
  @seealso            CBConnectPeripheralOptionEnableTransportBridgingKey
    @seealso            CBConnectPeripheralOptionRequiresANCS
  @seealso            CBConnectPeripheralOptionEnableAutoReconnect

Source

pub unsafe fn cancelPeripheralConnection(&self, peripheral: &CBPeripheral)

Available on crate features CBPeer and CBPeripheral only.

Parameter peripheral: A CBPeripheral .

Cancels an active or pending connection to peripheral . Note that this is non-blocking, and any CBPeripheral commands that are still pending to peripheral may or may not complete.

See: centralManager:didDisconnectPeripheral:error:

Source

pub unsafe fn registerForConnectionEventsWithOptions( &self, options: Option<&NSDictionary<CBConnectionEventMatchingOption, AnyObject>>, )

Available on crate feature CBCentralManagerConstants only.

Parameter options: A dictionary specifying connection event options.

Calls {

 centralManager:connectionEventDidOccur:forPeripheral:} when a connection event occurs matching any of the given options.
                      Passing nil in the option parameter clears any prior registered matching options.

  @see                centralManager:connectionEventDidOccur:forPeripheral:
  @seealso            CBConnectionEventMatchingOptionServiceUUIDs
  @seealso            CBConnectionEventMatchingOptionPeripheralUUIDs

Source §

impl CBCentralManager

Methods declared on superclass NSObject.

Source

pub unsafe fn new() -> Retained<Self>

Methods from Deref<Target = CBManager>§

Source

pub unsafe fn state(&self) -> CBManagerState

The current state of the manager, initially set to CBManagerStateUnknown . Updates are provided by required delegate method {

 managerDidUpdateState:}.

Source

pub unsafe fn authorization(&self) -> CBManagerAuthorization

👎Deprecated

The current authorization of the manager, initially set to CBManagerAuthorizationNotDetermined . Updates are provided by required delegate method {

 managerDidUpdateState:}.
  @seealso    state

Methods from Deref<Target = NSObject>§

Source

pub fn doesNotRecognizeSelector(&self, sel: Sel) -> !

Handle messages the object doesn’t recognize.

See Apple’s documentation for details.

Methods from Deref<Target = AnyObject>§

Source

pub fn class(&self) -> &'static AnyClass

Dynamically find the class of this object.

§Panics

May panic if the object is invalid (which may be the case for objects returned from unavailable init/new methods).

§Example

Check that an instance of NSObject has the precise class NSObject.

use objc2::ClassType;
use objc2::runtime::NSObject;

let obj = NSObject::new();
assert_eq!(obj.class(), NSObject::class());

Source

pub unsafe fn get_ivar<T>(&self, name: &str) -> &T
where T: Encode,

👎Deprecated: this is difficult to use correctly, use Ivar::load instead.

Use Ivar::load instead.

§Safety

The object must have an instance variable with the given name, and it must be of type T.

See Ivar::load_ptr for details surrounding this.

Source

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: DowncastTarget,

Attempt to downcast the object to a class of type T.

This is the reference-variant. Use Retained::downcast if you want to convert a retained object to another type.

§Mutable classes

Some classes have immutable and mutable variants, such as NSString and NSMutableString.

When some Objective-C API signature says it gives you an immutable class, it generally expects you to not mutate that, even though it may technically be mutable “under the hood”.

So using this method to convert a NSString to a NSMutableString, while not unsound, is generally frowned upon unless you created the string yourself, or the API explicitly documents the string to be mutable.

See Apple’s documentation on mutability and on isKindOfClass: for more details.

§Generic classes

Objective-C generics are called “lightweight generics”, and that’s because they aren’t exposed in the runtime. This makes it impossible to safely downcast to generic collections, so this is disallowed by this method.

You can, however, safely downcast to generic collections where all the type-parameters are AnyObject.

§Panics

This works internally by calling isKindOfClass:. That means that the object must have the instance method of that name, and an exception will be thrown (if CoreFoundation is linked) or the process will abort if that is not the case. In the vast majority of cases, you don’t need to worry about this, since both root objects NSObject and NSProxy implement this method.

§Examples

Cast an NSString back and forth from NSObject.

use objc2::rc::Retained;
use objc2_foundation::{NSObject, NSString};

let obj: Retained<NSObject> = NSString::new().into_super();
let string = obj.downcast_ref::<NSString>().unwrap();
// Or with `downcast`, if we do not need the object afterwards
let string = obj.downcast::<NSString>().unwrap();

Try (and fail) to cast an NSObject to an NSString.

use objc2_foundation::{NSObject, NSString};

let obj = NSObject::new();
assert!(obj.downcast_ref::<NSString>().is_none());

Try to cast to an array of strings.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);
// This is invalid and doesn't type check.
let arr = arr.downcast_ref::<NSArray<NSString>>();

This fails to compile, since it would require enumerating over the array to ensure that each element is of the desired type, which is a performance pitfall.

Downcast when processing each element instead.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);

for elem in arr {
    if let Some(data) = elem.downcast_ref::<NSString>() {
        // handle `data`
    }
}