Programmable Chat has been deprecated and is no longer supported. Instead, we'll be focusing on the next generation of chat: Twilio Conversations. Find out more about the EOL process here.
If you're starting a new project, please visit the Conversations Docs to begin. If you've already built on Programmable Chat, please visit our Migration Guide to learn about how to switch.
Push notifications are an important part of the mobile experience. Users have grown accustomed to having push notifications be a part of virtually every app that they use. The iOS Programmable Chat SDK is built to have push notifications integrated into it.
IMPORTANT: The default enabled flag for new Service instances for all Push Notifications is false
. This means that Push will be disabled until you explicitly enable it. To do so, please follow our Push Notification Configuration Guide.
Note: You will need to configure the sound
setting value for each push notification type you want the sound
payload parameter to present for, with required value. More information can be found in the above mentioned Push Notification Configuration Guide.
Managing your push credentials will be necessary, as your device token is required for the Chat SDK to be able to send any notifications through APNS. Let's go through the process of managing your push credentials.
The AppDelegate
class contains a series of application lifecycle methods. Many important events that occur like your app moving to the background or foreground have event listeners in this class.
When working with push notifications in your iOS application, it is quite likely you will find yourself needing to process push registrations or received events prior to the initialization of your Chat client. For this reason, we recommend you create a spot to store any registrations or push messages your application receives prior to the client being fully initialized. The best option here is to store these in a helper class to which your application delegate can obtain a reference. This way, your Chat client can process these values post-initialization if necessary or real-time otherwise. If you are doing a quick proof of concept, you could even define these on the application delegate itself but we recommend you refrain from doing this as storing state on the application delegate is not considered a best practice on iOS.
We will assume that you have defined the following properties in a way that makes them accessible to your application delegate method and Chat client initialization:
Your users can choose to authorize notifications or not - if they have authorized notifications, you can register the application for remote notifications from Twilio. Typically, you would do this in AppDelegate.swift
in the didFinishLaunchingWithOptions function.
1// For iOS 10 and later add this to the didFinishLaunchingWithOptions function or a similar place2// once you get granted permissions3if (@available(iOS 10.0, *)) {4UNUserNotificationCenter *currentNotificationCenter = [UNUserNotificationCenter currentNotificationCenter];5[currentNotificationCenter getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings *settings) {6if (settings.authorizationStatus == UNAuthorizationStatusAuthorized) {7[UIApplication.sharedApplication registerForRemoteNotifications];8}9}];10}1112// For iOS versions before 10 you should add such implementation13- (void)application:(UIApplication *)application didRegisterUserNotificationSettings:(UIUserNotificationSettings *)notificationSettings {14if(notificationSettings.types == UIUserNotificationTypeNone) {15NSLog(@"Failed to get token, error: Notifications are not allowed");16if (self.chatClient) {17[self.chatClient registerWithToken:nil];18} else {19self.updatedPushToken = nil;20}21} else {22[UIApplication.sharedApplication registerForRemoteNotifications];23}24}
After successfully registering for remote notifications, the Apple Push Notification Service (APNS) will send back a unique device token that identifies this app installation on this device. The Twilio Chat Client will take that device token (as a Data object), and pass it to Twilio's servers to use to send push notifications to this device.
1- (void)application:(UIApplication*)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData*)deviceToken {2if (self.chatClient && self.chatClient.user) {3[self.chatClient registerWithNotificationToken:deviceToken4completion:^(TCHResult *result) {5if (![result isSuccessful]) {6// try registration again or verify token7}8}];9} else {10self.updatedPushToken = deviceToken;11}12}1314- (void)application:(UIApplication*)application didFailToRegisterForRemoteNotificationsWithError:(NSError*)error {15NSLog(@"Failed to get token, error: %@", error);16self.updatedPushToken = nil;17}
We print an error if it fails, but if it succeeds, we either update the Chat client directly or save the token for later use.
Make sure you have created a push certificate on the Apple Developer Portal for your application first - for testing purposes, this should be a Sandbox certificate, but you will need a Production certificate for applications uploaded to the App Store.
We're going to need to export both a certificate and a private key from Keychain Access:
openssl pkcs12 -in cred.p12 -nokeys -out cert.pem -nodes
openssl pkcs12 -in cred.p12 -nocerts -out key.pem -nodes
The resulting file should contain "-----BEGIN RSA PRIVATE KEY-----". If the file contains "-----BEGIN PRIVATE KEY-----" and run the following command:
openssl rsa -in key.pem -out key.pem
Strip anything outside of "-----BEGIN RSA PRIVATE KEY-----" and "-----END RSA PRIVATE KEY-----" boundaries and upload your credentials into the Twilio Platform through the Console.
To store your Credential, visit your Chat Push Credentials Console and click on the Create a Push Credential
button. This console is located here:
Programmable Chat Push Credentials Console
The Credential SID for your new Credential is in the detail page labeled 'Credential SID.'
You should also ensure you add your credential SID to the Access Token Chat grant for iOS endpoints request tokens.
Each of the Twilio Helper Libraries makes provisions to add the push_credential_sid.
Please see the relevant documentation for your preferred Helper Library for details.
1var chatGrant = new ChatGrant({2serviceSid: ChatServiceSid,3pushCredentialSid: APNCredentialSid,4});
Nice! That's all we need to make sure the client has access to your device token.
You could keep your face buried in your phone all day waiting for your crush to send you a Chat message telling you that they're interested. Or you could turn on push notifications and go about your life, only getting notified once you receive their message. Sounds like a better option, right? Push notifications are supremely useful tools to keep users up to date with the status of their communication channels. Let's go through the process for integrating push notifications on iOS.
The AppDelegate
class contains a series of application lifecycle methods. Many important events that occur like your app moving to the background or foreground have event listeners in this class. One of those is the applicationDidFinishLaunchingWithOptions
method.
In this method, we're going to want to integrate push notifications for our app
1if (@available(iOS 10.0, *)) {2UNUserNotificationCenter *currentNotificationCenter = [UNUserNotificationCenter currentNotificationCenter];3[currentCenter requestAuthorizationWithOptions:UNAuthorizationOptionBadge | UNAuthorizationOptionAlert | UNAuthorizationOptionSound4completionHandler:^(BOOL granted, NSError *error) {5// Add here your handling of granted or not granted permissions6}];7currentNotificationCenter.delegate = self;8} else {9NSDictionary* localNotification = [launchOptions objectForKey:UIApplicationLaunchOptionsRemoteNotificationKey];10if (localNotification) {11[self application:application didReceiveRemoteNotification:localNotification];12}1314[UIApplication.sharedApplication registerUserNotificationSettings:[UIUserNotificationSettings settingsForTypes:(UIUserNotificationTypeSound | UIUserNotificationTypeAlert | UIUserNotificationTypeBadge) categories:nil]];15[UIApplication.sharedApplication registerForRemoteNotifications];16}
The above code snippet asks the user's permission for notifications, and if granted, registers for remote (push) notifications. That's it! We're now registered for notifications.
Receiving notifications in our app lets us react to whatever event just occurred. It can trigger our app to update a view, change a status, or even send data to a server. Whenever the app receives a notification, the method didReceiveRemoteNotification
is fired
1// For iOS 10 and later; do not forget to set up a delegate for UNUserNotificationCenter2- (void)userNotificationCenter:(UNUserNotificationCenter *)center3didReceiveNotificationResponse:(UNNotificationResponse *)response4withCompletionHandler:(void (^)(void))completionHandler {5NSDictionary *userInfo = response.notification.request.content.userInfo;6// If your application supports multiple types of push notifications, you may wish to limit which ones you send to the TwilioChatClient here7if (self.chatClient) {8// If your reference to the Chat client exists and is initialized, send the notification to it9[self.chantClient handleNotification:userInfo completion:^(TCHResult *result) {10if (![result isSuccessful]) {11// Handling of notification was not successful, retry?12}13}];14} else {15// Store the notification for later handling16self.receivedNotification = userInfo;17}18}1920// For iOS versions before 1021- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo {22// If your application supports multiple types of push notifications, you may wish to limit which ones you send to the TwilioChatClient here23if (self.chatClient && userInfo) {24// If your reference to the Chat client exists and is initialized, send the notification to it25[self.chatClient handleNotification:userInfo completion:^(TCHResult *result) {26if (![result isSuccessful]) {27// Handling of notification was not successful, retry?28}29}];30} else {31// Store the notification for later handling32self.receivedNotification = userInfo;33}34}
We will pass the notification directly on to the Chat client if it is initialized or store the event for later processing if not.
The userInfo parameter contains the data that the notification passes in from APNS. We can update our Chat client by passing it into the singleton via the receivedNotification
method. The manager wraps the Chat client methods that process the notifications appropriately.
Once your Chat client is up and available, you can provide the push token your application received:
1if (self.updatedPushToken) {2[self.chatClient registerWithNotificatrionToken:self.updatedPushToken3completion:^(TCHResult *result) {4if (![result isSuccessful]) {5// try registration again or verify token6}7}];8}910if (self.receivedNotification) {11[self.chatClient handleNotification:self.receivedNotification12completion:^(TCHResult *result) {13if (![result isSuccessful]) {14// Handling of notification was not successful, retry?15}16}];17}
To update badge count on an application icon, you should pass badge count from the Chat Client delegate to the application:
Next: Notifications on Android