Notifications

Configure push notifications via Helpshift

Notifications can be sent to your users when you reply to an issue submitted by them. In addition to the expected Push Notification behavior on iOS, you can customize your notifications to display a numbered badge on your App icon or play a sound alert when a notification is received.

If your app does not already use push, you will need to enable push for your app. To enable push notification in your application you need to add APNS registration code to your AppDelegate's application:didFinishLaunchingWithOptions: method:

- (BOOL) application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    ...
    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
    center.delegate = self;
    [center requestAuthorizationWithOptions:(UNAuthorizationOptionBadge | UNAuthorizationOptionSound | UNAuthorizationOptionAlert)
                                                                    completionHandler:^(BOOL granted, NSError *_Nullable error) {
                            ...
                        }];
    [UIApplication sharedApplication registerForRemoteNotifications];
    ...
}

- (BOOL) application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
...
if([[[UIDevice currentDevice] systemVersion] floatValue] >= 8.0) {
    UIUserNotificationType notificationType = UIUserNotificationTypeBadge | UIUserNotificationTypeAlert;
    UIUserNotificationSettings *notificationSettings = [UIUserNotificationSettings settingsForTypes:notificationType categories:nil];
    [[UIApplication sharedApplication] registerUserNotificationSettings:notificationSettings];
    [[UIApplication sharedApplication] registerForRemoteNotifications];

} else {
    [[UIApplication sharedApplication] registerForRemoteNotificationTypes:(UIRemoteNotificationTypeAlert | UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeSound)];
}
...
}

Configure Helpshift's push notification service in the Helpshift admin interface

You can configure this in 4 simple steps:

Setup your application with Apple and enable Push notifications.

You need to generate certificates for APNS on Apple's portal that you can later provide to Helpshift. This lets Helpshift send push notifications to your users. Apple has moved away from old type of certificates to Apple Push Notification service SSL. There is another option to create Apple Push Notification Authentication Key, but Helpshift does not support this option yet. Its also possible that you still have the old type of certificate that has not yet expired, this is also supported by Helpshift.

Apple provides two variations of Apple Push Notification service SSL

• Apple Push Notification service SSL (Sandbox)
• Apple Push Notification service SSL (Sandbox & Production)

After creating your certificate, download it. Double click on it to import it to the Keychain Access Application. In the Keychain Access Application, right click on the certificate that was just added, and click export it in .p12 format. Please provide a password while exporting the certificate since we do not accept empty passwords. (Note that if your development private key is not present in Keychain Access, you will not be able to export it in .p12 format.)

To enable the Helpshift system to send push notifications to your users you will have to add iOS as a platform in your app (if you have not added already). And then click on the push notifications option.

After export, login and upload the .p12 file in your app in the Helpshift admin panel. Provide the same password you used while exporting to .p12 format.

Please note that you need to use the same bundle identifier in the app as the one you used to create the APNS certificate.

You can configure whether to send a badge or not, and sound alerts if you provided custom sounds bundled with your app to handle notifications. Save it and you're all set.

Development (Sandbox) mode vs. Production mode

When you build and run your app from Xcode, it is in development (Sandbox) mode. To test push notifications from Helpshift in this mode make sure you choose 'Development Mode' while uploading either of the above two certificate types.

When you publish your app and download from App Store, your app is in Production mode. To test push notifications from Helpshift in production mode make sure you choose 'Production Mode' while uploading a certificate of 'Apple Push Notification service SSL (Sandbox & Production)' type. Sandbox mode certificate will not work on a production environment.

We do not support using the same certificate for both sandbox and production apps. In these cases we recommend you create two separate apps on our dashboard, one in 'Production mode' and the other in 'Development mode'. While testing please use the credentials of the developement mode app. When you are ready to publish, please replace the credentials with those of the production level app.

Configure the Helpshift iOS SDK to handle notifications

For Helpshift SDK to work with the Helpshift push notification service you will need to invoke the registerDeviceToken: api call inside the application delegate method application:didRegisterForRemoteNotificationsWithDeviceToken:

In your app delegate file it will look something like this:

- (void) application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
    [Helpshift registerDeviceToken:deviceToken];
}

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    Helpshift.registerDeviceToken(deviceToken)
}

If your app uses UNNotification framework

To respond to the delivery of notifications, you must implement a delegate for the shared UNUserNotificationCenter object. Your delegate object must conform to the UNUserNotificationCenterDelegate protocol, which the notification center uses to deliver notification information to your app:

1. If a notification arrives while your app is in the foreground, UNUserNotificationCenterDelegate's willPresentNotification: is called.
2. The system does not call the userNotificationCenter:willPresentNotification:withCompletionHandler: method when your app is in the background or is not running. In those cases, the system alerts the user according to the information in the notification itself. When the user selects an action from the notification interface, the system notifies your app of the user's choice. To receive responses, your delegate object must implement the userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler: method.

In all of the above cases, you should check the "origin" field of the notification dictionary and call handleNotificationWithUserInfoDictionary:isAppLaunch:withController: API if the origin of the notification is "helpshift". The Helpshift SDK will check Issues for which the notifications were received and will launch the Conversation screen for those Issues automatically. The isAppLaunch boolean flag here is used to distinguish between an active or backgrounded app vs. an app that was killed by the user. In the latter case, this flag should be set to true.

Example usage:

For the userNotificationCenter:willPresentNotification:withCompletionHandler: delegate -

- (void) userNotificationCenter:(UNUserNotificationCenter *)center
  willPresentNotification:(UNNotification *)notification
  withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler {
  if([[notification.request.content.userInfo objectForKey:@"origin"] isEqualToString:@"helpshift"]) {
    [Helpshift handleNotificationWithUserInfoDictionary:notification.request.content.userInfo
                                                isAppLaunch:false
                                             withController:self.window.rootViewController];
  }
  completionHandler(...);
}

func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    if notification.request.content.userInfo["origin"] as? String == "helpshift" {
        Helpshift.handleNotification(withUserInfoDictionary: notification.request.content.userInfo, isAppLaunch: false, with: rootViewController)
    }
}

For the userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler: delegate -

  -(void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler {
    if([[response.notification.request.content.userInfo objectForKey:@"origin"] isEqualToString:@"helpshift"]) {
        [Helpshift handleNotificationWithUserInfoDictionary:response.notification.request.content.userInfo
                                                isAppLaunch:false
                                             withController:rootViewController];
    };
}

     func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        if response.notification.request.content.userInfo["origin"]  as? String == "helpshift" {
            Helpshift.handleNotification(
                withUserInfoDictionary:response.notification.request.content.userInfo,
                isAppLaunch:false,
                with:rootViewController)
        }
    }

If your app uses UINotification framework (Deprecated)

When a push notification is received, the application delegate didReceiveRemoteNotification: is called. Additionally:

1. If the application was not in the foreground, and the user taps the push notification, this method is called again.
2. In cases where the app might have been killed by the user, and then they tap on a push notification, the application's didFinishLaunchingWithOptions: delegate is called.

In all of the above cases, developers should check the origin field of the notification dictionary and call handleNotificationWithUserInfoDictionary:isAppLaunch API if the origin of the notification is "Helpshift". The Helpshift SDK will check Issues for which the notifications were received and will launch the Conversation screen for those Issues automatically. The isAppLaunch boolean flag here is used to distinguish between an active or backgrounded app vs. an app that was killed by the user. In the latter case, this flag should be set to true.

Example usage:

When receiving remote notifications when the app starts for the first time, or after being killed by the user:

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    ...
    if(launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey]) {
        NSDictionary *userInfo = launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey];
        if([[userInfo objectForKey:@"origin"] isEqualToString:@"helpshift"]) {
            [Helpshift handleNotificationWithUserInfoDictionary:notification.request.content.userInfo
                                                isAppLaunch:YES
                                             withController:self.window.rootViewController];
        }
    }
    ...
}

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    if let launchOptions = launchOptions, let userInfo = launchOptions[UIApplication.LaunchOptionsKey.remoteNotification] as? NSDictionary  {
            let origin = userInfo["origin"] as? String
            if origin == "helpshift" {
                Helpshift.handleNotification(withUserInfoDictionary: userInfo, isAppLaunch: true, with: rootViewController)
            }
    }   
    return true
}

For the didReceiveRemoteNotification delegate -

- (void) application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo {
    if([[userInfo objectForKey:@"origin"] isEqualToString:@"helpshift"]) {
        [Helpshift handleNotificationWithUserInfoDictionary:notification.request.content.userInfo
                                                isAppLaunch:YES
                                             withController:self.window.rootViewController];
    }
}

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    if userInfo["origin"] as? String ==  "helpshift" {
        Helpshift.handleNotification(withUserInfoDictionary: userInfo, isAppLaunch: true, with: rootViewController)
        }
    }

Badge count

If you need to handle badge reset in the application icon, you can do something like below in the applicationDidBecomeActive: delegate method:

- (void)applicationDidBecomeActive:(UIApplication *)application
{
    [[UIApplication sharedApplication] setApplicationIconBadgeNumber:0];
}

In-app notifications

In-app notifications are similar to Apple's push notification banners. Unlike push notifications, they appear within your app when it is in use by the user.

These notifications are sent when an agent replies to a customer's issue. Your customers can click on these banners to go straight into the conversation screen.

Configuring In-app notifications

The Helpshift install call supports flags for configuring SDK behaviour. Currently we support one flag i.e enableInAppNotification.

Enabling/Disabling In-app notifications

If you do not want the in-app notifications support provided by the Helpshift SDK, please set this flag to NO. The default value of this flag is YES i.e in-app notifications will be enabled.
Read more about in-app notifications in the Notifications section.

Example:

[Helpshift installWithPlatformId:@"YOUR_PLATFORM_ID" 
                          domain:(NSString *)domain
                          config:@"YOUR_DOMAIN" config:config];

let config = ["enableInAppNotification" : true]
Helpshift.install(withPlatformId: "YOUR_PLATFORM_ID", domain: "YOUR_DOMAIN", config: config)

Pausing In-app notifications

If you have enabled in-app notifications, use the API [pauseDisplayOfInAppNotification: to pause/resume the notifications. When YES is passed to this method display of in-app notifications is paused even if they arrive. When you pass a NO, the in-app notifications start displaying.

Example:

[Helpshift pauseDisplayOfInAppNotification:YES]; // To temporarily pause in-app notifications
[Helpshift pauseDisplayOfInAppNotification:NO]; // To resume showing the in-app notifications

Helpshift.pauseDisplayOf(inAppNotification: true) // To temporarily pause in-app notifications
Helpshift.pauseDisplayOf(inAppNotification: false) // To resume showing the in-app notifications

Notification badges

If you want to show your user notifications for replies you send to the issues they posted, you can use notification counts provided by Helpshift SDK that gives you the total number of unread messages and display it as a badge. You can get notification counts asynchronously by implementing the HelpshiftDelegate in your respective .h and .m files. Notifications are typically displayed as badges inside your app where a user invokes the help section. These badges can be displayed anywhere in your app's interface to tell the user that they have unread replies/messages from you. For example to display a badge on a view (lets say its called yourView which can set its textLabel) while you are polling for notifications using:

[Helpshift requestUnreadMessageCount:YES];

You can implement something like the following in the notification count delegate method:

- (void) handleHelpshiftEvent:(NSString *)eventName withData:(NSDictionary *)data {
    ...
    if([eventName isEqualToString:HelpshiftEventNameReceivedUnreadMessageCount]) {
        int count = [data[HelpshiftEventDataUnreadMessageCount] intValue];
        BOOL fromCache = [data[HelpshiftEventDataUnreadMessageCountIsFromCache] boolValue];
        NSLog(@"Unread count: %d", count);
        NSLog(@"Is unreadCount served from local cache : %d", fromCache);

        dispatch_async(dispatch_get_main_queue(), ^{
            [yourView setTextLabel:[NSString stringWithFormat:@"%d",count];
        });
    }
}

func handleHelpshiftEvent(_ eventName: String, withData data: [AnyHashable : Any]?) {
    if eventName == HelpshiftEventNameReceivedUnreadMessageCount {
        guard let data = data else { return }
        let count = data[HelpshiftEventDataUnreadMessageCount] as? Int
        let isFromCache = data[HelpshiftEventDataUnreadMessageCountIsFromCache] as? Bool
        print("Count: \(count), fromCache: \(isFromCache)")

        DispatchQueue.main.async {
            yourLabel.text = "\(count)"   
        }
    }
}

Similarly for a UITabBarItem in the notification count delegate method you can implement something like:

- (void) handleHelpshiftEvent:(NSString *)eventName withData:(NSDictionary *)data {
    ...
    if([eventName isEqualToString:HelpshiftEventNameReceivedUnreadMessageCount]) {
        int count = [data[HelpshiftEventDataUnreadMessageCount] intValue];
        BOOL fromCache = [data[HelpshiftEventDataUnreadMessageCountIsFromCache] boolValue];
        NSLog(@"Unread count: %d", count);
        NSLog(@"Is unreadCount served from local cache : %d", fromCache);

        dispatch_async(dispatch_get_main_queue(), ^{
            tabBarItem.badgeValue = [NSString stringWithFormat:@"%d",count];
        });
    }
}

func handleHelpshiftEvent(_ eventName: String, withData data: [AnyHashable : Any]?) {
    if eventName == HelpshiftEventNameReceivedUnreadMessageCount {
        guard let data = data else { return }
        let count = data[HelpshiftEventDataUnreadMessageCount] as? Int
        let isFromCache = data[HelpshiftEventDataUnreadMessageCountIsFromCache] as? Bool
        print("Count: \(count), fromCache: \(isFromCache)")

        DispatchQueue.main.async {
            tabBarItem.badgeValue = "\(count)"   
        }
    }
}

These will update your view or UITabBarItem whenever a new notification arrives in the delegate method. The situation can vary depending upon your app UI. Showing notification counts at appropriate places would help you draw in your users so that you can engage them more in conversations and hence solve their problems better. To display the notification count of unread messages stored locally to your users, you can call requestUnreadMessageCount:

[Helpshift requestUnreadMessageCount:NO]

Helpshift.requestUnreadMessageCount(false)

to retrieve the unread messages count stored locally and display the unread count similar to mentioned in the above examples.