iOS

Platform integration

Creating a Universal Push Notification Client SSL Certificate

You use Member Center to generate a push notification client SSL certificate that allows your notification server to connect to the APNs. Each App ID is required to have its own client SSL certificate. The client SSL certificate Member Center generates is a universal certificate that allows your app to connect to both the development and production environments.

To generate a universal client SSL certificate

1. In Certificates, Identifiers & Profiles, select Certificates.

2. Click the Add button (+)

   
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.

5. Create a certificate request on your Mac.

6. Click Choose File.

7. In the dialog that appears, select the certificate request file (with a .certSigningRequest extension), and click Choose File.

8. Click Generate.

9. Click Download.

   

Follow these steps to export the certificate from Apple web-site to the P12-file:

1. Open "Keychain access" application

2. If the certificate hasn't been added to keychain access yet, choose "File" → "Import". Find the certificate file (CER-file) provided by Apple

3. Choose "Keys" section in "Keychain access" application

4. Choose a personal key associated with your iPhone developer certificate. Personal key is identified by open certificate associated with it "iPhone developer: ". Choose "File" → Export objects. Save key as .p12

5. You'll be suggested to create a password which is used when you need to import the key to another computer

Upload the certificate to the site

Upload the .p12-file into Integration section of application settings panel (Settings -> Push Notifications):

Messaging Module Integration (CocoaPods)

CocoaPods is the easiest way to add devtodev into your iOS project.

1. Firstly, install CocoaPods using:

sudo gem install cocoapods

2. In the project directory execute the command:

pod init

3. In the created Podfile add the dependency:

platform :ios, '9.0'

target 'TargetName' do
  use_frameworks!
  pod 'DTDAnalytics', '~> 2.0.0'
  pod 'DTDMessaging', '~> 2.0.0'
end

4. Finally, run the command in your Xcode project directory:

pod install

CocoaPods should download and install the devtodev library, and create a new Xcode workspace. Open this workspace in Xcode.

Messaging Module Integration (Manual Installation)

To connect the module for processing push notifications, you need to:

1. Download the latest devtodev SDK from the repository.

2. Add DTDAnalytics.xcframework to the project (check Do Not Embed).

1. Add DTDMessaging.xcframework to the project (check Do Not Embed)

1. In the Xcode project settings, open the tab, and add: "Push Notifications" and "Background Modes" respectively.

1. In the "Background Modes" section, enable "Remote notifications".

1. Add initialization to didFinishLaunchingWithOptions method:

let config = DTDAnalyticsConfiguration()
config.logLevel = .error
DTDAnalytics.initialize(applicationKey: "App ID", configuration: config)

DTDMessaging.delegate = self
DTDMessaging.pushNotificationsOptions = [.DTDNotificationOptionAlert,
                                         .DTDNotificationOptionSound,
                                         .DTDNotificationOptionBadge]
DTDMessaging.startPushService()

DTDNotificationOptions *options = [[DTDNotificationOptions alloc] initWithRawValue:
                                  [DTDNotificationOptions.DTDNotificationOptionAlert rawValue] |
                                  [DTDNotificationOptions.DTDNotificationOptionSound rawValue] |
                                  [DTDNotificationOptions.DTDNotificationOptionBadge rawValue]];
[DTDMessaging setPushNotificationsOptions:options];
[DTDMessaging startPushService];

1. To handle SDK delegate methods, you need to add the implementation of the DTDMessagingDelegate protocol.

extension AppDelegate: DTDMessagingDelegate {
    func didRegisterForRemoteNotifications(with deviceToken: Data) {
        // your code
    }

    func didFailToRegisterForRemoteNotifications(with error: Error) {
        // your code
    }

    func didReceiveInvisibleNotification(with message: DTDMessage) {
        // your code
    }

    func didReceiveForegroundNotification(with message: DTDMessage) {
        // your code
    }

    func didOpenRemoteNotification(with message: DTDMessage, and buttonClicked: DTDActionButton?) {
        // your code
    }
}

@interface AppDelegate () <DTDMessagingDelegate>

- (void)didRegisterForRemoteNotificationsWith:(NSData *)deviceToken {
    // your code
}

- (void)didFailToRegisterForRemoteNotificationsWith:(NSError *)error {
    // your code
}

-(void)didReceiveInvisibleNotificationWith:(DTDMessage *)message {
    // your code
}

- (void)didReceiveForegroundNotificationWith:(DTDMessage *)message {
    // your code
}

-(void)didOpenRemoteNotificationWith:(DTDMessage *)message and:(DTDActionButton *)buttonClicked {
    // your code
}

The DTDMessaging module provides support for notifications with attachments. These notifications are available since iOS 10. Attachments support images, animated gifs and videos. To use this function, you will need to create a “Notification Service Extension“, for this create a new target in your application settings:

• Open Xcode (File -> New -> Target). Select Notification Service Extension.

The next step is to modify the Notification Extension class as follows:

• Delete all auto-generated code.

• Inherit Notification Extension class from DTDMediaAttachmentExtension

Example:

import UserNotifications
import DTDMessaging

class NotificationService: DTDMediaAttachmentExtension {

}

External interface of the DTDMessaging module

Optional DTDMessagingDelegate methods

Class for receiving Notification data (DTDMessage)

Class for handling pressed buttons on a notification (DTDActionButton)

Notes

Foreground Notification

Displaying push notifications in Foreground state is available since iOS 10.0.

By default, according to Apple Push Notification Guidelines, the display of push notification in the Foreground state is disabled. In order to set the display method, you must:

• Assign delegate for UNUserNotificationCenter

• Or pass a parameter in the push notification constructor (_fg = 1). In this case, the display method will be formed from the Notification settings.

• Or delegate the system method userNotificationCenter willPresent notification. In this case, the display properties will be taken from the developer.

An example of a delegated method implementation:

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

DTDNotificationOptions

It is an OptionSet that is used to pass push notification authorization and set up interactions with users.

Possible values:

DTDMediaAttachmentExtension

To handle the application attitude to displaying push notifications, you need to add a Notifications service Extension. And inherit NotificationService from DTDMediaAttachmentExtension

@available(iOSApplicationExtension 10.0, *)
class NotificationService: DTDMediaAttachmentExtension {
  // nothing
}

Custom sounds

To use custom sounds for push notifications, you need to copy the necessary sound files to the Libraries folder of your Xcode project. You can read more about supported formats here.

When creating a push company, it is important to specify the full name of the sound with file extension (for example, sound.wav).

DTDMessaging integration with swizzling disabled

DTDMessaging automatically swizzles notification tracking and APNS-token usage methods by default. If you want to disable the function, add the flag DTDMessagingSwizzlingEnabled (boolean) in the app’s Info.plist file and set it to NO (0). However, if you disable notification swizzling, you will need additional integration for accurate analytics:

For sending APNS-token to DTDMessaging:

func application(_ application: UIApplication, 
                didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
  DTDMessaging.apnsToken = deviceToken
}i

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

For sending information about the application:

func application(_ application: UIApplication,
                didReceiveRemoteNotification userInfo: [AnyHashable: Any]) {
  DTDMessaging.didReceiveMessage(userInfo: userInfo, actionIdentifier: nil)
}

@available(iOS 10.0, *)
extension AppDelegate: UNUserNotificationCenterDelegate {
  func userNotificationCenter(_ center: UNUserNotificationCenter, 
                              didReceive response: UNNotificationResponse, 
                              withCompletionHandler completionHandler: @escaping () -> Void) {
    let userInfo = response.notification.request.content.userInfo
    let actionIdentifier = response.actionIdentifier
    DTDMessaging.didReceiveMessage(userInfo: userInfo, actionIdentifier: actionIdentifier)
  }

  func userNotificationCenter(_ center: UNUserNotificationCenter, 
                              willPresent notification: UNNotification, 
                              withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
    let userInfo = notification.request.content.userInfo
    DTDMessaging.willPresentMessage(userInfo: userInfo)
  }
}

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
    [DTDMessaging didReceiveMessageWithUserInfo:userInfo actionIdentifier:nil];
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
    NSDictionary *userInfo = notification.request.content.userInfo;
    [DTDMessaging willPresentMessageWithUserInfo:userInfo];
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler {
    NSDictionary *userInfo = response.notification.request.content.userInfo;
    NSString *actionIdentifier = response.actionIdentifier;

    [DTDMessaging didReceiveMessageWithUserInfo:userInfo actionIdentifier:actionIdentifier];
}