Push Notifications

Enable push notifications for iOS or Android apps that use the Marketo Mobile SDK.

Setup Push Notification on iOS

There are three steps to enable push notifications:

Configure Push Notifications on Apple Developer Account

Enable Push Notifications in xCode

Turn on the push notification capability in the xCode project.

Enable Push Notifications in App with Marketo SDK

Add the following code to the AppDelegate.m file to deliver push notifications to customer devices.

Note - If you use the Adobe Launch extension, use ALMarketo as the class name.

Add the following import to AppDelegate.h.

#import <UserNotifications/UserNotifications.h>

import UserNotifications

Add UNUserNotificationCenterDelegate to AppDelegate as shown below.

@interface AppDelegate : UIResponder <UIApplicationDelegate, UNUserNotificationCenterDelegate>

class AppDelegate: UIResponder, UIApplicationDelegate , UNUserNotificationCenterDelegate

Add the following code to initialize the push notification service.

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

    return YES;
}

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

    UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound,    .badge]) { granted, error in
            if let error = error {
                print("\(error.localizedDescription)")
            } else {
                DispatchQueue.main.async {
                    application.registerForRemoteNotifications()
                }
            }
        }

        return true
}

Call this method to start registration with Apple Push Service. If registration succeeds, the app calls the App delegate object’s application:didRegisterForRemoteNotificationsWithDeviceToken: method and passes it a device token.

If registration fails, the app calls its App delegate’s application:didFailToRegisterForRemoteNotificationsWithError: method instead.

Register the push token with Marketo. The device token must be registered to receive push notifications from Marketo.

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
    // Register the push token with Marketo
    [[Marketo sharedInstance] registerPushDeviceToken:deviceToken];
}

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    // Register the push token with Marketo
    Marketo.sharedInstance().registerPushDeviceToken(deviceToken)
}

You can also unregister the token when the user logs out.

[[Marketo sharedInstance] unregisterPushDeviceToken];

Marketo.sharedInstance().unregisterPushDeviceToken

To re-register the push token, extract the code from step 3 into an AppDelegate method. Call that method from the ViewController login method.

Handle the push notification after registering the device token with Marketo.

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo
{
    [[Marketo sharedInstance] handlePushNotification:userInfo];
}

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any]) {
    Marketo.sharedInstance().handlePushNotification(userInfo)
}

Add the following method to AppDelegate.

Use this method to display an alert, play a sound, or increase the badge while the app is in the foreground. Call the appropriate completionHandler in this method.

-(void)userNotificationCenter:(UNUserNotificationCenter *)center
    willPresentNotification:(UNNotification *)notification
        withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler{

    completionHandler(UNAuthorizationOptionSound | UNAuthorizationOptionAlert | UNAuthorizationOptionBadge);
}

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

Handle newly received push notifications in AppDelegate.

The delegate calls this method when the user responds to a notification by opening the application, dismissing the notification, or choosing a UNNotificationAction. Set the delegate before the application returns from applicationDidFinishLaunching:.

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void(^)(void))completionHandler {
    [[Marketo sharedInstance] userNotificationCenter:center didReceiveNotificationResponse:response withCompletionHandler:completionHandler];
}

func userNotificationCenter(_ center: UNUserNotificationCenter,
                                didReceive response: UNNotificationResponse,
                                withCompletionHandler
                                completionHandler: @escaping () -> Void) {
        Marketo.sharedInstance().userNotificationCenter(center, didReceive: response, withCompletionHandler: completionHandler)
}

Track push notifications.

If the app is in the background or inactive, the device receives a push notification as shown below. Marketo tracks when the user selects the notification.

When the device receives a push notification, it passes the notification to the application:didReceiveRemoteNotification: callback on the App delegate.

The following Marketo activity log shows app events and push notification events.

Setup Push Notification on Android

Android Test Devices

Add Marketo Activity to the manifest file inside the application tag.

<activity android:name="com.marketo.MarketoActivity"  android:configChanges="orientation|screenSize">
    <intent-filter android:label="MarketoActivity">
        <action  android:name="android.intent.action.VIEW"/>
        <category  android:name="android.intent.category.DEFAULT"/>
        <category  android:name="android.intent.category.BROWSABLE"/>
        <data android:host="add_test_device" android:scheme="mkto"/>
    </intent-filter/>
</activity/>

Register Marketo Push Service

NOTE: The FCM SDK automatically adds the required permissions and receiver functionality. If you used a previous SDK version, remove the following obsolete elements, which might cause message duplication.

<receiver android:name="com.marketo.MarketoBroadcastReceiver" android:permission="com.google.android.c2dm.permission.SEND">
    <intent-filter>
        <!‐‐Receives the actual messages.‐‐>
        <action android:name="com.google.android.c2dm.intent.RECEIVE"/>
        <!‐‐Register to enable push notification‐‐>
        <action android:name="com.google.android.c2dm.intent.REGISTRATION"/>
        <!‐‐‐Replace YOUR_PACKAGE_NAME with your own package name‐‐>
        <category android:name="YOUR_PACKAGE_NAME"/>
    </intent-filter>
</receiver>

<!‐‐Marketo service to handle push registration and notification‐‐>
<service android:name="com.marketo.MarketoIntentService"/>

Troubleshooting

If mobile push messages do not work as expected, check the common configuration issues before investigating the implementation details.

Push Message is Not Showing Up

Check whether push messages are disabled on the device. Mobile users can control whether they receive messages for each app, and developers or marketers might disable messages during development.

Check whether the app is open and active. When the app is active, mobile push messages do not appear on the screen. They appear in the app’s “local notifications” area instead.

View the Activity Logs in Marketo

Use the Marketo Activity logs to verify that a message was sent.

Review the activity records for a person who should have received the message. If the message was sent, the activity log contains a record. If no record exists, check the iOS certificate or Android API key configuration in Marketo.

Certificate or Key is Invalid

Verify that the correct certificate is loaded for Sandbox or Production. If necessary, re-export the iOS certificates or Android keys and reload them into Marketo.

.p12 file is Missing a Certificate or Key (iOS)

When you export the certificate, export both the key and the certificate.

Provisioning Profiles Out-of-Date (iOS)

After adding a device, update the provisioning profiles and generate new certificates. Point the Xcode project to the correct profiles and certificates, and import the certificates into Marketo.

Cannot Upload iOS Certificate (IOS)

Ensure that the password used to export the certificate does not contain spaces. For example, instead of this:

Hello World 123

use this:

HelloWorld123

Troubleshooting iOS Certificates

For sandbox applications, use a “developer” or “universal” certificate. For production applications, upload a valid “distribution” or “universal” certificate.

Push Bounce / Invalid Token

A registration token can become invalid in the following scenarios: