iOS

1. Install the SDK

You can install the Localytics iOS SDK through Swift Package Manager, Cocoapods, Carthage, or manually.

If you are upgrading from a previous version of the SDK, please refer to documentation for upgrading the SDK.

https://github.com/localytics/Localytics-swiftpm.git
      

.package(url: "https://github.com/localytics/Localytics-swiftpm.git", from: "6.3.3")
      

binary "https://downloads.localytics.com/SDKs/iOS/Localytics.json" ~> 6.3.2

2. Configure test mode

To configure test mode, you'll need to setup a URL scheme. The URL scheme is defined as "amp" followed by your Localytics app key, as demonstrated below. You can find your app key in the Localytics Dashboard. If you switch between multiple Localytics app keys, as when you have separate testing and production app keys, there's no harm in registering both URL schemes.

1. Enter Project Navigator view and click on your project icon. It should be at the top of the Project Navigator.
2. Select your target from the sidebar or from the dropdown menu, then select the Info tab.
3. Open the URL Types expander and click +.
4. In the URL Schemes field, enter "amp" followed by your Localytics app key.

3. Initialize the SDK

In order to run the Localytics SDK, you must initialize the SDK using your Localytics app key. You can find your app key in the Localytics Dashboard. Localytics can be used in Objective-C, Swift, and mixed language projects. More information on using Localytics within a Swift project is available here.

If you have an app with extensive, engaged usage in the background, or you require more fine control over the session lifecycle (most apps don't), use manual integration.

In your application's delegate file:

1. Import the Localytics SDK under any existing imports.

   Objective-C Swift

   @import Localytics;
   

   import Localytics
   

2. For customers who grant their users the ability to opt out of data collection, please continue with integration by following the advanced section.

   Additionally, for customers who opt their app into iPad multi-window behavior in iOS 13 and above, please continue with integration by following the advanced section.

   Add the following line to the start of didFinishLaunchingWithOptions:.

   Objective-C Swift

   [Localytics autoIntegrate:@"YOUR-LOCALYTICS-APP-KEY"
       withLocalyticsOptions:@{
                               LOCALYTICS_WIFI_UPLOAD_INTERVAL_SECONDS: @5,
                               LOCALYTICS_GREAT_NETWORK_UPLOAD_INTERVAL_SECONDS: @10,
                               LOCALYTICS_DECENT_NETWORK_UPLOAD_INTERVAL_SECONDS: @30,
                               LOCALYTICS_BAD_NETWORK_UPLOAD_INTERVAL_SECONDS: @90
                             }
               launchOptions:launchOptions];
   

   Localytics.autoIntegrate("YOUR-LOCALYTICS-APP-KEY", withLocalyticsOptions:[
                           LOCALYTICS_WIFI_UPLOAD_INTERVAL_SECONDS: 5,
                           LOCALYTICS_GREAT_NETWORK_UPLOAD_INTERVAL_SECONDS: 10,
                           LOCALYTICS_DECENT_NETWORK_UPLOAD_INTERVAL_SECONDS: 30,
                           LOCALYTICS_BAD_NETWORK_UPLOAD_INTERVAL_SECONDS: 90
                         ], launchOptions: launchOptions)
   

   Localytics attempts to upload user data quickly to our backend to power time sensitive messaging use cases. By default, Localytics will upload data periodically based on the state of a user's network connection. However, you have full flexibility over this behavior. While not recommended, you can change the upload intervals for each type of connection, and even remove this type of behavior entirely and depend on your own Localytics.upload() calls to upload data whenever you wish.

   To use the default intervals provided by Localytics, you can pass in nil into localyticsOptions. If you would like to disable scheduled uploads, pass in -1 as the value for all keys.

   The available keys for setting upload intervals are:

   • LOCALYTICS_WIFI_UPLOAD_INTERVAL_SECONDS: Defines the interval that will be used in the case of a WiFi connection. Having a WiFi connection will supersede any mobile data connection. Default value is 5 seconds.
   • LOCALYTICS_GREAT_NETWORK_UPLOAD_INTERVAL_SECONDS: Defines the interval that will be used in the case of 4G or LTE connections. Default value is 10 seconds.
   • LOCALYTICS_DECENT_NETWORK_UPLOAD_INTERVAL_SECONDS: Defines the interval that will be used in the case of 3G connection. Default value is 30 seconds.
   • LOCALYTICS_BAD_NETWORK_UPLOAD_INTERVAL_SECONDS: Defines the interval that will be used in the case of 2G or EDGE connections. Default value is 90 seconds.

3. Compile and run your app.

4. Next steps

Congratulations! You have successfully performed the basic Localytics integration and are now sending session data to Localytics. You can also use Localytics In-App Messaging to message users in your app, and you have everything you need to track where your most highly engaged users are coming from.

Note that it may take a few minutes for your first datapoints to show up within the Localytics Dashboard. In the meantime, we suggest reading the next few sections to learn how to:

1. Track one user action as an event
2. Track one user property as a profile attribute
3. Integrate push messaging

We recommend doing these things before releasing your app for the first time with Localytics.

Standard events

Standard events make it easier to analyze user behavior and optimize your app marketing around common business goals such as driving user registrations or purchases. You can also tag custom events for other user behavior in your app that doesn't match one of the standard events.

[Localytics tagPurchased:@"Shirt"
                  itemId:@"sku-123"
                itemType:@"Apparel"
               itemPrice:@15
              attributes:extraAttributes];

Localytics.tagPurchased("Shirt", itemId: "sku-123", itemType: "Apparel", itemPrice: 15, attributes: extraAttributes)

[Localytics tagAddedToCart:@"Shirt"
                    itemId:@"sku-123"
                  itemType:@"Apparel"
                 itemPrice:@15
                attributes:extraAttributes];

Localytics.tagAddedToCart("Shirt", itemId: "sku-123", itemType: "Apparel", itemPrice: 15, attributes: extraAttributes)

[Localytics tagStartedCheckout:@50
                     itemCount:@2
                    attributes:extraAttributes];

Localytics.tagStartedCheckout(50, itemCount: 2, attributes: extraAttributes)

[Localytics tagCompletedCheckout:@50
                       itemCount:@2
                      attributes:extraAttributes];

Localytics.tagCompletedCheckout(50, itemCount: 2, attributes: extraAttributes)

[Localytics tagContentViewed:@"Top 10"
                   contentId:@"e8z7319zbe"
                 contentType:@"Article"
                  attributes:extraAttributes];

Localytics.tagContentViewed("Top 10", contentId: "e8z7319zbe", contentType: "Article", attributes: extraAttributes)

[Localytics tagSearched:@"Celtics"
            contentType:@"Sports"
            resultCount:@15
             attributes:extraAttributes];

Localytics.tagSearched("Celtics", contentType: "Sports", resultCount: 15, attributes: extraAttributes)

[Localytics tagShared:@"Top 10"
            contentId:@"e8z7319zbe"
          contentType:@"Article"
           methodName:@"Twitter"
           attributes:extraAttributes];

Localytics.tagShared("Top 10", contentId: "e8z7319zbe", contentType: "Article", methodName: "Twitter", attributes: extraAttributes)

[Localytics tagContentRated:@"Headlines"
                  contentId:@"8a4z5j9q"
                contentType:@"Song"
                     rating:@5
                 attributes:extraAttributes];

Localytics.tagContentRated("Headlines", contentId: "8a4z5j9q", contentType: "Song", rating: 5, attributes: extraAttributes)

[Localytics tagCustomerRegistered:[LLCustomer customerWithBlock:^(LLCustomerBuilder *builder) {
          builder.customerId = @"3neRKTxbNWYKM4NJ";
          builder.firstName = @"John";
          builder.lastName = @"Smith";
          builder.fullName = @"Mr. John Smith, III";
          builder.emailAddress = @"john@smith.com";
      }]
                       methodName:@"Facebook"
                       attributes:extraAttributes];

Localytics.tagCustomerRegistered((LLCustomer { (builder) in
  builder.customerId = "3neRKTxbNWYKM4NJ"
  builder.firstName = "John"
  builder.lastName = "Smith"
  builder.fullName = "Mr. John Smith, III"
  builder.emailAddress = "john@smith.com"
}), methodName: "Facebook", attributes: extraAttributes)

[Localytics tagCustomerLoggedIn:[LLCustomer customerWithBlock:^(LLCustomerBuilder *builder) {
          builder.customerId = @"3neRKTxbNWYKM4NJ";
          builder.firstName = @"John";
          builder.lastName = @"Smith";
          builder.fullName = @"Mr. John Smith, III";
          builder.emailAddress = @"john@smith.com";
      }]
                     methodName:@"Native"
                     attributes:extraAttributes];

Localytics.tagCustomerLoggedIn((LLCustomer { (builder) in
  builder.customerId = "3neRKTxbNWYKM4NJ"
  builder.firstName = "John"
  builder.lastName = "Smith"
  builder.fullName = "Mr. John Smith, III"
  builder.emailAddress = "john@smith.com"
}), methodName: "Native", attributes: extraAttributes)

[Localytics tagCustomerLoggedOut:extraAttributes];

Localytics.tagCustomerLoggedOut(extraAttributes)

[Localytics tagInvited:@"SMS"
            attributes:extraAttributes];

Localytics.tagInvited("SMS", attributes: extraAttributes)

Custom event

Objective-C Swift

[Localytics tagEvent:@"Team Favorited"];

Localytics.tagEvent("Team Favorited")

Custom event with attributes

Objective-C Swift

[Localytics tagEvent:@"Team Favorited"
          attributes:@{@"Team Name" : @"Celtics", @"City" : @"Boston"}];

Localytics.tagEvent("Team Favorited", attributes: ["Team Name" : "Celtics", "City" : "Boston"])

Customer ID

Objective-C Swift

[Localytics setCustomerId:@"3neRKTxbNWYKM4NJ"];

Localytics.setCustomerId("3neRKTxbNWYKM4NJ")

Customer first name

Objective-C Swift

[Localytics setCustomerFirstName:@"John"];

Localytics.setCustomerFirstName("John")

Customer last name

Objective-C Swift

[Localytics setCustomerLastName:@"Smith"];

Localytics.setCustomerLastName("Smith")

Customer full name

Objective-C Swift

[Localytics setCustomerFullName:@"Sir John Smith, III"];

Localytics.setCustomerFullName("Sir John Smith, III")

Customer email address

Objective-C Swift

[Localytics setCustomerEmail:@"sir.john@smith.com"];

Localytics.setCustomerEmail("sir.john@smith.com")

Setting a profile attribute value

[Localytics setValue:@45 forProfileAttribute:@"Age" withScope:LLProfileScopeOrganization];

Localytics.setValue(45, forProfileAttribute: "Age", with: .organization)

[Localytics setValue:@[@8, @13] forProfileAttribute:@"Lucky Numbers" withScope:LLProfileScopeApplication];

Localytics.setValue([8, 13], forProfileAttribute: "Lucky numbers", with: .application)

[Localytics setValue:[NSDate date] forProfileAttribute:@"Last Purchase Date" withScope:LLProfileScopeOrganization];

Localytics.setValue(NSDate(), forProfileAttribute: "Last Purchase Date", with: .organization)

NSDateFormatter* dateFormatter = [[NSDateFormatter alloc] init];
[dateFormatter setDateFormat:@"MM-dd-yyyy"];
[Localytics setValue:@[[dateFormatter dateFromString:@"10-01-2015"], [dateFormatter dateFromString:@"03-17-2016"]] forProfileAttribute:@"Upcoming Milestone Dates" withScope:LLProfileScopeApplication];

let dateFormatter = DateFormatter()
dateFormatter.dateFormat = "MM-dd-yyyy"
Localytics.setValue([dateFormatter.date(from: "10-01-2015")!, dateFormatter.date(from: "03-17-2016")!], forProfileAttribute: "Upcoming Milestone Dates", with: .application)

[Localytics setValue:@"New York, New York" forProfileAttribute:@"Hometown" withScope:LLProfileScopeOrganization];

Localytics.setValue("New York, New York", forProfileAttribute: "Hometown", with: .organization)

[Localytics setValue:@[@"New York", @"California", @"South Dakota"] forProfileAttribute:@"States Visited" withScope:LLProfileScopeApplication];

Localytics.setValue(["New York", "California", "South Dakota"], forProfileAttribute: "States Visited", with: .application)

Removing a profile attribute

Objective-C Swift

[Localytics deleteProfileAttribute:@"Days Until Graduation" withScope:LLProfileScopeApplication];

Localytics.deleteProfileAttribute("Days Until Graduation", with: .application)

Adding to a set of profile attribute values

[Localytics addValues:@[@8] toSetForProfileAttribute:@"Lucky Numbers" withScope:LLProfileScopeApplication];

Localytics.addValues([8], toSetForProfileAttribute: "Lucky Numbers", with: .application)

NSDateFormatter* dateFormatter = [[NSDateFormatter alloc] init];
[dateFormatter setDateFormat:@"MM-dd-yyyy"];
[Localytics addValues:@[[dateFormatter dateFromString:@"04-19-2015"], [dateFormatter dateFromString:@"12-24-2015"]] toSetForProfileAttribute:@"Upcoming Milestone Dates" withScope:LLProfileScopeApplication];

let dateFormatter = DateFormatter()
dateFormatter.dateFormat = "MM-dd-yyyy"
Localytics.addValues([dateFormatter.date(from: "4-19-2015")!, dateFormatter.date(from: "12-24-2015")!], toSetForProfileAttribute: "Upcoming Milestone Dates", with: .application)

[Localytics addValues:@[@"North Dakota"] toSetForProfileAttribute:@"States Visited" withScope:LLProfileScopeApplication];

Localytics.addValues(["North Dakota"], toSetForProfileAttribute: "States Visited", with: .application)

Removing from a set of profile attribute values

[Localytics removeValues:@[@8, @9] fromSetForProfileAttribute:@"Lucky Numbers" withScope:LLProfileScopeApplication];

Localytics.removeValues([8, 9], fromSetForProfileAttribute: "Lucky Numbers", with: .application)

NSDateFormatter* dateFormatter = [[NSDateFormatter alloc] init];
[dateFormatter setDateFormat:@"MM-dd-yyyy"];
[Localytics removeValues:@[[dateFormatter dateFromString:@"03-17-2016"]] fromSetForProfileAttribute:@"Upcoming Milestone Dates" withScope:LLProfileScopeApplication];

let dateFormatter = DateFormatter()
dateFormatter.dateFormat = "MM-dd-yyyy"
Localytics.removeValues([dateFormatter.date(from: "03-17-2016")!], fromSetForProfileAttribute: "Upcoming Milestone Dates", with: .application)

[Localytics removeValues:@[@"California"] fromSetForProfileAttribute:@"States Visited" withScope:LLProfileScopeApplication];

Localytics.removeValues(["California"], fromSetForProfileAttribute: "States Visited", with: .application)

Incrementing a numeric profile attribute value

Objective-C Swift

[Localytics incrementValueBy:1 forProfileAttribute:@"Age" withScope:LLProfileScopeOrganization];

Localytics.incrementValueBy(1, forProfileAttribute: "Age", with: .organization)

Decrementing a numeric profile attribute value

Objective-C Swift

[Localytics decrementValueBy:3 forProfileAttribute:@"Days Until Graduation" withScope:LLProfileScopeApplication];

Localytics.decrementValueBy(3, forProfileAttribute: "Days Until Graduation", with: .application)

Triggering in-app messages

When creating in-app campaigns in the Localytics Dashboard, you decide under which conditions the in-app creative should display. You can trigger in-app messages to display at session start. You can also trigger in-app messages to display when a particular event is tagged using the event name alone or using the event name combined with attribute conditions.

Sometimes, you just want to display an in-app message, but there is not an existing event tag of which to take advantage, and you don't want to create an additional event datapoint solely to display a message. In this situation, Localytics marketing triggers allow you to trigger in-app messages off of specific user behaviors that you do not have tagged as an event in the Localytics dashboard.

There are a variety of scenarios where these triggers might be relevant:

• You have a lot of Summary Events tagged, and Summary Events do not allow for granular behavioral triggering of messages.
• You do not want to pass a particular behavior as an Event to the Localytics dashboard because the behavior is so frequent that an Event tag would incur high data point usage.

[Localytics triggerInAppMessage:@"Item Purchased"];

Localytics.triggerInAppMessage("Item Purchased")

[Localytics triggerInAppMessage:@"Item Purchased" withAttributes:@{@"Item name" : @"Stickers"}];

Localytics.triggerInAppMessage("Item Purchased", withAttributes: ["Item name" : "Stickers"])

Selecting marketing triggers in the dashboard

Once the marketing trigger has been instrumented in the app’s code base, you can use these to trigger in-app messages in the Localytics dashboard. When you get to the Scheduling page of the campaign setup process, you will chose the “Event” trigger. For these marketing triggers, you will need to type in the name of the marketing trigger in the drop down (as seen below) - it will not automatically populate as the dashboard events do.

Customizing in-app messages

[Localytics setInAppMessageDismissButtonImageWithName:@"custom_dismiss_button"];

Localytics.setInAppMessageDismissButtonImageWithName("custom_dismiss_button")

[Localytics setInAppMessageDismissButtonImage:[UIImage imageNamed:@"custom_dismiss_button"]];

Localytics.setInAppMessageDismissButtonImage(UIImage(named: "custom_dismiss_button"))

[Localytics setInAppMessageDismissButtonImage:nil];

Localytics.setInAppMessageDismissButtonImage(nil)

[Localytics setInAppMessageDismissButtonLocation:LLInAppMessageDismissButtonLocationLeft];

Localytics.setInAppMessageDismissButtonLocation(.left)

[Localytics setInAppMessageDismissButtonLocation:LLInAppMessageDismissButtonLocationRight];

Localytics.setInAppMessageDismissButtonLocation(.right)

<html>
  <head>
    <meta http-equiv="content-type" content="text/html; charset=utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" data-localytics="notch_fullscreen=true, close_button_visibility=visible, close_button_position=right, offset=50, aspect_ratio=1.5, background_alpha=0.8 video_conversion_percentage=80" />

- (nonnull LLInAppConfiguration *)localyticsWillDisplayInAppMessage:(nonnull LLInAppCampaign *)campaign withConfiguration:(nonnull LLInAppConfiguration *)configuration {
  if ([configuration isCenterCampaign]) {
    configuration.aspectRatio = 1.2;
  } else if ([configuration isTopBannerCampaign] || [configuration isBottomBannerCampaign]) {
    configuration.offset = 50;
  }
  configuration.backgroundAlpha = 0;
  configuration.dismissButtonImage = [UIImage imageNamed:@"custom_dismiss_button"];
  configuration.dismissButtonLocation = LLInAppMessageDismissButtonLocationRight;
  configuration.dismissButtonHidden = YES;
  configuration.autoHideHomeScreenIndicator = YES;
  configuration.notchFullScreen = YES;

  return configuration;
}

func localyticsWillDisplay(inAppMessage campaign: LLInAppCampaign, with configuration: LLInAppConfiguration) -> LLInAppConfiguration {
    if configuration.isCenterCampaign() {
        configuration.aspectRatio = 1.2
    } else if configuration.isTopBannerCampaign() || configuration.isBottomBannerCampaign() {
        configuration.offset = 50
    }
    configuration.backgroundAlpha = 0
    configuration.dismissButtonImage = UIImage(named:"custom_dismiss_button")
    configuration.dismissButtonLocation = .right
    configuration.dismissButtonHidden = true
    configuration.autoHideHomeScreenIndicator = true;
    configuration.notchFullScreen = true;

    return configuration
}

Custom Creative Javascript API

The Localytics SDK adds a localytics Javascript function to the in-app HTML that provides access to several native SDK methods and properties and handles URL navigation and in-app dismissal.

The localytics Javascript function is only added to the in-app after the web view has finished loading, and initial rendering has completed. As a result, if you are trying to render content based on Localytics data (such as a custom dimension), we suggest calling Localytics asynchronously and including some type of loading indicator.

The sections below cover the details of the in-app Javascript API. It is crucial to understand these APIs when designing and uploading your own custom creatives. Note: When using the in-app message builder, calls to these APIs will be handled automatically.

// Opening a web URL
function openHomePage() {
  window.open("https://www.localytics.com?ampAction=click&ampExternalOpen=true");
  localytics.close();
}

// Opening a deep link URL
function openFavorites() {
  window.open("myApp://favorites?ampAction=click");
  localytics.close();
}

// Opening a deep link to the favorites page
function openFavorites() {
  window.open("myApp://favorites?ampAction=favorites");
  localytics.close();
}

// Opening a deep link to the share page
function openShare() {
  window.open("myApp://share?ampAction=share");
  localytics.close();
}

// Opening a web URL in the phone's default browser
function openHomepage() {
  window.open("https://www.localytics.com?ampAction=click&ampExternalOpen=true");
  localytics.close();
}

// Opening a web URL within the in-app message view
function openBlogInsideInApp() {
  window.open("https://info.localytics.com/blog?ampAction=click&ampExternalOpen=false");
}

// Opening another HTML file contained in the ZIP within the in-app message view
function goToFeedback() {
  window.open("feedback.html?ampAction=feedback&ampExternalOpen=false");
}

1. Enable push and background modes capabilities

1. Enter Project Navigator view and click on your project icon.
2. Select your target from the expanded sidebar or from the dropdown menu next to General then select the Capabilities tab.
3. If Push Notifications isn't enabled, click the switch to add the "Push Notifications" entitlement to your App ID. If you are using Xcode 8, ensure that an APP-NAME.entitlements file has been added to your project.
4. If Background Modes isn't enabled, click the switch and then check the Remote notifications box. Localytics uses background modes to track when push messages are received on a user's device before the message is ever opened.

2. Register for a push token

Add the following code to your app delegate's didFinishLaunchingWithOptions: to request a push token from Apple Push Notification Services (APNS). This will not prompt the user for notification display permissions.

Objective-C Swift

[application registerForRemoteNotifications];

application.registerForRemoteNotifications()

3. Register for notifications

On iOS 12+, you have the option of provisionally authorizing users to receive push notifications, even if they haven’t yet opted in to receive notifications. These provisional notifications are “delivered quietly” directly to the device Notification Center. We strongly encourage you to enable provisional authorization, as it can dramatically increase the number of users who can receive push notifications.

Provisional authorization requires that you use the UserNotifications framework. First you must import it:

Objective-C Swift

@import UserNotifications;

import UserNotifications

Then, request provisional authorization after the Localytics initialization code in didFinishLaunchingWithOptions: in your AppDelegate:

Objective-C Swift

if (NSClassFromString(@"UNUserNotificationCenter") && @available(iOS 12.0, *)) {
  UNAuthorizationOptions options = UNAuthorizationOptionProvisional;
  [[UNUserNotificationCenter currentNotificationCenter] requestAuthorizationWithOptions:options
            completionHandler:^(BOOL granted, NSError * _Nullable error) {
                [Localytics didRequestUserNotificationAuthorizationWithOptions:options
                            granted:granted];
  }];
}

if #available(iOS 12.0, *), objc_getClass("UNUserNotificationCenter") != nil {
    let options: UNAuthorizationOptions = [.provisional]
    UNUserNotificationCenter.current().requestAuthorization(options: options) { (granted, error) in
        Localytics.didRequestUserNotificationAuthorization(withOptions: options.rawValue, granted: granted)
    }
} 

Although Provisional Auth allows you to send notifications to users before they've opted into push, we still strongly recommend that you encourage users to fully opt in. When a user opts in, notifications will get shown on the Lock Screen and as banners, badges will be incremented, and sounds will played when a notification is received. All of this increases the prominence of the notification, increasing the chances that it will be seen by the user.

The most effect way to drive opt ins is through a soft-ask, which we discuss here. However, if you would prefer to trigger the system prompt for push authorization some other way, you can call the following:

Objective-C Swift

if (NSClassFromString(@"UNUserNotificationCenter")) {
  UNAuthorizationOptions options = (UNAuthorizationOptionBadge | UNAuthorizationOptionSound | UNAuthorizationOptionAlert);
  [[UNUserNotificationCenter currentNotificationCenter] requestAuthorizationWithOptions:options
                                                                      completionHandler:^(BOOL granted, NSError * _Nullable error) {
                                                                        [Localytics didRequestUserNotificationAuthorizationWithOptions:options
                                                                                                                               granted:granted];
                                                                      }];
} else {
  UIUserNotificationType types = (UIUserNotificationTypeAlert | UIUserNotificationTypeBadge | UIUserNotificationTypeSound);
  UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes:types categories:nil];
  [application registerUserNotificationSettings:settings];
}

if #available(iOS 10.0, *), objc_getClass("UNUserNotificationCenter") != nil {
    let options: UNAuthorizationOptions = [.alert, .badge, .sound]
    UNUserNotificationCenter.current().requestAuthorization(options: options) { (granted, error) in
        Localytics.didRequestUserNotificationAuthorization(withOptions: options.rawValue, granted: granted)
    }
} else {
    let types: UIUserNotificationType = [.alert, .badge, .sound]
    let settings = UIUserNotificationSettings(types: types, categories: nil)
    application.registerUserNotificationSettings(settings)
}

4. Handle opened remote notifications

This step is only required if you are using the UserNotification framework introduced in iOS 10 and you are setting a UNUserNotificationCenterDelegate. If this doesn't apply to your app, please continue on to creating a univeral push notification client SSL certificate.

When using the UserNotification framework and using a UNUserNotificationCenterDelegate, you need to notify the Localytics SDK when notifications are opened. Add the following to your userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler: delegate method:

Objective-C Swift

- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void(^)())completionHandler {
  [Localytics didReceiveNotificationResponseWithUserInfo:response.notification.request.content.userInfo];
  completionHandler();
}

@available(iOS 10.0, *) // if also targeting iOS versions less than 10.0
func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
    Localytics.didReceiveNotificationResponse(userInfo: response.notification.request.content.userInfo)
    completionHandler()
}

5. Create a universal push notification client SSL certificate

To prepare for push notifications on iOS, you need to create a Universal Push Notification Client SSL Certificate that allows Localytics to connect to the Apple Push Notification service. A universal certificate allows your app to connect to both the development and production environments.

1. Log in to the Apple Developer console and go to Certificates, Identifiers & Profiles.
2. Under Certificates, select All and then click the Add button (+) in the upper-right corner.
3. Under Production, select the "Apple Push Notification service SSL (Sandbox & Production)" checkbox, and click Continue.
4. Choose an App ID from the App ID pop-up menu, and click Continue. Choose the explicit App ID that matches your bundle ID. If your explicit App ID doesn't appear in the list, follow our instructions for creating an explicit App ID and then return to this step.
5. Follow the instructions on the next webpage to create a certificate request on your Mac, and click Continue.
6. On the Generate your certificate page, click Choose File and choose the certificate request file you just created (with a .certSigningRequest extension) and then click Continue.
7. Download the generated certificate to your Mac and then double-click the .cer file to install it in Keychain Access. Finally, click Done.

6. Verify your App ID is push enabled

1. Log in to the Apple Developer console and go to Certificates, Identifiers & Profiles.
2. Under Identifiers, select App IDs and then select the explicit App ID that matches the bundle ID.
3. Verify that a green circle followed by "Enabled" appears in the Push Notifications row and the Distribution column. Because this is a universal certificate, the Development column will remain in the "Configurable" state. This is expected - you don't need to create a development specific certificate because the universal certificate will work within both development and production builds.

7. Upload your push certificate

In order for Localytics to be able to send pushes on your behalf, you must provide Localytics with the universal push certificate you generated.

1. On your Mac Launch Keychain Access.
2. In the Category section, select My Certificates.
3. Find the certificate you generated and disclose its contents. You’ll see both a certificate and a private key.
4. Select both the certificate and the key, and choose File > Export Items.
5. Save the certificate in the Personal Information Exchange (.p12) format. You can optionally enter a password to protect the item.
6. Login to the Localytics Dashboard and navigate to Settings > Apps.
7. Find your app key app in the list and click the gear icon.
8. Click Add Certs and then click Upload Certificate.
9. Browse to the location of the .p12 file you created and select it.
10. Select Development from the Push Mode dropdown menu.
11. Enter your push certificate password if you previously added one. Leave the Push Password field blank if your push certifcate doesn't have a password.
12. Click Save.

8. Generate a development build

A development build allows you to most easily test your push integration. You cannot test push in the iOS Simulator, so you must physically connect a device and target it for a build.

1. Connect a physical device to your computer using a USB cable.
2. In Xcode, select the device you just connected as the destination for new builds. The destination dropdown is in the toolbar at the top to the right of the run and stop buttons.
3. Navigate to the Product menu and click Run. You may need to unlock your device.
4. A development build of your app will appear on your connected device. If you have logging enabled at this point, you should see messages indicating that the Localytics SDK obtained your push token and should see the push token present in the dpush field of the next upload body.

9. Test push integration

If you have integrated SDK version 4.1 or later, use the Rapid Push Verification page to confirm that you have integrated push correctly. Be sure to select the correct app in the dropdown at the top of the page.

If you experience issues testing your push integration, go through the following steps to troubleshoot your integration:

1. Make sure your SDK version is 4.1 or later.
2. Ensure your app has been integrated for Localytics push notifications. Check the "Register for notifications" section in our guide.
3. Make sure you have generated a development build for your app. See "Generate a development build" to physically connect a device and target it for a build.
4. Confirm that you are collecting push tokens every session. Be sure to be calling a request to collect tokens early (preferably on app launch) to ensure collection of fresh tokens. See "Register for a push token" for instructions. For manual integrations, call setPushToken in your App Delegate when tokens are collected to send the token to Localytics (see Step 6 in our Manual Integration guide).
5. If your app is not opening after scanning the QR code on the Rapid Push Verification Page, try opening the link in Safari to see if your app launches. If not, make sure your deep link scheme is set up correctly by going back to "Configure test mode. If still having issues and you have manually integrated, see Step 5 under Manual Integration.
6. If you opened the push message successfully but no Push Opened event was reported, check that you are properly integrated to "Handle opened remote notifications" in Step 4 (for auto and manual integrations). If still having issues and you have manually integrated, check you have properly integrated Step 8 of Manual Integration.

10. Add support for rich media push attachments (optional)

Rich Push on iOS is purely optional but requires iOS 10, Localytics SDK v4.1 or higher, and the new UserNotifications framework if you wish to use this feature. See our migration guide for details on the prerequisites.

To integrate Rich Push, you'll need to create a new Notification Service Extension:

1. Open up Xcode and navigate to File > New > Target. The following dialog will pop up:

2. Select the Notification Service Extension option, click "Next", fill out the name, and click "Finish". Xcode will now create a new top level folder in your project with the name you provided, containing a NotificationServiceExtension class.
3. Include the below code snippet in the didReceiveNotificationRequest:withContentHandler: method of the extension.

   Objective-C Swift

   - (void)didReceiveNotificationRequest:(UNNotificationRequest *)request withContentHandler:(void (^)(UNNotificationContent * _Nonnull))contentHandler {
     self.contentHandler = contentHandler;
     self.bestAttemptContent = [request.content mutableCopy];
   
       // Modify the notification content here...
       NSString *imageURL = self.bestAttemptContent.userInfo[@"ll_attachment_url"];
       NSString *imageType = self.bestAttemptContent.userInfo[@"ll_attachment_type"];
       if (!imageURL || !imageType) {
           //handle non localytics rich push
           self.contentHandler(self.bestAttemptContent);
           return;
       }
       NSURL *url = [NSURL URLWithString:imageURL];
       [[[NSURLSession sharedSession] downloadTaskWithURL:url completionHandler:^(NSURL * _Nullable tempFile, NSURLResponse * _Nullable response, NSError * _Nullable error) {
           if (error) {
               NSLog(@"Failed to retrieve attachment with error: %@", [error localizedDescription]);
               self.contentHandler(self.bestAttemptContent);
               return;
           }
   
           NSArray *cache = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
           NSString *cachesFolder = cache[0];
   
           NSString *guid = [[NSProcessInfo processInfo] globallyUniqueString];
           NSString *fileName = [[guid stringByAppendingString:@"localytics-rich-push-attachment"] stringByAppendingPathExtension:imageType];
           NSString *cacheFile = [cachesFolder stringByAppendingPathComponent:fileName];
           NSURL *attachmentURL = [NSURL fileURLWithPath:cacheFile isDirectory:NO];
           NSError *err = nil;
           [[NSFileManager defaultManager] moveItemAtURL:tempFile toURL:attachmentURL error:&err];
           if (err) {
               NSLog(@"Failed to save attachment on disk with error: %@", [err localizedDescription]);
               self.contentHandler(self.bestAttemptContent);
               return;
           }
   
           UNNotificationAttachment *attachment = [UNNotificationAttachment attachmentWithIdentifier:@"" URL:attachmentURL options:nil error:&err];
           if (attachment) {
               self.bestAttemptContent.attachments = @[attachment];
           } else {
               NSLog(@"Failed to create attachment with error: %@", [err localizedDescription]);
           }
           self.contentHandler(self.bestAttemptContent);
       }] resume];
   }
     
   

   override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
     self.contentHandler = contentHandler
     self.bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
   
     if let bestAttemptContent =  bestAttemptContent {
         if let attachmentURL = bestAttemptContent.userInfo["ll_attachment_url"] as? String, let attachmentType = bestAttemptContent.userInfo["ll_attachment_type"] as? String {
             guard let url = URL(string: attachmentURL) else {
                 print("Failed to present attachment due to an invalid url: %@", attachmentURL)
                 contentHandler(bestAttemptContent)
                 return
             }
   
             let task = URLSession.shared.downloadTask(with: url) { (tempFile, response, error) in
                 if let error = error {
                     print("Failed to retrieve attachment with error: %@", error.localizedDescription)
                     contentHandler(bestAttemptContent)
                     return
                 }
                 guard let tempFile = tempFile else {
                     print("Failed to store contents of attachment on disk")
                     contentHandler(bestAttemptContent)
                     return
                 }
   
                 let cache = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true)
                 let cachesFolder = cache[0]
   
                 let guid = ProcessInfo.processInfo.globallyUniqueString
                 let cacheFile = "\(cachesFolder)/\(guid)-localytics-rich-push-attachment.\(attachmentType)"
                 let attachmentURL = URL(fileURLWithPath: cacheFile)
   
                 do {
                     try FileManager.default.moveItem(at: tempFile, to: attachmentURL)
   
                     let attachment = try UNNotificationAttachment(identifier: "localytics-rich-push-attachment", url: attachmentURL, options: nil)
                     bestAttemptContent.attachments = [attachment]
                 } catch _ {
                     print("Failed to create attachment for push notification")
                 }
   
                 contentHandler(bestAttemptContent)
             }
             task.resume()
         } else {
             //handle non localytics rich push
             contentHandler(bestAttemptContent)
         }
     }
   }
   
     
   

11. Add support for categories and actions (optional)

Categories and actions on iOS are purely optional but require Localytics SDK v4.4 or higher for proper reporting functionality.

Steps to integrate categories and actions:

1. Register your desired categories and actions. These are generally configured within your App Delegate. For apps targeting iOS 10 and using the UserNotifications framework:

   Objective-C Swift

   UNNotificationAction *like = [UNNotificationAction actionWithIdentifier:@"like" title:@"Like" options:UNNotificationActionOptionForeground];
   UNNotificationAction *share = [UNNotificationAction actionWithIdentifier:@"share" title:@"Share" options:UNNotificationActionOptionForeground];
   UNNotificationCategory *social = [UNNotificationCategory categoryWithIdentifier:@"social" actions:@[like, share] intentIdentifiers:@[] options:UNNotificationCategoryOptionNone];
   
   NSSet *categories = [NSSet setWithArray:@[social]];
   [[UNUserNotificationCenter currentNotificationCenter] setNotificationCategories:categories];
         
   

   let likeAction = UNNotificationAction(identifier: "like", title: "Like", options: .foreground)
   let shareAction = UNNotificationAction(identifier: "share", title: "Share", options: .foreground)
   let socialCategory = UNNotificationCategory(identifier: "social", actions: [likeAction, shareAction], intentIdentifiers: [], options: [])
   
   var categories = Set<UNNotificationCategory>()
   categories.insert(socialCategory)
   UNUserNotificationCenter.current().setNotificationCategories(categories)
         
   

   For apps targeting iOS 9 use the following:

   Objective-C Swift

   UIMutableUserNotificationAction *like = [[UIMutableUserNotificationAction alloc] init];
   like.title = @"Like";
   like.identifier = @"like";
   like.activationMode = UIUserNotificationActivationModeForeground;
   
   UIMutableUserNotificationAction *share = [[UIMutableUserNotificationAction alloc] init];
   share.title = @"Share";
   share.identifier = @"share";
   share.activationMode = UIUserNotificationActivationModeForeground;
   
   UIMutableUserNotificationCategory *social = [[UIMutableUserNotificationCategory alloc] init];
   social.identifier = @"social";
   [social setActions:@[like, share] forContext:UIUserNotificationActionContextMinimal];
   
   NSSet *categories = [NSSet setWithArray:@[social]];
   [application registerUserNotificationSettings:[UIUserNotificationSettings settingsForTypes:types categories:categories]];
         
   

   let like = UIMutableUserNotificationAction()
   like.title = "Like"
   like.identifier = "like"
   like.activationMode = .foreground
   
   let share = UIMutableUserNotificationAction()
   share.title = "Share"
   share.identifier = "share"
   share.activationMode = .foreground
   
   let social = UIMutableUserNotificationCategory()
   social.identifier = "social"
   social.setActions([like, share], for:.minimal)
   
   application.registerUserNotificationSettings(UIUserNotificationSettings(types:.alert, categories:[social]))
   

2. Handle the actions when the respective action button is pressed and pass the action identifier to Localytics.

   Objective-C Swift

   -(void) userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse: UNNotificationResponse *)response withCompletionHandler:(void (^)())completionHandler {
   
     [Localytics didReceiveNotificationResponse:response.notification.request.content.userInfo andActionIdentifier: response.actionIdentifier];
   
     if ([@"like" isEqualToString:response.actionIdentifier]) {
       //handle behavior for like button
     } else if ([@"share" isEqualToString:response.actionIdentifier]) {
       //handle behavior for share button
     } else if ([UNNotificationDefaultActionIdentifier isEqualToString:response.actionIdentifier]) {
       //handle open behavior
     } else if([UNNotificationDismissActionIdentifier isEqualToString:response.actionIdentifier]) {
       //handle dismiss behavior
     }
     if (completionHandler) {
       completionHandler();
     }
   }
   

   func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
     Localytics.didReceiveNotificationResponse(userInfo: response.notification.request.content.userInfo, andActionIdentifier: response.actionIdentifier)
   
     switch response.actionIdentifier {
       case "like": break // handle like button
       case "share": break // handle share button
       case UNNotificationDefaultActionIdentifier: break // handle default open
       case UNNotificationDismissActionIdentifier: break // handle dismiss
       default: break // handle other cases
     }
   
     completionHandler()
   }
   

3. If you are using manual integration and targeting iOS 9 and below, implement methods in your App Delegate to handle the actions when notifications are received.

   Objective-C Swift

   - (void)application:(UIApplication *)application handleActionWithIdentifier:(nullable NSString *)identifier forRemoteNotification:(nonnull NSDictionary *)userInfo completionHandler:(nonnull void (^)())completionHandler {
     [self.localyticsDelegate handleNotification:userInfo withActionIdentifier:identifier];
     if (completionHandler){
       completionHandler(UIBackgroundFetchResultNoData);
     }
   }
   
   - (void)application:(UIApplication *)application handleActionWithIdentifier:(nullable NSString *)identifier forRemoteNotification:(nonnull NSDictionary *)userInfo withResponseInfo:(nonnull NSDictionary *)responseInfo completionHandler:(nonnull void (^)())completionHandler {
     [self.localyticsDelegate handleNotification:userInfo withActionIdentifier:identifier];
     if (completionHandler){
       completionHandler(UIBackgroundFetchResultNoData);
     }
   }
   

   func application(_ application: UIApplication, handleActionWithIdentifier identifier: String?, forRemoteNotification userInfo: [AnyHashable : Any], completionHandler: @escaping () -> Void) {
     Localytics.handleNotification(userInfo, withActionIdentifier:identifier)
   }
   
   func application(_ application: UIApplication, handleActionWithIdentifier identifier: String?, forRemoteNotification userInfo: [AnyHashable : Any], withResponseInfo responseInfo: [AnyHashable : Any], completionHandler: @escaping () -> Void) {
     Localytics.handleNotification(userInfo, withActionIdentifier:identifier)
   }
   

12. Before you release to the App Store

Before you release your app to the App Store, you will want to test that it can properly receive not only development push messages as above, but also production push messages. We also recommend using a different Localytics app key for the production build of your app.

1. If your production build uses a different App ID/Bundle ID than your development build, follow the creating a universal certificate and verifying your App ID is push enabled instructions to generate a universal push notification certificate for this App ID.
2. Upload your universal push certificate to Localytics for your production app key. Follow the uploading your push certificate instructions but select Production from the Push Mode dropdown menu. You can use the same certificate (.p12) if your production build uses the same App ID/Bundle ID as your development build.
3. Create a distribution provisioning profile. Follow the instructions for creating Ad Hoc provisioning profiles. Ad Hoc builds are just like App Store builds except that you can only install them on a limited set of predetermined devices. Both types of builds will use Apple's Production Push environment.
4. Generate a distribution build of your app and install it on a connected test device. If you have logging enabled at this point, you should see messages indicating that the Localytics SDK obtained your push token and should see the push token present in the push (not dpush) field of the next upload body.
5. Send yourself a test push message using the same instructions as before.
6. Complete all of the same steps above except select App Store as the provisioning profile type. If you are using multiple Localytics app keys, e.g. one for development and one for production, make sure to upload your production push certificate to your production app key.

1. Include a list of inbox messages

You have 2 options for adding a list of inbox messages to your app:

1. Using LLInboxViewController, which is the recommended and simplest approach.
2. Getting inbox campaigns from the Localytics class methods and displaying them in your own UIViewController.

Using LLInboxViewController (recommended)

LLInboxViewController can be added to your app using a storyboard or by initializing a new instance programmatically.

To add LLInboxViewController to an existing storyboard:

1. Drag a new UIViewController object into the storyboard canvas and embed it in a UINavigationController.
2. Select the new UIViewController, open the Identity inspector, and set the class name to LLInboxViewController.

To programmatically add LLInboxViewController, create a new instance and push it onto a UINavigationController stack as follows.

Objective-C Swift

- (void)displayInbox {
    LLInboxViewController *inboxViewController = [[LLInboxViewController alloc] init];
    [self.navigationController pushViewController:inboxViewController
                                         animated:YES];
}

func displayInbox() {
  let inboxViewController = LLInboxViewController()
  self.navigationController?.pushViewController(inboxViewController, animated: true)
}

If you prefer to present LLInboxViewController modally, include it within a UINavigationController as follows.

Objective-C Swift

- (void)displayInbox {
    LLInboxViewController *inboxViewController = [[LLInboxViewController alloc] init];
    UINavigationController *navigationController = [[UINavigationController alloc] initWithRootViewController:inboxViewController];
    [self presentViewController:navigationController
                       animated:YES
                     completion:nil];
}

func displayInbox() {
  let inboxViewController = LLInboxViewController()
  let navigationController = UINavigationController(rootViewController: inboxViewController)
  present(navigationController, animated: true, completion: nil)
}

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSArray<LLInboxCampaign *> *inboxCampaigns = [Localytics inboxCampaigns];
});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
  let inboxCampaigns = Localytics.inboxCampaigns()
}

[Localytics refreshInboxCampaigns:^(NSArray<LLInboxCampaign *> *inboxCampaigns) {
    // refresh UI using inboxCampaigns
}];

Localytics.refreshInboxCampaigns { (inboxCampaigns) in
  // refresh UI using inboxCampaigns
}

2. Display a detail inbox message view

You must use LLInboxDetailViewController to display a detail inbox message view. When using LLInboxViewController the default behavior will automatically mark the inbox message as read and create an LLInboxDetailViewController and push it onto the navigation stack. If you are not using LLInboxViewController, you can get an instance from the Localytics class as follows.

Objective-C Swift

LLInboxCampaign *campaign = /* campaign from [Localytics inboxCampaigns] */;
LLInboxDetailViewController *inboxDetailViewController = [Localytics inboxDetailViewControllerForCampaign:campaign];

let campaign = /* campaign from Localytics.inboxCampaigns() */
let inboxDetailViewController = Localytics.inboxDetailViewController(for: campaign)

3. Customize the appearance and behavior

To match the look and feel of your app, there are several customization options available for App Inbox.

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
    if ([segue.identifier isEqualToString:@"inbox_list"]) {
        LLInboxViewController *inboxViewController = (LLInboxViewController *) segue.destinationViewController;
        inboxViewController.textLabelColor = [UIColor redColor];
        inboxViewController.textLabelFont = [UIFont boldSystemFontOfSize:24.0f];
        inboxViewController.detailTextLabelColor = [UIColor greenColor];
        inboxViewController.detailTextLabelFont = [UIFont boldSystemFontOfSize:16.0f];
        inboxViewController.timeTextLabelColor = [UIColor blueColor];
        inboxViewController.timeTextLabelFont = [UIFont systemFontOfSize:12.0f];
        inboxViewController.unreadIndicatorColor = [UIColor yellowColor];
        inboxViewController.cellBackgroundColor = [UIColor whiteColor];
    }
}

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if segue.identifier == "inbox_list" {
        let inboxViewController = segue.destination as! LLInboxViewController
        inboxViewController.textLabelColor = .red
        inboxViewController.textLabelFont = .boldSystemFont(ofSize: 24)
        inboxViewController.detailTextLabelColor = .green
        inboxViewController.detailTextLabelFont = .boldSystemFont(ofSize: 16)
        inboxViewController.timeTextLabelColor = .blue
        inboxViewController.timeTextLabelFont = .boldSystemFont(ofSize: 12)
        inboxViewController.unreadIndicatorColor = .yellow
        inboxViewController.cellBackgroundColor = .white
    }
}

- (void)displayInbox {
    LLInboxViewController *inboxViewController = [[LLInboxViewController alloc] init];
    inboxViewController.textLabelColor = [UIColor redColor];
    inboxViewController.textLabelFont = [UIFont boldSystemFontOfSize:24.0f];
    inboxViewController.detailTextLabelColor = [UIColor greenColor];
    inboxViewController.detailTextLabelFont = [UIFont boldSystemFontOfSize:16.0f];
    inboxViewController.timeTextLabelColor = [UIColor blueColor];
    inboxViewController.timeTextLabelFont = [UIFont systemFontOfSize:12.0f];
    inboxViewController.unreadIndicatorColor = [UIColor yellowColor];
    inboxViewController.cellBackgroundColor = [UIColor whiteColor];
    [self.navigationController pushViewController:inboxViewController
                                         animated:YES];
}

func displayInbox() {
  let inboxViewController = LLInboxViewController()
  inboxViewController.textLabelColor = .red
  inboxViewController.textLabelFont = .boldSystemFont(ofSize: 24)
  inboxViewController.detailTextLabelColor = .green
  inboxViewController.detailTextLabelFont = .boldSystemFont(ofSize: 16)
  inboxViewController.timeTextLabelColor = .blue
  inboxViewController.timeTextLabelFont = .boldSystemFont(ofSize: 12)
  inboxViewController.unreadIndicatorColor = .yellow
  inboxViewController.cellBackgroundColor = .white
  self.navigationController?.pushViewController(inboxViewController, animated: true)
}

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    LLInboxCampaign *campaign = [self campaignForRowAtIndexPath:indexPath];
    if (campaign.hasCreative) {
        LLInboxDetailViewController *detailViewController = [Localytics inboxDetailViewControllerForCampaign:campaign];
        UINavigationController *navigationController = [[UINavigationController alloc] initWithRootViewController:detailViewController];
        [self presentViewController:navigationController
                           animated:YES
                         completion:nil];
    } else {
        [Localytics inboxListItemTapped:campaign];
    }

    [tableView deselectRowAtIndexPath:indexPath animated:YES];

    if (!campaign.isRead) {
        // Set campaign as read and reload to refresh unread indicators
        campaign.read = YES;
        [tableView reloadData];
    }
}

override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    let campaign = campaignForRow(at: indexPath)!
    if campaign.hasCreative {
        let detailViewController = Localytics.inboxDetailViewController(for: campaign)
        let navigationController = UINavigationController(rootViewController: detailViewController)
        present(navigationController, animated: true, completion: nil)
    } else {
        Localytics.inboxListItemTapped(campaign: campaign);
    }

    tableView.deselectRow(at: indexPath, animated: true)

    if !campaign.isRead {
        // Set campaign as read and reload to refresh unread indicators
        campaign.isRead = true
        tableView.reloadData()
    }
}

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
    if ([segue.identifier isEqualToString:@"inbox_list"]) {
        LLInboxViewController *inboxViewController = (LLInboxViewController *) segue.destinationViewController;
        inboxViewController.showsActivityIndicatorView = YES;
    }
}

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if segue.identifier == "inbox_list" {
        let inboxViewController = segue.destination as! LLInboxViewController
        inboxViewController.showsActivityIndicatorView = true
    }
}

- (void)displayInbox {
    LLInboxViewController *inboxViewController = [[LLInboxViewController alloc] init];
    inboxViewController.showsActivityIndicatorView = YES;
    [self.navigationController pushViewController:inboxViewController
                                         animated:YES];
}

func displayInbox() {
  let inboxViewController = LLInboxViewController()
  inboxViewController.showsActivityIndicatorView = true
  self.navigationController?.pushViewController(inboxViewController, animated: true)
}

- (void)localyticsDidBeginRefreshingInboxCampaigns {
    // show a loading indicator
}

- (void)localyticsDidFinishRefreshingInboxCampaigns {
    // hide a loading indicator
}

override func localyticsDidBeginRefreshingInboxCampaigns() {
    // show a loading indicator
}

override func localyticsDidFinishRefreshingInboxCampaigns() {
    // hide a loading indicator
}

- (UIView *)createEmptyView {
    UIView *emptyView = [UIView new];
    emptyView.translatesAutoresizingMaskIntoConstraints = NO;
    emptyView.backgroundColor = [UIColor whiteColor];

    UIImage *emptyImage = [UIImage imageNamed:@"empty_inbox"];
    UIImageView *emptyImageView = [[UIImageView alloc] initWithImage:emptyImage];
    emptyImageView.translatesAutoresizingMaskIntoConstraints = NO;

    [emptyView addSubview:emptyImageView];
    [emptyView addConstraint:[NSLayoutConstraint constraintWithItem:emptyImageView
                                                          attribute:NSLayoutAttributeCenterX
                                                          relatedBy:NSLayoutRelationEqual
                                                             toItem:emptyView
                                                          attribute:NSLayoutAttributeCenterX
                                                         multiplier:1.0f
                                                           constant:0.0f]];
    [emptyView addConstraint:[NSLayoutConstraint constraintWithItem:emptyImageView
                                                          attribute:NSLayoutAttributeCenterY
                                                          relatedBy:NSLayoutRelationEqual
                                                             toItem:emptyView
                                                          attribute:NSLayoutAttributeCenterY
                                                         multiplier:1.0f
                                                           constant:0.0f]];
    return emptyView;
}

func createEmptyView() -> UIView {
    let emptyView = UIView()
    emptyView.translatesAutoresizingMaskIntoConstraints = false
    emptyView.backgroundColor = .white

    let emptyImage = UIImage(named: "empty_inbox")
    let emptyImageView = UIImageView(image: emptyImage)
    emptyImageView.translatesAutoresizingMaskIntoConstraints = false

    emptyView.addSubview(emptyImageView)
    emptyView.addConstraint(NSLayoutConstraint(
        item: emptyImageView,
        attribute: .centerX,
        relatedBy: .equal,
        toItem: emptyView,
        attribute: .centerX,
        multiplier: 1,
        constant: 0))
    emptyView.addConstraint(NSLayoutConstraint(
        item: emptyImageView,
        attribute: .centerY,
        relatedBy: .equal,
        toItem: emptyView,
        attribute: .centerY,
        multiplier: 1,
        constant: 0))

    return emptyView
}

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
    if ([segue.identifier isEqualToString:@"inbox_list"]) {
        LLInboxViewController *inboxViewController = (LLInboxViewController *) segue.destinationViewController;
        inboxViewController.emptyCampaignsView = [self createEmptyView];
    }
}

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if segue.identifier == "inbox_list" {
        let inboxViewController = segue.destination as! LLInboxViewController
        inboxViewController.emptyCampaignsView = createEmptyView()
    }
}

- (void)displayInbox {
    LLInboxViewController *inboxViewController = [[LLInboxViewController alloc] init];
    inboxViewController.emptyCampaignsView = [self createEmptyView];
    [self.navigationController pushViewController:inboxViewController
                                         animated:YES];
}

func displayInbox() {
  let inboxViewController = LLInboxViewController()
  inboxViewController.emptyCampaignsView = createEmptyView()
  self.navigationController?.pushViewController(inboxViewController, animated: true)
}

- (void)viewDidLoad {
    [super viewDidLoad];

    self.downloadsThumbnails = NO;
    [self.tableView registerClass:[UITableViewCell class]
           forCellReuseIdentifier:@"reuseIdentifier"];
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    LLInboxCampaign *campaign = [self campaignForRowAtIndexPath:indexPath];
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"reuseIdentifier"];

    /* create and populate cell with campaign data */

    return cell;
}

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
    return 44.0f;
}

override func viewDidLoad() {
  super.viewDidLoad()

  self.downloadsThumbnails = false
  self.tableView.register(UITableViewCell.self, forCellReuseIdentifier: "reuseIdentifier")
}

override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
  let campaign = campaignForRow(at: indexPath)!
  let cell = tableView.dequeueReusableCell(withIdentifier: "reuseIdentifier")

  /* create and populate cell with campaign data */

  return cell!
}

override func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
  return 44
}

- (UIView *)createErrorView {
    UIView *errorView = [UIView new];
    errorView.translatesAutoresizingMaskIntoConstraints = NO;
    errorView.backgroundColor = [UIColor blackColor];

    UILabel *errorLabel = [UILabel new];
    errorLabel.translatesAutoresizingMaskIntoConstraints = NO;
    errorLabel.textColor = [UIColor whiteColor];
    errorLabel.font = [UIFont boldSystemFontOfSize:30];
    errorLabel.text = @"Error";

    [errorView addSubview:errorLabel];
    [errorView addConstraint:[NSLayoutConstraint constraintWithItem:errorLabel
                                                          attribute:NSLayoutAttributeCenterX
                                                          relatedBy:NSLayoutRelationEqual
                                                             toItem:errorView
                                                          attribute:NSLayoutAttributeCenterX
                                                         multiplier:1.0f
                                                           constant:0.0f]];
    [errorView addConstraint:[NSLayoutConstraint constraintWithItem:errorLabel
                                                          attribute:NSLayoutAttributeCenterY
                                                          relatedBy:NSLayoutRelationEqual
                                                             toItem:errorView
                                                          attribute:NSLayoutAttributeCenterY
                                                         multiplier:1.0f
                                                           constant:0.0f]];
    return errorView;
}

func createErrorView() -> UIView {
    let errorView = UIView()
    errorView.translatesAutoresizingMaskIntoConstraints = false
    errorView.backgroundColor = .black

    let errorLabel = UILabel()
    errorLabel.translatesAutoresizingMaskIntoConstraints = false
    errorLabel.textColor = .white
    errorLabel.font = .boldSystemFont(ofSize: 30)
    errorLabel.text = "Error"

    errorView.addSubview(errorLabel)
    errorView.addConstraint(NSLayoutConstraint(
        item: errorLabel,
        attribute: .centerX,
        relatedBy: .equal,
        toItem: errorView,
        attribute: .centerX,
        multiplier: 1,
        constant: 0))
    errorView.addConstraint(NSLayoutConstraint(
        item: errorLabel,
        attribute: .centerY,
        relatedBy: .equal,
        toItem: errorView,
        attribute: .centerY,
        multiplier: 1,
        constant: 0))

    return errorView
}

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
    if ([segue.identifier isEqualToString:@"inbox_list"]) {
        LLInboxViewController *inboxViewController = (LLInboxViewController *) segue.destinationViewController;
        inboxViewController.creativeLoadErrorView = [self createErrorView];
    }
}

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if segue.identifier == "inbox_list" {
        let inboxViewController = segue.destination as! LLInboxViewController
        inboxViewController.creativeLoadErrorView = createErrorView()
    }
}

- (void)displayInbox {
    LLInboxViewController *inboxViewController = [[LLInboxViewController alloc] init];
    inboxViewController.creativeLoadErrorView = [self createErrorView];
    [self.navigationController pushViewController:inboxViewController
                                         animated:YES];
}

func displayInbox() {
  let inboxViewController = LLInboxViewController()
  inboxViewController.creativeLoadErrorView = createErrorView()
  self.navigationController?.pushViewController(inboxViewController, animated: true)
}

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    LLInboxCampaign *campaign = [self campaignForRowAtIndexPath:indexPath];
    if (campaign.hasCreative) {
        LLInboxDetailViewController *detailViewController = [Localytics inboxDetailViewControllerForCampaign:campaign];
        detailViewController.creativeLoadErrorView = [self createErrorView];
        [self.navigationController pushViewController:detailViewController animated:YES];
    }

    [tableView deselectRowAtIndexPath:indexPath animated:YES];

    if (!campaign.isRead) {
        // Set campaign as read and reload to refresh unread indicators
        campaign.read = YES;
        [tableView reloadData];
    }
}

override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    let campaign = campaignForRow(at: indexPath)!
    if campaign.hasCreative {
        let detailViewController = Localytics.inboxDetailViewController(for: campaign)
        detailViewController.creativeLoadErrorView = createErrorView()
        self.navigationController?.pushViewController(detailViewController, animated: true)
    }

    tableView.deselectRow(at: indexPath, animated: true)

    if !campaign.isRead {
        // Set campaign as read and reload to refresh unread indicators
        campaign.isRead = true
        tableView.reloadData()
    }
}

[Localytics deleteInboxCampaign:campaign];
[((LLInboxCampaign *) campaign) delete];

Localytics.deleteInboxCampaign(campaign)
((LLInboxCampaign *) campaign).delete()

- (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
    if ([segue.identifier isEqualToString:@"inbox_list"]) {
        LLInboxViewController *inboxViewController = (LLInboxViewController *) segue.destinationViewController;
        inboxViewController.enableDetailViewDelete = YES;
        inboxViewController.enableSwipeDelete = YES;
    }
}

override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if segue.identifier == "inbox_list" {
        let inboxViewController = segue.destination as! LLInboxViewController
        inboxViewController.enableDetailViewDelete = YES;
        inboxViewController.enableSwipeDelete = YES;
    }
}

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    LLInboxCampaign *campaign = self.tableData[indexPath.row];
    if (campaign.hasCreative) {
        LLInboxDetailViewController *controller = [Localytics inboxDetailViewControllerForCampaign:campaign];
        controller.deleteInNavBar = self.enableDetailViewDelete;
        [self.navigationController pushViewController:controller animated:YES];
    } else {
        [Localytics inboxListItemTapped:campaign];
    }
    ...
}