So you've explored the demo, tested the companion app and have now decided to integrate Kumulos into your app - great! This guide will walk you through everything you need to do and they key considerations while doing this. This should only take you a few hours per platform.

Integrate Kumulos into your app

Before you begin, don't forget to invite any other developers to your Kumulos account who will be working on this with you.

To get started, create a client and then add an app. Kumulos groups your apps under clients, usually the name of the company you are building the app for. This helps keep the console organized and, if you enable the Client Portal, allows your clients to be given read-only access to the analytics and reports for their apps. You can also share files and links with them.

Click the Start button next to Analytics

Select Start

Click Get Started and you will be asked to confirm that you wish to begin a 30 day free trial.

Get Started

Click Yes, proceed when prompted.

Confirm start trial

Add the SDK

Kumulos has a number of mobile SDKs. All of our SDKs are hosted on GitHub and can be added to your project using the appropriate package manager for that language. For example: Carthage or CocoaPods for Objective-C and Swift, JCenter for Android and NPM for React Native. To add the SDK to your project, please see the appropriate README on GitHub:

Initialize SDK

To initialize the SDK, you will need your app's API Key and Secret Key. Click on the app in your console and you will see this at the bottom of the dashboard.

App Keys

Use these credentials to initialize the SDK early in your application startup as shown in the integration guide for each SDK. For example: for Swift...

import UIKit
import KumulosSDK

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

  var window: UIWindow?

  func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

    let builder = KSConfigBuilder(apiKey: "your-api-key", secretKey: "your-secret-key")
    Kumulos.initialize(config: builder.build())

    // Override point for customization after application launch.
    return true
  }
}

When you now run your app on a simulator or install your app on a device, Anayltics data will be sent to Kumulos. To check that the SDK has been initialized correctly, click on the Installs tab. This shows the ten most recent installs of your app (platform, device model and installation id).

Recent installs

Click on any install to see more information. The Overview tab shows more details about the installation including app version, when the app was installed, the approximate location (to help identify test devices and installs) and the locale being used.

Install overview

Enable Crash Reporting

Crash Reporting allows you to track unhandled exceptions in your app, and optionally log any caught exceptions for further investigation. Crash reporting is not enabled by default. Click the Start button next to Diagnostics on the App Dashboard.

Start using diagnostics

Click Get Started and you will be asked to confirm that you wish to begin a 30 day free trial. Click Yes, proceed when prompted. Your 30 day trial of Crash Reporting & Diagnostics will now begin. Now, simply modify your Kumulos initialization to include enabling crash reporting as shown in the integration guide for each SDK. For example: for Swift...

let builder = KSConfigBuilder(apiKey: "your-api-key", secretKey: "your-secret-key").enableCrash()
Kumulos.initialize(config: builder.build())

Unhandled exceptions that lead to crashes will now be recorded automatically and shown in your App Delivery Console.

If your app relies on any other APIs or services to function, add API Endpoint Monitoring checks to test are all the API Endpoints reachable? Returning the correct response code? Returning data to your app in the expected format? And how long do they take to do this? Monitoring checks will alert you to any problems before they impact your audience.

Register for Push Notifications

Push Notifications are an effective way to keep users engaged with an app. Click the Start button next to Push on the App Dashboard.

Start using push

Click Get Started and you will be asked to confirm that you wish to begin a 30 day free trial. Click Yes, proceed when prompted. Your 30 day trial of Push Notifications will now begin.

Configure Platforms

In order to send push notifications to iOS and/or Android devices you must configure the Apple Push Notification Service (APNS) and/or Firebase Cloud Messaging (FCM) and upload your push certificate to Kumulos.

APNS Configuration

In order to send push notifications to iOS devices with Kumulos, you'll need to create certificates in the Apple Developer Member Center. The steps to complete this are shown in the video guide.

Configuring APNS for iOS with Kumulos

FCM Configuration

In order to enable push notifications for Android with Kumulos, you'll need to set up an FCM project and configure push for your app. These steps are shown in the following video guide.

Enabling Push Notifications for Android

Upload to Kumulos

Now, in Kumulos, click CONFIGURE NOW or the cog icon next to the platform you would like to configure. This will open the platform configuration dialog where you can enter the required information to send push notifications to iOS devices via APNS and/or Android devices via FCM.

Configure Push Dashboard

Request Device Token

The Kumulos SDKs provide helper methods to request a device token from the OS. For example: for Swift...

Kumulos.pushRequestDeviceToken()

When adding Kumulos to an existing app, we suggest calling pushRequestDeviceToken as soon as the app is opened for the first time after update.

Send Token to Kumulos

Now send the returned device token to Kumulos using the helper shown in the integration guide for each SDK. For example: for Swift...

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    Kumulos.pushRegister(deviceToken)
}

Track Open Rates

To correctly report on push open rates & conversions, you need to tell Kumulos that the app was launched by the remote notification. For example: for Swift...


import UIKit
import KumulosSDK
import UserNotifications

// Add the delegate protocol
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterDelegate {

    var window: UIWindow?

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
        // Set up the delegate (for iOS10)
        UNUserNotificationCenter.current().delegate = self;

        return true
    }

    ...

    // iOS10
    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        completionHandler([])
    }

    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        let userInfo = response.notification.request.content.userInfo;
        Kumulos.pushTrackOpen(notification: userInfo)
        completionHandler()
    }

}

Please see the integration guide for each SDK for further details customizing push launch behaviour, opening URLs and handling background data.

Send Location Updates

If you want to use the geotargeting features of Kumulos, then your app needs to send location updates to Kumulos.

How frequently you send location updates to Kumulos will depend on the specific use case of your app. You should consider both accuracy and battery life when making this decision. For most cases, using the Significant-Change service on iOS and the Fused Location Provider on Android will be sufficient.

For details of how to send location updates to Kumulos, see the integration guide for each SDK. As an example in Swift, once you have created a CLLocationManagerDelegate you can use the helper method in the Kumulos SDK to send location updates to Kumulos.

func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation])
{
  let latestLocation: CLLocation = locations[locations.count - 1]
  Kumulos.sendLocationUpdate(location: latestLocation)
}

Associate Users

If your app has user based authentication, then Kumulos allows associating an anonymized user identifier with the current installation ID (for example for targeting via Push API. You can optionally associate a collection of attributes with the user, which can be used to create audience segments. Each Kumulos SDK provides a helper method to associate users. For example: in Swift...

Kumulos.associateUserWithInstall(userIdentifier: "A12345", attributes: [
   "isCustomer": true as AnyObject,
   "startDate": "2019-06-01" as AnyObject
])

When adding Kumulos to an existing app, we suggest calling associateUserWithInstall when a new user signs up, an existing user logs in AND when the app is opened for the first time after update (for users who are already logged in to the app). As this method is idempotent, it may be simpler to just call this method every time the app is opened.

Track Analytics Events

Analytics events can be used as triggers to fire automation rules (e.g. to trigger a notification), as steps in a funnel to track conversion through key user journeys in your app or simply to answer questions on how the app is being used. For example: What is the most viewed screen? Which product category is most popular? How does this vary between customers and non-customers? Etc.

Explore events grouped by property and attribute

Each Kumulos SDK provides a helper method to track analytics events. For example: in Swift to track an event when someone purchase a product, including the product identifier as a property, use Kumulos.trackEvent as follows:

Kumulos.trackEvent(eventType: "product.purchased", properties: [
    "productId": 404
])

Event tracking is available offline as all events are persisted locally before being synced to the server in batches in the background.

A similar method trackEventImmediately will immediately start an event sync rather than waiting for the next time the app is backgrounded.

What analytics events you should track, will depend on the use case of the app. However, we would recommend tracking all steps through the first launch / onboarding flow including, any signup and user registration events. We would also recommend tracking any purchase or subscription events and an event for each screen in the app (so you can see how the app is being used).

Submit to Stores

You are now ready to submit your app or update to the stores for approval. Ensure you have added all of the features you are using to your Kumulos subscription first to avoid your app being rejected.

On the App Dashboard, click Buy next to any feature and you will be asked to confirm that you wish to add the feature to your subscription. At the same time, you can also add any other features currently being trialled by checking the appropriate box.

Add to subscription

Check all the features in use and click Proceed. If this is the first feature you have bought, you will need to create a billing subscription by adding payment card details.

Once the app has been approved, use App Store Optimization to:

  • Track where your app ranks in search results versus competitive apps
  • View volume, contention and ranking over time for different search terms
  • Compare your App Store listing and Google Play Store listing side-by-side
  • Compare your listing to that of competitive apps and top apps in category
  • View the most recent and also most helpful reviews

Keyword Ranking