# SDK Installation Complete installation and configuration guides for the Airship SDK, including setup, advanced integration, logging, and locale configuration. # Install and Set Up the Apple SDK > Learn how to install the Airship SDK using SPM, CocoaPods, Carthage, or xcframeworks, and initialize the SDK in your iOS, tvOS, or visionOS applications. The Airship SDK is a modern, Swift 6-native SDK designed for Apple platforms. It provides type-safe, actor-isolated APIs with full Swift concurrency support that work seamlessly across iOS, tvOS, and visionOS — all from a single SDK. For a complete reference of feature support across iOS, tvOS, and visionOS, see [Platform Support](https://www.airship.com/docs/developer/sdk-integration/apple/resources/#platform-support). > **Tip:** If you use an AI coding assistant, you can connect it to Airship with Skills and an MCP server. See [Airship AI Tools](https://www.airship.com/docs/developer/ai-tools/ai-tools/). ## Requirements * Minimum iOS version: 16.0+ * Minimum tvOS version: 18.0+ * Minimum visionOS version: 1.0+ * Requires Xcode 26.0+ ## SDK installation The Airship SDK can be installed using SPM (Swift Package Manager), CocoaPods, Carthage, or xcframeworks. We recommend SPM for new projects. #### SPM 1. In your Xcode project, select your project in the Project Navigator. 2. Select your target, then go to the **Package Dependencies** tab. 3. Click the **+** button to add a package. 4. Enter the package URL: `https://github.com/urbanairship/ios-library` 5. Select the version rule (recommended: "Up to Next Major Version"). 6. Click **Add Package**. 7. Select the Airship package products you want to include in your app: **Available package products:** - `AirshipBasement` : Required by AirshipCore - `AirshipCore` : Push messaging features including channels, tags, named user and default actions (required) - `AirshipMessageCenter` : Message center - `AirshipAutomation` : Automation and in-app messaging - `AirshipPreferenceCenter` : Preference Center - `AirshipFeatureFlags` : Feature Flags - `AirshipObjectiveC` : Objective-C Bindings - `AirshipDebug` : Debugging tools - `AirshipNotificationServiceExtension` : Service Extension framework (only for Notification Service Extension targets, not the app target)* 8. Click **Add Package**. 9. Import the modules in your code where needed. Import statements match the module names: ```swift import AirshipCore import AirshipMessageCenter import AirshipAutomation ``` For more details, see Apple's guide on [adding package dependencies to your app](https://developer.apple.com/documentation/xcode/adding-package-dependencies-to-your-app). #### Cocoapods > **Note:** CocoaPods trunk is [moving to read-only mode in December 2026](https://blog.cocoapods.org/CocoaPods-Specs-Repo/). Airship will continue to support CocoaPods as long as possible, but we recommend using SPM (Swift Package Manager) for new projects. Existing CocoaPods installations will continue to work after trunk becomes read-only. 1. Install CocoaPods if you haven't already: `$ gem install cocoapods` 2. Navigate to your project directory in Terminal. 3. Create a `Podfile` (if one doesn't exist): `$ pod init` 4. Open your `Podfile` and add the Airship pod. The `Airship` pod is modular and divided into subspecs: **Available subspecs:** - `Airship/Core` : Push messaging features including channels, tags, named user and default actions (required) - `Airship/MessageCenter` : Message center - `Airship/Automation` : Automation and in-app messaging - `Airship/PreferenceCenter` : Preference Center module - `Airship/FeatureFlags` : Feature Flags module - `Airship/ObjectiveC` : Objective-C bindings ```ruby target "" do pod 'Airship' end ``` **Or specify individual subspecs:** ```ruby target "" do pod 'Airship/Core' pod 'Airship/MessageCenter' pod 'Airship/Automation' pod 'Airship/FeatureFlags' end ``` **For tvOS projects, specify the platform:** ```ruby platform :tvos, '18.0' target "" do pod 'Airship' end ``` 5. Install the pods: `$ pod install` 6. **Important:** After running `pod install`, an Xcode workspace (`.xcworkspace`) file is generated. Always open the workspace file instead of the project file (`.xcodeproj`) when building your project. If you encounter issues, see the [CocoaPods troubleshooting guide](http://guides.cocoapods.org/using/troubleshooting.html). #### Carthage 1. Install Carthage if you haven't already. See the [Carthage installation guide](https://github.com/Carthage/Carthage#installing-carthage). 2. Verify `Enable Modules` and `Link Frameworks Automatically` are enabled in your project's Build Settings. 3. Follow Carthage's [adding frameworks to an application](https://github.com/Carthage/Carthage#adding-frameworks-to-an-application) instructions to add frameworks to your application. 4. Specify the Airship iOS SDK in your `Cartfile`: ```text github "urbanairship/ios-library" ``` 5. Build the frameworks: `$ carthage update` 6. Add the frameworks to your project. Airship is modular, so select only the frameworks you need: **Available frameworks:** - `AirshipBasement` : Required by AirshipCore - `AirshipCore` : Push messaging features including channels, tags, named user and default actions (required) - `AirshipMessageCenter` : Message center - `AirshipAutomation` : Automation and in-app messaging - `AirshipPreferenceCenter` : Preference Center - `AirshipFeatureFlags` : Feature Flags - `AirshipObjectiveC` : Objective-C Bindings - `AirshipDebug` : Debugging tools - `AirshipNotificationServiceExtension` : Service Extension framework (only for Notification Service Extensions)* 7. Import the frameworks in your code. Import statements match the framework names: ```swift import AirshipCore import AirshipMessageCenter import AirshipAutomation ``` #### xcframeworks 1. Download and decompress the latest version of the [iOS SDK](https://github.com/urbanairship/ios-library/releases). 2. Inside the folder you should see a collection of XCFrameworks. Airship is modular, so select only the XCFrameworks you need: **Available XCFrameworks:** - `AirshipBasement.xcframework` : Required by AirshipCore - `AirshipCore.xcframework` : Push messaging features including channels, tags, named user and default actions (required) - `AirshipMessageCenter.xcframework` : Message center - `AirshipAutomation.xcframework` : Automation and in-app messaging - `AirshipPreferenceCenter.xcframework` : Preference Center - `AirshipFeatureFlags.xcframework` : Feature Flags - `AirshipObjectiveC.xcframework` : Objective-C Bindings - `AirshipDebug.xcframework` : Debugging tools - `AirshipNotificationServiceExtension.xcframework` : Service Extension framework (only for Notification Service Extensions)* 3. Add XCFrameworks to your project: - Open your project in Xcode - Click on your project in the Project Navigator - Select your target - Make sure the General tab is selected - Scroll down to **Frameworks, Libraries, and Embedded Content** - Drag in desired XCFrameworks from the downloaded SDK. They are wired up automatically as dependencies of your target 4. Verify Build Settings: - `Enable Modules` should be set to `Yes` - `Link Frameworks Automatically` should be set to `Yes` ![Enable Modules build setting in Xcode](https://www.airship.com/docs/images/enable-modules_hu_f56ed603b2699427.webp) *Enable Modules build setting in Xcode* ![Link Frameworks Automatically build setting in Xcode](https://www.airship.com/docs/images/link-frameworks-automatically_hu_e08f4e14a1a2ca09.webp) *Link Frameworks Automatically build setting in Xcode* 5. Import the frameworks in your code. Import statements match the framework names: ```swift import AirshipCore import AirshipMessageCenter import AirshipAutomation ``` ## Initialize Airship The Airship SDK requires only a single entry point, known as *takeOff*. For UIKit apps, initialize during the application delegate's `application(_:didFinishLaunchingWithOptions:)` method. For SwiftUI apps, you can initialize in the App's `init()` method. Before calling `takeOff`, configure the following: - **Project Credentials**: Airship requires your project's [App Key](https://www.airship.com/docs/reference/glossary/#app_key) and [App Secret](https://www.airship.com/docs/reference/glossary/#app_secret)to authenticate your application. To find them, select the dropdown menu (▼) next to your project name, and then **Project details**. You need separate credentials for development and production environments. On iOS, this is necessary because Apple provides separate APNS (Apple Push Notification Service) environments: - **Development/Sandbox**: Used for testing and development builds - **Production**: Used for App Store and TestFlight builds The SDK automatically selects the correct credentials based on your build configuration. Configure both sets of credentials in your code, and use the `#if DEBUG` conditional to switch between environments. - **Cloud Site**: Airship config defaults to the US cloud site. If your application is set up for the EU site, set the site on the config options to `.eu`. ### Calling takeOff The following examples show how to configure and call `takeOff` programmatically. Alternatively, you can configure Airship using an `AirshipConfig.plist` file—see [Advanced Integration](https://www.airship.com/docs/developer/sdk-integration/apple/installation/advanced-integration/#configuring-airship-via-plist-file) for details. #### Swift ```swift import SwiftUI import AirshipCore @main struct MyApp: App { init() { var config = AirshipConfig() // Set credentials config.productionAppKey = "YOUR PRODUCTION APP KEY" config.productionAppSecret = "YOUR PRODUCTION APP SECRET" config.developmentAppKey = "YOUR DEVELOPMENT APP KEY" config.developmentAppSecret = "YOUR DEVELOPMENT APP SECRET" // Set cloud site (.us or .eu) config.site = .us #if DEBUG config.inProduction = false config.isAirshipDebugEnabled = true #else config.inProduction = true #endif try! Airship.takeOff(config) } var body: some Scene { WindowGroup { ContentView() } } } ``` For **UIKit** apps, call `takeOff` in your `AppDelegate`'s `application(_:didFinishLaunchingWithOptions:)` method instead of the App's `init()`. #### Objective-C ```objective-c @implementation AppDelegate - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { UAConfig *config = [UAConfig config]; // Set credentials config.productionAppKey = @"YOUR PRODUCTION APP KEY"; config.productionAppSecret = @"YOUR PRODUCTION APP SECRET"; config.developmentAppKey = @"YOUR DEVELOPMENT APP KEY"; config.developmentAppSecret = @"YOUR DEVELOPMENT APP SECRET"; // Set cloud site (UACloudSiteUS or UACloudSiteEU) config.site = UACloudSiteUS; #if DEBUG config.inProduction = NO; config.isAirshipDebugEnabled = YES; #else config.inProduction = YES; #endif NSError *airshipError; [UAirship takeOff:config error:&airshipError]; NSAssert(airshipError == nil, @"TakeOff failed %@", airshipError); return YES; } @end ``` The Airship SDK automatically integrates with your app by default, so you don't need to implement push-related `UIApplicationDelegate` or `UNUserNotificationCenterDelegate` methods. This works for most applications out of the box. For advanced use cases or to disable automatic integration, see the [Advanced Integration](https://www.airship.com/docs/developer/sdk-integration/apple/installation/advanced-integration/##manual-integration) guide. ## Test the integration After completing the setup, verify your integration: 1. **Build and run your app** in Xcode 2. **Check the console logs** for Airship channel creation: - Look for a log message: `Channel ID: ` - The channel ID will be displayed in the console output - For more detailed logging, see [Logging](https://www.airship.com/docs/developer/sdk-integration/apple/installation/logging/) If you see the channel ID in the console logs and no errors, your integration is successful. You can now proceed with configuring [deep links](https://www.airship.com/docs/developer/sdk-integration/apple/deep-links/), [push notifications](https://www.airship.com/docs/developer/sdk-integration/apple/push-notifications/getting-started/), and other Airship features. If you don't see a channel ID in the console logs or encounter errors during initialization, see [Troubleshooting Initialization](https://www.airship.com/docs/developer/sdk-integration/apple/troubleshooting/initialization/) for common problems and solutions. # Advanced Integration > Disable automatic integration, manually forward app delegate methods, and configure URL allowlists for the Airship SDK. ## Configuring Airship via plist file If no config is provided to `takeOff` programmatically, Airship will default to loading config from the `AirshipConfig.plist` file in your application's bundle. This can be useful for apps with multiple build variants, or for keeping credentials out of version control. Sample `AirshipConfig.plist` file: ```xml detectProvisioningMode developmentAppKey Your Development App Key developmentAppSecret Your Development App Secret productionAppKey Your Production App Key productionAppSecret Your Production App Secret ``` The keys used in the `AirshipConfig.plist` file match the field names in [AirshipConfig](https://urbanairship.github.io/ios-library/v20/AirshipCore/documentation/airshipcore/airshipconfig) . If your app uses Airship's EU cloud site, add the `site` key: ```xml site EU ``` If you don't see a Channel ID in the console logs or encounter errors during initialization, see [Troubleshooting Initialization](https://www.airship.com/docs/developer/sdk-integration/apple/troubleshooting/initialization/). ## Manual Integration By default, the Airship SDK automatically integrates with your app using *method swizzling*. This allows the SDK to intercept app delegate messages and forward them automatically, so you don't need to implement push-related `UIApplicationDelegate` or `UNUserNotificationCenterDelegate` protocol methods. For most applications, automatic integration works out of the box. However, if you have custom app delegate requirements or prefer explicit control over method forwarding, you can disable automatic integration and handle it manually. ### Disabling automatic integration Set [AirshipConfig.isAutomaticSetupEnabled](https://urbanairship.github.io/ios-library/v20/AirshipCore/documentation/airshipcore/airshipconfig/isautomaticsetupenabled) to `false` in your Airship config during [takeOff](https://www.airship.com/docs/developer/sdk-integration/apple/installation/getting-started/#calling-takeoff): #### Swift ```swift var config = AirshipConfig() config.isAutomaticSetupEnabled = false try! Airship.takeOff(config) ``` #### Objective-C ```objc UAConfig *config = [UAConfig config]; config.isAutomaticSetupEnabled = NO; [UAirship takeOff:config error:&airshipError]; ``` ### Forwarding app delegate methods When automatic integration is disabled, you must forward the appropriate app delegate methods to the Airship SDK. #### Swift `UIApplicationDelegate` methods: ```swift func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool { // Set up the UNUserNotificationCenter delegate UNUserNotificationCenter.current().delegate = self return true } func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) { AppIntegration.application(application, didRegisterForRemoteNotificationsWithDeviceToken: deviceToken) } func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) { AppIntegration.application(application, didFailToRegisterForRemoteNotificationsWithError: error) } func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any]) async -> UIBackgroundFetchResult { return await AppIntegration.application(application, didReceiveRemoteNotification: userInfo) } ``` `UNUserNotificationCenterDelegate` methods: ```swift func userNotificationCenter( _ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping @Sendable () -> Void ) { // Call through to Airship. The completion handler version is called on the main actor. // It's important to use the `completionHandler` version and not the async one, or it // will be called on a background thread and Airship might not receive the event in time // to count the direct open. MainActor.assumeIsolated { AppIntegration.userNotificationCenter( center, didReceive: response, withCompletionHandler: completionHandler ) } } func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification) async -> UNNotificationPresentationOptions { return await AppIntegration.userNotificationCenter(center, willPresent: notification) } ``` #### Objective-C `UIApplicationDelegate` methods: ```objc - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { // Set up the UNUserNotificationCenter delegate [UNUserNotificationCenter currentNotificationCenter].delegate = self; return YES; } - (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken { [UAAppIntegration application:application didRegisterForRemoteNotificationsWithDeviceToken:deviceToken]; } - (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error { [UAAppIntegration application:application didFailToRegisterForRemoteNotificationsWithError:error]; } - (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler { [UAAppIntegration application:application didReceiveRemoteNotification:userInfo fetchCompletionHandler:completionHandler]; } ``` `UNUserNotificationCenterDelegate` methods: ```objc - (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler { [UAAppIntegration userNotificationCenter:center willPresentNotification:notification withCompletionHandler:completionHandler]; } - (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler { [UAAppIntegration userNotificationCenter:center didReceiveNotificationResponse:response withCompletionHandler:completionHandler]; } ``` ## URL allowlist The [URLAllowList](https://urbanairship.github.io/ios-library/v20/AirshipCore/documentation/airshipcore/airshipurlallowlist) controls which URLs the Airship SDK is able to act on. The SDK divides up usages of URLs into two different scopes: - `SCOPE_OPEN_URL`: Only URLs allowed for this scope can be opened from an action, displayed in landing page, or displayed in an HTML in-app message. Defaults to allowing all URLs if not specified in the config. - `SCOPE_JAVASCRIPT_INTERFACE`: These URLs are checked before the Airship JavaScript interface is injected into the webview. Defaults to any Airship originated URLs. Allowed URLs should be provided when configuring the Airship Config during [takeOff](https://www.airship.com/docs/developer/sdk-integration/apple/installation/getting-started/#calling-takeoff). #### Swift ```swift var config = AirshipConfig() // Allow all URLs for both scopes config.urlAllowList = ["*"] // Or configure specific scopes: config.urlAllowListScopeOpenURL = ["https://example.com/*", "https://*.youtube.com/*"] config.urlAllowListScopeJavaScriptInterface = ["https://example.com/*"] try! Airship.takeOff(config) ``` #### Objective-C ```objc UAConfig *config = [UAConfig config]; // Allow all URLs for both scopes config.urlAllowList = @[@"*"]; // Or configure specific scopes: config.urlAllowListScopeOpenURL = @[@"https://example.com/*", @"https://*.youtube.com/*"]; config.urlAllowListScopeJavaScriptInterface = @[@"https://example.com/*"]; [UAirship takeOff:config error:&airshipError]; ``` **Valid URL pattern syntax** ```text := '*' | '://'/ | '://' | ':/' | ':///' := := '*' | '*.' | := ``` # Logging > Configure log levels, privacy settings, and custom log handlers to control how the Airship SDK logs messages. The Airship SDK provides configurable log levels to help you debug issues without overwhelming the console. If you don't configure logging, the SDK uses **Info** for development builds and **Error** for production builds with **private** privacy level. ## Log levels The log level acts as a minimum threshold—only logs at that level and higher will be logged. Available log levels, ordered from most to least verbose: | Log Level | Prefix | Description | | :-------- | :----- | :---------- | | **Verbose** | `[Airship] [V]` | Highly detailed SDK status for deep debugging and troubleshooting | | **Debug** | `[Airship] [D]` | General SDK status with more detailed information than Info | | **Info** | `[Airship] [I]` | General SDK status and lifecycle events | | **Warning** | `[Airship] [W]` | API deprecations, invalid setup, and other recoverable issues | | **Error** | `[Airship] [E]` | Critical errors and exceptions that the SDK cannot gracefully handle | | **None** | — | Disables all logging | ## Log privacy levels Control the visibility of log contents using privacy levels. This is especially useful when debugging release builds without exposing sensitive information. - **private** (default): Uses `os.Logger` to log all messages at the `private` level. The content of most logs will be redacted and will not be visible in the Console app by default. Use this for production builds to protect sensitive data. - **public**: Sends all logs to `os.Logger` with a `public` privacy level, preventing their content from being redacted. Use this when you need to capture detailed logs from release builds for debugging. > **Note:** When using `public` privacy level, `verbose` and `debug` log messages are automatically elevated to `info` level because Console log doesn't support those levels directly. This ensures all detailed logs are visible when debugging production builds. ## Configuration You can set separate log levels and privacy levels for development and production builds in your Airship config during [takeOff](https://www.airship.com/docs/developer/sdk-integration/apple/installation/getting-started/#calling-takeoff). ### Common configuration Typical setup: more verbose logging for development, minimal logging for production: #### Swift ```swift var config = AirshipConfig() // Development: verbose logging for debugging config.developmentLogLevel = .verbose config.developmentLogPrivacyLevel = .public // Production: minimal logging to reduce noise config.productionLogLevel = .error config.productionLogPrivacyLevel = .private try! Airship.takeOff(config) ``` #### Objective-C ```objc UAConfig *config = [UAConfig config]; // Development: verbose logging for debugging config.developmentLogLevel = UAAirshipLogLevelVerbose; // Production: minimal logging to reduce noise config.productionLogLevel = UAAirshipLogLevelError; // Privacy levels (set via AirshipConfig.plist) // developmentLogPrivacyLevel // public // productionLogPrivacyLevel // private [UAirship takeOff:config error:&airshipError]; ``` ### Debugging production issues When debugging issues in production builds, temporarily enable verbose logging to capture detailed SDK behavior: #### Swift ```swift var config = AirshipConfig() // Production debugging: enable verbose logs config.productionLogLevel = .verbose config.productionLogPrivacyLevel = .public try! Airship.takeOff(config) ``` #### Objective-C ```objc UAConfig *config = [UAConfig config]; // Production debugging: enable verbose logs config.productionLogLevel = UAAirshipLogLevelVerbose; // Set via AirshipConfig.plist: // productionLogPrivacyLevel // public [UAirship takeOff:config error:&airshipError]; ``` ## Custom log handler You can provide a custom log handler to intercept and handle all Airship log messages. This is useful when you need to integrate Airship logs with your own logging system or customize how logs are formatted or stored. When a custom log handler is set, the default Airship log handler is completely replaced. Log level filtering is performed before your handler is called, so your handler will only receive logs that meet the configured log level threshold. Implement the `AirshipLogHandler` protocol and set it on your Airship config: ```swift import os.log final class CustomLogHandler: AirshipLogHandler { private let logger = Logger(subsystem: "com.yourapp.airship", category: "Airship") func log( logLevel: AirshipLogLevel, message: String, fileID: String, line: UInt, function: String ) { // Forward to your logging system let osLogLevel: OSLogType switch logLevel { case .verbose, .debug: osLogLevel = .debug case .info: osLogLevel = .info case .warning: osLogLevel = .default case .error: osLogLevel = .error case .none: return } logger.log(level: osLogLevel, "\(message)") // Optionally: send to remote logging service // YourLoggingService.log(message, level: logLevel) } } var config = AirshipConfig() config.logHandler = CustomLogHandler() try! Airship.takeOff(config) ``` # Locale > Configure locale behavior and override the default locale that Airship uses. Airship uses the [Locale](https://www.airship.com/docs/reference/glossary/#locale) for various SDK operations. By default, the SDK automatically uses the device's locale settings, but you can configure it to use the user's preferred language or override it programmatically. ## Configuring locale behavior You can configure how Airship determines the locale by setting the `useUserPreferredLocale` option in your Airship config during [takeOff](https://www.airship.com/docs/developer/sdk-integration/apple/installation/getting-started/#calling-takeoff). By default, `useUserPreferredLocale` is `false`, and the SDK uses `Locale.autoupdatingCurrent`, which reflects the device's current locale settings. When set to `true`, the SDK uses the first language from the user's preferred languages list (`Locale.preferredLanguages[0]`), which is useful when you want the SDK to match the user's language preference rather than the device's current locale settings. #### Swift ```swift var config = AirshipConfig() // ... other config settings ... // Use preferred language instead of current locale config.useUserPreferredLocale = true try! Airship.takeOff(config) ``` #### Objective-C ```objc UAConfig *config = [UAConfig config]; // ... other config settings ... // Use preferred language instead of current locale config.useUserPreferredLocale = YES; [UAirship takeOff:config error:&airshipError]; ``` ## Overriding the locale You can override the locale programmatically at runtime, which takes precedence over both the configured locale behavior and the device's locale settings. #### Swift ```swift Airship.localeManager.currentLocale = Locale(identifier:"de") ``` #### Objective-C ```objc UAirship.localeManager.currentLocale = [NSLocale localeWithLocaleIdentifier:@"de"]; ``` ## Clearing the locale override To remove a locale override and return to using the configured locale behavior: #### Swift ```swift Airship.localeManager.clearLocale() ``` #### Objective-C ```objc [UAirship.localeManager clearLocale]; ``` ## Getting the current locale To retrieve the locale that Airship is currently using: #### Swift ```swift let airshipLocale = Airship.localeManager.currentLocale ``` #### Objective-C ```objc NSLocale *airshipLocale = UAirship.localeManager.currentLocale; ```