use objc2::__framework_prelude::*;
#[cfg(feature = "objc2-cloud-kit")]
use objc2_cloud_kit::*;
use objc2_foundation::*;
use crate::*;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIStatusBarStyle(pub NSInteger);
impl UIStatusBarStyle {
#[doc(alias = "UIStatusBarStyleDefault")]
pub const Default: Self = Self(0);
#[doc(alias = "UIStatusBarStyleLightContent")]
pub const LightContent: Self = Self(1);
#[doc(alias = "UIStatusBarStyleDarkContent")]
pub const DarkContent: Self = Self(3);
#[deprecated]
#[doc(alias = "UIStatusBarStyleBlackTranslucent")]
pub const BlackTranslucent: Self = Self(1);
#[deprecated]
#[doc(alias = "UIStatusBarStyleBlackOpaque")]
pub const BlackOpaque: Self = Self(2);
}
unsafe impl Encode for UIStatusBarStyle {
const ENCODING: Encoding = NSInteger::ENCODING;
}
unsafe impl RefEncode for UIStatusBarStyle {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIStatusBarAnimation(pub NSInteger);
impl UIStatusBarAnimation {
#[doc(alias = "UIStatusBarAnimationNone")]
pub const None: Self = Self(0);
#[doc(alias = "UIStatusBarAnimationFade")]
pub const Fade: Self = Self(1);
#[doc(alias = "UIStatusBarAnimationSlide")]
pub const Slide: Self = Self(2);
}
unsafe impl Encode for UIStatusBarAnimation {
const ENCODING: Encoding = NSInteger::ENCODING;
}
unsafe impl RefEncode for UIStatusBarAnimation {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
extern "C" {
pub static UIApplicationInvalidInterfaceOrientationException: &'static NSExceptionName;
}
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIRemoteNotificationType(pub NSUInteger);
bitflags::bitflags! {
impl UIRemoteNotificationType: NSUInteger {
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
#[doc(alias = "UIRemoteNotificationTypeNone")]
const None = 0;
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
#[doc(alias = "UIRemoteNotificationTypeBadge")]
const Badge = 1<<0;
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
#[doc(alias = "UIRemoteNotificationTypeSound")]
const Sound = 1<<1;
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
#[doc(alias = "UIRemoteNotificationTypeAlert")]
const Alert = 1<<2;
#[deprecated = "Use UserNotifications Framework's UNAuthorizationOptions for user notifications and registerForRemoteNotifications for receiving remote notifications instead."]
#[doc(alias = "UIRemoteNotificationTypeNewsstandContentAvailability")]
const NewsstandContentAvailability = 1<<3;
}
}
unsafe impl Encode for UIRemoteNotificationType {
const ENCODING: Encoding = NSUInteger::ENCODING;
}
unsafe impl RefEncode for UIRemoteNotificationType {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIBackgroundFetchResult(pub NSUInteger);
impl UIBackgroundFetchResult {
#[doc(alias = "UIBackgroundFetchResultNewData")]
pub const NewData: Self = Self(0);
#[doc(alias = "UIBackgroundFetchResultNoData")]
pub const NoData: Self = Self(1);
#[doc(alias = "UIBackgroundFetchResultFailed")]
pub const Failed: Self = Self(2);
}
unsafe impl Encode for UIBackgroundFetchResult {
const ENCODING: Encoding = NSUInteger::ENCODING;
}
unsafe impl RefEncode for UIBackgroundFetchResult {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIBackgroundRefreshStatus(pub NSInteger);
impl UIBackgroundRefreshStatus {
#[doc(alias = "UIBackgroundRefreshStatusRestricted")]
pub const Restricted: Self = Self(0);
#[doc(alias = "UIBackgroundRefreshStatusDenied")]
pub const Denied: Self = Self(1);
#[doc(alias = "UIBackgroundRefreshStatusAvailable")]
pub const Available: Self = Self(2);
}
unsafe impl Encode for UIBackgroundRefreshStatus {
const ENCODING: Encoding = NSInteger::ENCODING;
}
unsafe impl RefEncode for UIBackgroundRefreshStatus {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct UIApplicationState(pub NSInteger);
impl UIApplicationState {
#[doc(alias = "UIApplicationStateActive")]
pub const Active: Self = Self(0);
#[doc(alias = "UIApplicationStateInactive")]
pub const Inactive: Self = Self(1);
#[doc(alias = "UIApplicationStateBackground")]
pub const Background: Self = Self(2);
}
unsafe impl Encode for UIApplicationState {
const ENCODING: Encoding = NSInteger::ENCODING;
}
unsafe impl RefEncode for UIApplicationState {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
pub type UIBackgroundTaskIdentifier = NSUInteger;
extern "C" {
pub static UIBackgroundTaskInvalid: UIBackgroundTaskIdentifier;
}
extern "C" {
pub static UIMinimumKeepAliveTimeout: NSTimeInterval;
}
extern "C" {
pub static UIApplicationBackgroundFetchIntervalMinimum: NSTimeInterval;
}
extern "C" {
pub static UIApplicationBackgroundFetchIntervalNever: NSTimeInterval;
}
pub type UIApplicationOpenExternalURLOptionsKey = NSString;
extern_class!(
#[derive(Debug, PartialEq, Eq, Hash)]
#[cfg(feature = "UIResponder")]
pub struct UIApplication;
#[cfg(feature = "UIResponder")]
unsafe impl ClassType for UIApplication {
#[inherits(NSObject)]
type Super = UIResponder;
type Mutability = MainThreadOnly;
}
);
#[cfg(feature = "UIResponder")]
unsafe impl NSObjectProtocol for UIApplication {}
#[cfg(feature = "UIResponder")]
unsafe impl UIResponderStandardEditActions for UIApplication {}
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[method_id(@__retain_semantics Other sharedApplication)]
pub fn sharedApplication(mtm: MainThreadMarker) -> Retained<UIApplication>;
#[method_id(@__retain_semantics Other delegate)]
pub unsafe fn delegate(
&self,
) -> Option<Retained<ProtocolObject<dyn UIApplicationDelegate>>>;
#[method(setDelegate:)]
pub unsafe fn setDelegate(
&self,
delegate: Option<&ProtocolObject<dyn UIApplicationDelegate>>,
);
#[deprecated = "Use UIView's userInteractionEnabled property instead"]
#[method(beginIgnoringInteractionEvents)]
pub unsafe fn beginIgnoringInteractionEvents(&self);
#[deprecated = "Use UIView's userInteractionEnabled property instead"]
#[method(endIgnoringInteractionEvents)]
pub unsafe fn endIgnoringInteractionEvents(&self);
#[deprecated = "Use UIView's userInteractionEnabled property instead"]
#[method(isIgnoringInteractionEvents)]
pub unsafe fn isIgnoringInteractionEvents(&self) -> bool;
#[method(isIdleTimerDisabled)]
pub unsafe fn isIdleTimerDisabled(&self) -> bool;
#[method(setIdleTimerDisabled:)]
pub unsafe fn setIdleTimerDisabled(&self, idle_timer_disabled: bool);
#[deprecated]
#[method(openURL:)]
pub unsafe fn openURL(&self, url: &NSURL) -> bool;
#[method(canOpenURL:)]
pub unsafe fn canOpenURL(&self, url: &NSURL) -> bool;
#[cfg(feature = "block2")]
#[method(openURL:options:completionHandler:)]
pub unsafe fn openURL_options_completionHandler(
&self,
url: &NSURL,
options: &NSDictionary<UIApplicationOpenExternalURLOptionsKey, AnyObject>,
completion: Option<&block2::Block<dyn Fn(Bool)>>,
);
#[cfg(feature = "UIEvent")]
#[method(sendEvent:)]
pub unsafe fn sendEvent(&self, event: &UIEvent);
#[cfg(all(feature = "UIView", feature = "UIWindow"))]
#[deprecated = "Should not be used for applications that support multiple scenes as it returns a key window across all connected scenes"]
#[method_id(@__retain_semantics Other keyWindow)]
pub unsafe fn keyWindow(&self) -> Option<Retained<UIWindow>>;
#[cfg(all(feature = "UIView", feature = "UIWindow"))]
#[deprecated = "Use UIWindowScene.windows on a relevant window scene instead"]
#[method_id(@__retain_semantics Other windows)]
pub fn windows(&self) -> Retained<NSArray<UIWindow>>;
#[cfg(feature = "UIEvent")]
#[method(sendAction:to:from:forEvent:)]
pub unsafe fn sendAction_to_from_forEvent(
&self,
action: Sel,
target: Option<&AnyObject>,
sender: Option<&AnyObject>,
event: Option<&UIEvent>,
) -> bool;
#[deprecated = "Provide a custom network activity UI in your app if desired."]
#[method(isNetworkActivityIndicatorVisible)]
pub unsafe fn isNetworkActivityIndicatorVisible(&self) -> bool;
#[deprecated = "Provide a custom network activity UI in your app if desired."]
#[method(setNetworkActivityIndicatorVisible:)]
pub unsafe fn setNetworkActivityIndicatorVisible(
&self,
network_activity_indicator_visible: bool,
);
#[cfg(all(feature = "UIOrientation", feature = "UIView", feature = "UIWindow"))]
#[method(supportedInterfaceOrientationsForWindow:)]
pub unsafe fn supportedInterfaceOrientationsForWindow(
&self,
window: Option<&UIWindow>,
) -> UIInterfaceOrientationMask;
#[deprecated = "Use viewWillTransitionToSize:withTransitionCoordinator: instead."]
#[method(statusBarOrientationAnimationDuration)]
pub unsafe fn statusBarOrientationAnimationDuration(&self) -> NSTimeInterval;
#[deprecated = "Use the statusBarManager property of the window scene instead."]
#[method(statusBarFrame)]
pub fn statusBarFrame(&self) -> CGRect;
#[deprecated = "Use -[UNUserNotificationCenter setBadgeCount:withCompletionHandler:] instead."]
#[method(applicationIconBadgeNumber)]
pub unsafe fn applicationIconBadgeNumber(&self) -> NSInteger;
#[deprecated = "Use -[UNUserNotificationCenter setBadgeCount:withCompletionHandler:] instead."]
#[method(setApplicationIconBadgeNumber:)]
pub unsafe fn setApplicationIconBadgeNumber(
&self,
application_icon_badge_number: NSInteger,
);
#[method(applicationSupportsShakeToEdit)]
pub unsafe fn applicationSupportsShakeToEdit(&self) -> bool;
#[method(setApplicationSupportsShakeToEdit:)]
pub unsafe fn setApplicationSupportsShakeToEdit(
&self,
application_supports_shake_to_edit: bool,
);
#[method(applicationState)]
pub unsafe fn applicationState(&self) -> UIApplicationState;
#[method(backgroundTimeRemaining)]
pub unsafe fn backgroundTimeRemaining(&self) -> NSTimeInterval;
#[cfg(feature = "block2")]
#[method(beginBackgroundTaskWithExpirationHandler:)]
pub unsafe fn beginBackgroundTaskWithExpirationHandler(
&self,
handler: Option<&block2::Block<dyn Fn()>>,
) -> UIBackgroundTaskIdentifier;
#[cfg(feature = "block2")]
#[method(beginBackgroundTaskWithName:expirationHandler:)]
pub unsafe fn beginBackgroundTaskWithName_expirationHandler(
&self,
task_name: Option<&NSString>,
handler: Option<&block2::Block<dyn Fn()>>,
) -> UIBackgroundTaskIdentifier;
#[method(endBackgroundTask:)]
pub unsafe fn endBackgroundTask(&self, identifier: UIBackgroundTaskIdentifier);
#[deprecated = "Use a BGAppRefreshTask in the BackgroundTasks framework instead"]
#[method(setMinimumBackgroundFetchInterval:)]
pub unsafe fn setMinimumBackgroundFetchInterval(
&self,
minimum_background_fetch_interval: NSTimeInterval,
);
#[method(backgroundRefreshStatus)]
pub unsafe fn backgroundRefreshStatus(&self) -> UIBackgroundRefreshStatus;
#[method(isProtectedDataAvailable)]
pub unsafe fn isProtectedDataAvailable(&self) -> bool;
#[cfg(feature = "UIInterface")]
#[method(userInterfaceLayoutDirection)]
pub unsafe fn userInterfaceLayoutDirection(&self) -> UIUserInterfaceLayoutDirection;
#[cfg(feature = "UIContentSizeCategory")]
#[method_id(@__retain_semantics Other preferredContentSizeCategory)]
pub unsafe fn preferredContentSizeCategory(&self) -> Retained<UIContentSizeCategory>;
#[cfg(feature = "UIScene")]
#[method_id(@__retain_semantics Other connectedScenes)]
pub unsafe fn connectedScenes(&self) -> Retained<NSSet<UIScene>>;
#[cfg(feature = "UISceneSession")]
#[method_id(@__retain_semantics Other openSessions)]
pub unsafe fn openSessions(&self) -> Retained<NSSet<UISceneSession>>;
#[method(supportsMultipleScenes)]
pub unsafe fn supportsMultipleScenes(&self) -> bool;
#[cfg(all(feature = "UISceneSessionActivationRequest", feature = "block2"))]
#[method(activateSceneSessionForRequest:errorHandler:)]
pub unsafe fn activateSceneSessionForRequest_errorHandler(
&self,
request: &UISceneSessionActivationRequest,
error_handler: Option<&block2::Block<dyn Fn(NonNull<NSError>)>>,
);
#[cfg(all(
feature = "UISceneOptions",
feature = "UISceneSession",
feature = "block2"
))]
#[deprecated = "Please use activateSceneSessionForRequest:errorHandler:"]
#[method(requestSceneSessionActivation:userActivity:options:errorHandler:)]
pub unsafe fn requestSceneSessionActivation_userActivity_options_errorHandler(
&self,
scene_session: Option<&UISceneSession>,
user_activity: Option<&NSUserActivity>,
options: Option<&UISceneActivationRequestOptions>,
error_handler: Option<&block2::Block<dyn Fn(NonNull<NSError>)>>,
);
#[cfg(all(
feature = "UISceneOptions",
feature = "UISceneSession",
feature = "block2"
))]
#[method(requestSceneSessionDestruction:options:errorHandler:)]
pub unsafe fn requestSceneSessionDestruction_options_errorHandler(
&self,
scene_session: &UISceneSession,
options: Option<&UISceneDestructionRequestOptions>,
error_handler: Option<&block2::Block<dyn Fn(NonNull<NSError>)>>,
);
#[cfg(feature = "UISceneSession")]
#[method(requestSceneSessionRefresh:)]
pub unsafe fn requestSceneSessionRefresh(&self, scene_session: &UISceneSession);
}
);
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[method_id(@__retain_semantics Init init)]
pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
#[method_id(@__retain_semantics New new)]
pub unsafe fn new(mtm: MainThreadMarker) -> Retained<Self>;
}
);
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[method(registerForRemoteNotifications)]
pub unsafe fn registerForRemoteNotifications(&self);
#[method(unregisterForRemoteNotifications)]
pub unsafe fn unregisterForRemoteNotifications(&self);
#[method(isRegisteredForRemoteNotifications)]
pub unsafe fn isRegisteredForRemoteNotifications(&self) -> bool;
#[deprecated = "Use -[UIApplication registerForRemoteNotifications] and UserNotifications Framework's -[UNUserNotificationCenter requestAuthorizationWithOptions:completionHandler:]"]
#[method(registerForRemoteNotificationTypes:)]
pub unsafe fn registerForRemoteNotificationTypes(&self, types: UIRemoteNotificationType);
#[deprecated = "Use -[UIApplication isRegisteredForRemoteNotifications] and UserNotifications Framework's -[UNUserNotificationCenter getNotificationSettingsWithCompletionHandler:] to retrieve user-enabled remote notification and user notification settings"]
#[method(enabledRemoteNotificationTypes)]
pub unsafe fn enabledRemoteNotificationTypes(&self) -> UIRemoteNotificationType;
}
);
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[cfg(feature = "UILocalNotification")]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter addNotificationRequest:withCompletionHandler:]"]
#[method(presentLocalNotificationNow:)]
pub unsafe fn presentLocalNotificationNow(&self, notification: &UILocalNotification);
#[cfg(feature = "UILocalNotification")]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter addNotificationRequest:withCompletionHandler:]"]
#[method(scheduleLocalNotification:)]
pub unsafe fn scheduleLocalNotification(&self, notification: &UILocalNotification);
#[cfg(feature = "UILocalNotification")]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter removePendingNotificationRequestsWithIdentifiers:]"]
#[method(cancelLocalNotification:)]
pub unsafe fn cancelLocalNotification(&self, notification: &UILocalNotification);
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter removeAllPendingNotificationRequests]"]
#[method(cancelAllLocalNotifications)]
pub unsafe fn cancelAllLocalNotifications(&self);
#[cfg(feature = "UILocalNotification")]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter getPendingNotificationRequestsWithCompletionHandler:]"]
#[method_id(@__retain_semantics Other scheduledLocalNotifications)]
pub unsafe fn scheduledLocalNotifications(
&self,
) -> Option<Retained<NSArray<UILocalNotification>>>;
#[cfg(feature = "UILocalNotification")]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter getPendingNotificationRequestsWithCompletionHandler:]"]
#[method(setScheduledLocalNotifications:)]
pub unsafe fn setScheduledLocalNotifications(
&self,
scheduled_local_notifications: Option<&NSArray<UILocalNotification>>,
);
}
);
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[cfg(feature = "UIUserNotificationSettings")]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter requestAuthorizationWithOptions:completionHandler:] and -[UNUserNotificationCenter setNotificationCategories:]"]
#[method(registerUserNotificationSettings:)]
pub unsafe fn registerUserNotificationSettings(
&self,
notification_settings: &UIUserNotificationSettings,
);
#[cfg(feature = "UIUserNotificationSettings")]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter getNotificationSettingsWithCompletionHandler:] and -[UNUserNotificationCenter getNotificationCategoriesWithCompletionHandler:]"]
#[method_id(@__retain_semantics Other currentUserNotificationSettings)]
pub unsafe fn currentUserNotificationSettings(
&self,
) -> Option<Retained<UIUserNotificationSettings>>;
}
);
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[method(beginReceivingRemoteControlEvents)]
pub unsafe fn beginReceivingRemoteControlEvents(&self);
#[method(endReceivingRemoteControlEvents)]
pub unsafe fn endReceivingRemoteControlEvents(&self);
}
);
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[cfg(feature = "UIImage")]
#[deprecated = "Newsstand apps now behave like normal apps on SpringBoard"]
#[method(setNewsstandIconImage:)]
pub unsafe fn setNewsstandIconImage(&self, image: Option<&UIImage>);
}
);
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[cfg(feature = "UIApplicationShortcutItem")]
#[method_id(@__retain_semantics Other shortcutItems)]
pub unsafe fn shortcutItems(&self) -> Option<Retained<NSArray<UIApplicationShortcutItem>>>;
#[cfg(feature = "UIApplicationShortcutItem")]
#[method(setShortcutItems:)]
pub unsafe fn setShortcutItems(
&self,
shortcut_items: Option<&NSArray<UIApplicationShortcutItem>>,
);
}
);
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[method(supportsAlternateIcons)]
pub unsafe fn supportsAlternateIcons(&self) -> bool;
#[cfg(feature = "block2")]
#[method(setAlternateIconName:completionHandler:)]
pub unsafe fn setAlternateIconName_completionHandler(
&self,
alternate_icon_name: Option<&NSString>,
completion_handler: Option<&block2::Block<dyn Fn(*mut NSError)>>,
);
#[method_id(@__retain_semantics Other alternateIconName)]
pub unsafe fn alternateIconName(&self) -> Option<Retained<NSString>>;
}
);
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[method(extendStateRestoration)]
pub unsafe fn extendStateRestoration(&self);
#[method(completeStateRestoration)]
pub unsafe fn completeStateRestoration(&self);
#[method(ignoreSnapshotOnNextApplicationLaunch)]
pub unsafe fn ignoreSnapshotOnNextApplicationLaunch(&self);
#[cfg(feature = "UIStateRestoration")]
#[method(registerObjectForStateRestoration:restorationIdentifier:)]
pub unsafe fn registerObjectForStateRestoration_restorationIdentifier(
object: &ProtocolObject<dyn UIStateRestoring>,
restoration_identifier: &NSString,
);
}
);
pub type UIApplicationLaunchOptionsKey = NSString;
pub type UIApplicationOpenURLOptionsKey = NSString;
pub type UIApplicationExtensionPointIdentifier = NSString;
extern_protocol!(
pub unsafe trait UIApplicationDelegate: NSObjectProtocol + IsMainThreadOnly {
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationDidFinishLaunching:)]
unsafe fn applicationDidFinishLaunching(&self, application: &UIApplication);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:willFinishLaunchingWithOptions:)]
unsafe fn application_willFinishLaunchingWithOptions(
&self,
application: &UIApplication,
launch_options: Option<&NSDictionary<UIApplicationLaunchOptionsKey, AnyObject>>,
) -> bool;
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:didFinishLaunchingWithOptions:)]
unsafe fn application_didFinishLaunchingWithOptions(
&self,
application: &UIApplication,
launch_options: Option<&NSDictionary<UIApplicationLaunchOptionsKey, AnyObject>>,
) -> bool;
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationDidBecomeActive:)]
unsafe fn applicationDidBecomeActive(&self, application: &UIApplication);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationWillResignActive:)]
unsafe fn applicationWillResignActive(&self, application: &UIApplication);
#[cfg(feature = "UIResponder")]
#[deprecated]
#[optional]
#[method(application:handleOpenURL:)]
unsafe fn application_handleOpenURL(
&self,
application: &UIApplication,
url: &NSURL,
) -> bool;
#[cfg(feature = "UIResponder")]
#[deprecated]
#[optional]
#[method(application:openURL:sourceApplication:annotation:)]
unsafe fn application_openURL_sourceApplication_annotation(
&self,
application: &UIApplication,
url: &NSURL,
source_application: Option<&NSString>,
annotation: &AnyObject,
) -> bool;
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:openURL:options:)]
unsafe fn application_openURL_options(
&self,
app: &UIApplication,
url: &NSURL,
options: &NSDictionary<UIApplicationOpenURLOptionsKey, AnyObject>,
) -> bool;
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationDidReceiveMemoryWarning:)]
unsafe fn applicationDidReceiveMemoryWarning(&self, application: &UIApplication);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationWillTerminate:)]
unsafe fn applicationWillTerminate(&self, application: &UIApplication);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationSignificantTimeChange:)]
unsafe fn applicationSignificantTimeChange(&self, application: &UIApplication);
#[cfg(all(feature = "UIOrientation", feature = "UIResponder"))]
#[deprecated = "Use viewWillTransitionToSize:withTransitionCoordinator: instead."]
#[optional]
#[method(application:willChangeStatusBarOrientation:duration:)]
unsafe fn application_willChangeStatusBarOrientation_duration(
&self,
application: &UIApplication,
new_status_bar_orientation: UIInterfaceOrientation,
duration: NSTimeInterval,
);
#[cfg(all(feature = "UIOrientation", feature = "UIResponder"))]
#[deprecated = "Use viewWillTransitionToSize:withTransitionCoordinator: instead."]
#[optional]
#[method(application:didChangeStatusBarOrientation:)]
unsafe fn application_didChangeStatusBarOrientation(
&self,
application: &UIApplication,
old_status_bar_orientation: UIInterfaceOrientation,
);
#[cfg(feature = "UIResponder")]
#[deprecated = "Use viewWillTransitionToSize:withTransitionCoordinator: instead."]
#[optional]
#[method(application:willChangeStatusBarFrame:)]
unsafe fn application_willChangeStatusBarFrame(
&self,
application: &UIApplication,
new_status_bar_frame: CGRect,
);
#[cfg(feature = "UIResponder")]
#[deprecated = "Use viewWillTransitionToSize:withTransitionCoordinator: instead."]
#[optional]
#[method(application:didChangeStatusBarFrame:)]
unsafe fn application_didChangeStatusBarFrame(
&self,
application: &UIApplication,
old_status_bar_frame: CGRect,
);
#[cfg(all(feature = "UIResponder", feature = "UIUserNotificationSettings"))]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenter requestAuthorizationWithOptions:completionHandler:]"]
#[optional]
#[method(application:didRegisterUserNotificationSettings:)]
unsafe fn application_didRegisterUserNotificationSettings(
&self,
application: &UIApplication,
notification_settings: &UIUserNotificationSettings,
);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:didRegisterForRemoteNotificationsWithDeviceToken:)]
unsafe fn application_didRegisterForRemoteNotificationsWithDeviceToken(
&self,
application: &UIApplication,
device_token: &NSData,
);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:didFailToRegisterForRemoteNotificationsWithError:)]
unsafe fn application_didFailToRegisterForRemoteNotificationsWithError(
&self,
application: &UIApplication,
error: &NSError,
);
#[cfg(feature = "UIResponder")]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate willPresentNotification:withCompletionHandler:] or -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:] for user visible notifications and -[UIApplicationDelegate application:didReceiveRemoteNotification:fetchCompletionHandler:] for silent remote notifications"]
#[optional]
#[method(application:didReceiveRemoteNotification:)]
unsafe fn application_didReceiveRemoteNotification(
&self,
application: &UIApplication,
user_info: &NSDictionary,
);
#[cfg(all(feature = "UILocalNotification", feature = "UIResponder"))]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate willPresentNotification:withCompletionHandler:] or -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:]"]
#[optional]
#[method(application:didReceiveLocalNotification:)]
unsafe fn application_didReceiveLocalNotification(
&self,
application: &UIApplication,
notification: &UILocalNotification,
);
#[cfg(all(
feature = "UILocalNotification",
feature = "UIResponder",
feature = "block2"
))]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:]"]
#[optional]
#[method(application:handleActionWithIdentifier:forLocalNotification:completionHandler:)]
unsafe fn application_handleActionWithIdentifier_forLocalNotification_completionHandler(
&self,
application: &UIApplication,
identifier: Option<&NSString>,
notification: &UILocalNotification,
completion_handler: &block2::Block<dyn Fn()>,
);
#[cfg(all(feature = "UIResponder", feature = "block2"))]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:]"]
#[optional]
#[method(application:handleActionWithIdentifier:forRemoteNotification:withResponseInfo:completionHandler:)]
unsafe fn application_handleActionWithIdentifier_forRemoteNotification_withResponseInfo_completionHandler(
&self,
application: &UIApplication,
identifier: Option<&NSString>,
user_info: &NSDictionary,
response_info: &NSDictionary,
completion_handler: &block2::Block<dyn Fn()>,
);
#[cfg(all(feature = "UIResponder", feature = "block2"))]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:]"]
#[optional]
#[method(application:handleActionWithIdentifier:forRemoteNotification:completionHandler:)]
unsafe fn application_handleActionWithIdentifier_forRemoteNotification_completionHandler(
&self,
application: &UIApplication,
identifier: Option<&NSString>,
user_info: &NSDictionary,
completion_handler: &block2::Block<dyn Fn()>,
);
#[cfg(all(
feature = "UILocalNotification",
feature = "UIResponder",
feature = "block2"
))]
#[deprecated = "Use UserNotifications Framework's -[UNUserNotificationCenterDelegate didReceiveNotificationResponse:withCompletionHandler:]"]
#[optional]
#[method(application:handleActionWithIdentifier:forLocalNotification:withResponseInfo:completionHandler:)]
unsafe fn application_handleActionWithIdentifier_forLocalNotification_withResponseInfo_completionHandler(
&self,
application: &UIApplication,
identifier: Option<&NSString>,
notification: &UILocalNotification,
response_info: &NSDictionary,
completion_handler: &block2::Block<dyn Fn()>,
);
#[cfg(all(feature = "UIResponder", feature = "block2"))]
#[optional]
#[method(application:didReceiveRemoteNotification:fetchCompletionHandler:)]
unsafe fn application_didReceiveRemoteNotification_fetchCompletionHandler(
&self,
application: &UIApplication,
user_info: &NSDictionary,
completion_handler: &block2::Block<dyn Fn(UIBackgroundFetchResult)>,
);
#[cfg(all(feature = "UIResponder", feature = "block2"))]
#[deprecated = "Use a BGAppRefreshTask in the BackgroundTasks framework instead"]
#[optional]
#[method(application:performFetchWithCompletionHandler:)]
unsafe fn application_performFetchWithCompletionHandler(
&self,
application: &UIApplication,
completion_handler: &block2::Block<dyn Fn(UIBackgroundFetchResult)>,
);
#[cfg(all(
feature = "UIApplicationShortcutItem",
feature = "UIResponder",
feature = "block2"
))]
#[optional]
#[method(application:performActionForShortcutItem:completionHandler:)]
unsafe fn application_performActionForShortcutItem_completionHandler(
&self,
application: &UIApplication,
shortcut_item: &UIApplicationShortcutItem,
completion_handler: &block2::Block<dyn Fn(Bool)>,
);
#[cfg(all(feature = "UIResponder", feature = "block2"))]
#[optional]
#[method(application:handleEventsForBackgroundURLSession:completionHandler:)]
unsafe fn application_handleEventsForBackgroundURLSession_completionHandler(
&self,
application: &UIApplication,
identifier: &NSString,
completion_handler: &block2::Block<dyn Fn()>,
);
#[cfg(all(feature = "UIResponder", feature = "block2"))]
#[optional]
#[method(application:handleWatchKitExtensionRequest:reply:)]
unsafe fn application_handleWatchKitExtensionRequest_reply(
&self,
application: &UIApplication,
user_info: Option<&NSDictionary>,
reply: &block2::Block<dyn Fn(*mut NSDictionary)>,
);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationShouldRequestHealthAuthorization:)]
unsafe fn applicationShouldRequestHealthAuthorization(&self, application: &UIApplication);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationDidEnterBackground:)]
unsafe fn applicationDidEnterBackground(&self, application: &UIApplication);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationWillEnterForeground:)]
unsafe fn applicationWillEnterForeground(&self, application: &UIApplication);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationProtectedDataWillBecomeUnavailable:)]
unsafe fn applicationProtectedDataWillBecomeUnavailable(&self, application: &UIApplication);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationProtectedDataDidBecomeAvailable:)]
unsafe fn applicationProtectedDataDidBecomeAvailable(&self, application: &UIApplication);
#[cfg(all(feature = "UIResponder", feature = "UIView", feature = "UIWindow"))]
#[optional]
#[method_id(@__retain_semantics Other window)]
unsafe fn window(&self) -> Option<Retained<UIWindow>>;
#[cfg(all(feature = "UIResponder", feature = "UIView", feature = "UIWindow"))]
#[optional]
#[method(setWindow:)]
unsafe fn setWindow(&self, window: Option<&UIWindow>);
#[cfg(all(
feature = "UIOrientation",
feature = "UIResponder",
feature = "UIView",
feature = "UIWindow"
))]
#[optional]
#[method(application:supportedInterfaceOrientationsForWindow:)]
unsafe fn application_supportedInterfaceOrientationsForWindow(
&self,
application: &UIApplication,
window: Option<&UIWindow>,
) -> UIInterfaceOrientationMask;
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:shouldAllowExtensionPointIdentifier:)]
unsafe fn application_shouldAllowExtensionPointIdentifier(
&self,
application: &UIApplication,
extension_point_identifier: &UIApplicationExtensionPointIdentifier,
) -> bool;
#[cfg(all(feature = "UIResponder", feature = "UIViewController"))]
#[optional]
#[method_id(@__retain_semantics Other application:viewControllerWithRestorationIdentifierPath:coder:)]
unsafe fn application_viewControllerWithRestorationIdentifierPath_coder(
&self,
application: &UIApplication,
identifier_components: &NSArray<NSString>,
coder: &NSCoder,
) -> Option<Retained<UIViewController>>;
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:shouldSaveSecureApplicationState:)]
unsafe fn application_shouldSaveSecureApplicationState(
&self,
application: &UIApplication,
coder: &NSCoder,
) -> bool;
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:shouldRestoreSecureApplicationState:)]
unsafe fn application_shouldRestoreSecureApplicationState(
&self,
application: &UIApplication,
coder: &NSCoder,
) -> bool;
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:willEncodeRestorableStateWithCoder:)]
unsafe fn application_willEncodeRestorableStateWithCoder(
&self,
application: &UIApplication,
coder: &NSCoder,
);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:didDecodeRestorableStateWithCoder:)]
unsafe fn application_didDecodeRestorableStateWithCoder(
&self,
application: &UIApplication,
coder: &NSCoder,
);
#[cfg(feature = "UIResponder")]
#[deprecated = "Use application:shouldSaveSecureApplicationState: instead"]
#[optional]
#[method(application:shouldSaveApplicationState:)]
unsafe fn application_shouldSaveApplicationState(
&self,
application: &UIApplication,
coder: &NSCoder,
) -> bool;
#[cfg(feature = "UIResponder")]
#[deprecated = "Use application:shouldRestoreSecureApplicationState: instead"]
#[optional]
#[method(application:shouldRestoreApplicationState:)]
unsafe fn application_shouldRestoreApplicationState(
&self,
application: &UIApplication,
coder: &NSCoder,
) -> bool;
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:willContinueUserActivityWithType:)]
unsafe fn application_willContinueUserActivityWithType(
&self,
application: &UIApplication,
user_activity_type: &NSString,
) -> bool;
#[cfg(all(
feature = "UIResponder",
feature = "UIUserActivity",
feature = "block2"
))]
#[optional]
#[method(application:continueUserActivity:restorationHandler:)]
unsafe fn application_continueUserActivity_restorationHandler(
&self,
application: &UIApplication,
user_activity: &NSUserActivity,
restoration_handler: &block2::Block<
dyn Fn(*mut NSArray<ProtocolObject<dyn UIUserActivityRestoring>>),
>,
) -> bool;
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:didFailToContinueUserActivityWithType:error:)]
unsafe fn application_didFailToContinueUserActivityWithType_error(
&self,
application: &UIApplication,
user_activity_type: &NSString,
error: &NSError,
);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(application:didUpdateUserActivity:)]
unsafe fn application_didUpdateUserActivity(
&self,
application: &UIApplication,
user_activity: &NSUserActivity,
);
#[cfg(all(feature = "UIResponder", feature = "objc2-cloud-kit"))]
#[optional]
#[method(application:userDidAcceptCloudKitShareWithMetadata:)]
unsafe fn application_userDidAcceptCloudKitShareWithMetadata(
&self,
application: &UIApplication,
cloud_kit_share_metadata: &CKShareMetadata,
);
#[cfg(all(
feature = "UIResponder",
feature = "UISceneOptions",
feature = "UISceneSession"
))]
#[optional]
#[method_id(@__retain_semantics Other application:configurationForConnectingSceneSession:options:)]
unsafe fn application_configurationForConnectingSceneSession_options(
&self,
application: &UIApplication,
connecting_scene_session: &UISceneSession,
options: &UISceneConnectionOptions,
) -> Retained<UISceneConfiguration>;
#[cfg(all(feature = "UIResponder", feature = "UISceneSession"))]
#[optional]
#[method(application:didDiscardSceneSessions:)]
unsafe fn application_didDiscardSceneSessions(
&self,
application: &UIApplication,
scene_sessions: &NSSet<UISceneSession>,
);
#[cfg(feature = "UIResponder")]
#[optional]
#[method(applicationShouldAutomaticallyLocalizeKeyCommands:)]
unsafe fn applicationShouldAutomaticallyLocalizeKeyCommands(
&self,
application: &UIApplication,
) -> bool;
}
unsafe impl ProtocolType for dyn UIApplicationDelegate {}
);
extern_methods!(
#[cfg(feature = "UIResponder")]
unsafe impl UIApplication {
#[deprecated]
#[method(isProximitySensingEnabled)]
pub unsafe fn isProximitySensingEnabled(&self) -> bool;
#[deprecated]
#[method(setProximitySensingEnabled:)]
pub unsafe fn setProximitySensingEnabled(&self, proximity_sensing_enabled: bool);
#[deprecated = "Use -[UIViewController prefersStatusBarHidden]"]
#[method(setStatusBarHidden:animated:)]
pub unsafe fn setStatusBarHidden_animated(&self, hidden: bool, animated: bool);
#[cfg(feature = "UIOrientation")]
#[deprecated = "Explicit setting of the status bar orientation is more limited in iOS 6.0 and later"]
#[method(setStatusBarOrientation:)]
pub unsafe fn setStatusBarOrientation(
&self,
status_bar_orientation: UIInterfaceOrientation,
);
#[cfg(feature = "UIOrientation")]
#[deprecated = "Explicit setting of the status bar orientation is more limited in iOS 6.0 and later"]
#[method(setStatusBarOrientation:animated:)]
pub unsafe fn setStatusBarOrientation_animated(
&self,
interface_orientation: UIInterfaceOrientation,
animated: bool,
);
#[deprecated = "Use -[UIViewController preferredStatusBarStyle]"]
#[method(setStatusBarStyle:)]
pub unsafe fn setStatusBarStyle(&self, status_bar_style: UIStatusBarStyle);
#[deprecated = "Use -[UIViewController preferredStatusBarStyle]"]
#[method(setStatusBarStyle:animated:)]
pub unsafe fn setStatusBarStyle_animated(
&self,
status_bar_style: UIStatusBarStyle,
animated: bool,
);
#[deprecated = "Use -[UIViewController prefersStatusBarHidden]"]
#[method(setStatusBarHidden:)]
pub unsafe fn setStatusBarHidden(&self, status_bar_hidden: bool);
#[deprecated = "Use -[UIViewController prefersStatusBarHidden]"]
#[method(setStatusBarHidden:withAnimation:)]
pub unsafe fn setStatusBarHidden_withAnimation(
&self,
hidden: bool,
animation: UIStatusBarAnimation,
);
#[cfg(feature = "block2")]
#[deprecated = "Please use PushKit for VoIP applications instead of calling this method"]
#[method(setKeepAliveTimeout:handler:)]
pub unsafe fn setKeepAliveTimeout_handler(
&self,
timeout: NSTimeInterval,
keep_alive_handler: Option<&block2::Block<dyn Fn()>>,
) -> bool;
#[deprecated = "Please use PushKit for VoIP applications instead of calling this method"]
#[method(clearKeepAliveTimeout)]
pub unsafe fn clearKeepAliveTimeout(&self);
}
);
extern "C" {
pub fn UIApplicationMain(
argc: c_int,
argv: NonNull<*mut c_char>,
principal_class_name: Option<&NSString>,
delegate_class_name: Option<&NSString>,
) -> c_int;
}
extern "C" {
pub static UITrackingRunLoopMode: &'static NSRunLoopMode;
}
extern "C" {
pub static UIApplicationDidEnterBackgroundNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationWillEnterForegroundNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationDidFinishLaunchingNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationDidBecomeActiveNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationWillResignActiveNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationDidReceiveMemoryWarningNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationWillTerminateNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationSignificantTimeChangeNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationWillChangeStatusBarOrientationNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationDidChangeStatusBarOrientationNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationStatusBarOrientationUserInfoKey: &'static NSString;
}
extern "C" {
pub static UIApplicationWillChangeStatusBarFrameNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationDidChangeStatusBarFrameNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationStatusBarFrameUserInfoKey: &'static NSString;
}
extern "C" {
pub static UIApplicationBackgroundRefreshStatusDidChangeNotification:
&'static NSNotificationName;
}
extern "C" {
pub static UIApplicationProtectedDataWillBecomeUnavailable: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationProtectedDataDidBecomeAvailable: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationLaunchOptionsURLKey: &'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsSourceApplicationKey:
&'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsRemoteNotificationKey:
&'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsLocalNotificationKey:
&'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsAnnotationKey: &'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsLocationKey: &'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsNewsstandDownloadsKey:
&'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsBluetoothCentralsKey:
&'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsBluetoothPeripheralsKey:
&'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsShortcutItemKey: &'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsEventAttributionKey:
&'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsUserActivityDictionaryKey:
&'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsUserActivityTypeKey:
&'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationLaunchOptionsCloudKitShareMetadataKey:
&'static UIApplicationLaunchOptionsKey;
}
extern "C" {
pub static UIApplicationOpenSettingsURLString: &'static NSString;
}
extern "C" {
pub static UIApplicationOpenNotificationSettingsURLString: &'static NSString;
}
extern "C" {
pub static UIApplicationOpenURLOptionsSourceApplicationKey:
&'static UIApplicationOpenURLOptionsKey;
}
extern "C" {
pub static UIApplicationOpenURLOptionsAnnotationKey: &'static UIApplicationOpenURLOptionsKey;
}
extern "C" {
pub static UIApplicationOpenURLOptionsOpenInPlaceKey: &'static UIApplicationOpenURLOptionsKey;
}
extern "C" {
pub static UIApplicationOpenURLOptionsEventAttributionKey:
&'static UIApplicationOpenURLOptionsKey;
}
extern "C" {
pub static UIApplicationUserDidTakeScreenshotNotification: &'static NSNotificationName;
}
extern "C" {
pub static UIApplicationKeyboardExtensionPointIdentifier:
&'static UIApplicationExtensionPointIdentifier;
}
extern "C" {
pub static UIApplicationOpenURLOptionUniversalLinksOnly:
&'static UIApplicationOpenExternalURLOptionsKey;
}
extern "C" {
pub static UIApplicationOpenExternalURLOptionsEventAttributionKey:
&'static UIApplicationOpenExternalURLOptionsKey;
}