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)

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

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

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

6. 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];

7. 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
}

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];
}

Plugin installation

The SDK can be found in the devtodev GitHub repository. Download the latest release of the Source code (zip). Unzip the archive and copy the DTDMessaging folder to the Plugins folder of your project.

If you have a C++ type project, add DTDMessaging to the list of dependency names in the <module_name>.Build.cs file of the module in which you plan to use the plugin.

Example:

PublicDependencyModuleNames.Add("DTDMessaging");

Android

Add your google-services.json file to the project's root directory. It will be used to configure notifications during the project-building process.

iOS

In the case your Unreal Engine is built from GitHub source code:

Enable notifications in the settings of your project: Edit → Project Settings → iOS → Enable Remote Notifications Support

In the case your Unreal Engine is not built from GitHub source code:

Add the parameter to the engine configuration file (<proj_dir>/Config/DefaultEngine.ini):

// Some code/Script/IOSRuntimeSettings.IOSRuntimeSettings]
bEnableRemoteNotificationsSupport=True

Data types

class UDTDMessagingBPLibrary

A class that implements analytic methods.

Header file:

#include "DTDMessaging/Public/DTDMessagingBPLibrary.h"

enum class EDTDNotificationActionType : uint8

Notification action type

Header file:

#include "DTDMessaging/Public/DTDNotificationActionType.h"

Values:

• App = 0 - default value

• Url = 1 - external link opening

• Share = 2 - share contentc

• DeepLink = 2 - an in-app link opening

struct FDTDNotification

Notification data container.

Header file:

#include "DTDMessaging/Public/DTDNotification.h"

struct FDTDNotificationAction

Notification action data container.

Header file:

#include "DTDMessaging/Public/DTDNotificationAction.h

enum class EDTDIOSNotificationOptions : uint8

Push Notification display settings are Bitflags that are managed by the developer and allow for selecting the method of user notification. It can be altered by the end user.

By default, it has the value: Badge|Sound|Alert

Header file:

#include "DTDMessaging/Public/DTDIOSNotificationOptions.h"

Values:

• None = 0 - nothing

• Badge = 1 << 0 - can display a badge on the app icon

• Sound = 1 << 1 - can play a sound

• Alert = 1 << 2 - can display an alert

• CarPlay = 1 << 3 - can display a push notification on CarPlay

• CriticalAlert = 1 << 4 - critical alerts can play a sound even if Do Not Disturb is enabled (critical alerts require a special entitlement issued by Apple). Available from iOS 12 onwards.

• AppNotificationSettings = 1 << 5 - this option defines that the system should display a notification settings button in the app. Available from iOS 12.0 onwards.

• Provisional = 1 << 6 - an option for sending provisional notifications to the Notification Center without interrupting functioning processes. Available from iOS 12.0 onwards.

Use this setting to avoid the permission request on app launch because it is seen as intrusive, and most users opt out of it.

It’s also important that when using the Provisional setting, the user needs to go to Notification Center settings to allow explicit notifications.

Delegates

Header file:

#include "DTDMessaging/Public/DTDMessagingDelegates.h"

Delegates:

DECLARE_DELEGATE_OneParam(FDTDMessagingBoolParamsDelegate, bool);
DECLARE_DELEGATE_OneParam(FDTDMessagingStringParamsDelegate, const FString&);
DECLARE_DELEGATE_OneParam(FDTDMessagingNotificationParamsDelegate, const FDTDNotification&);
DECLARE_DELEGATE_TwoParams(FDTDMessagingNotificationActionParamsDelegate, const FDTDNotification&, const FDTDNotificationAction&);

Initialization

Notification module initialization:

UDTDMessagingBPLibrary::Initialize();

Methods

SetAvailability

A method responsible for enabling/disabling push notifications. When the state changes, it sends an event that includes the availability status (true or false). The availability status flag is stored in the SDK.

UDTDMessagincgBPLibrary::SetAvailability(true);

GetAvailability

Get the current availability status flag (true or false):

auto onResult = new FDTDMessagingBoolParamsDelegate();
onResult->BindLambda([](bool value)
{
  // Your code...
});
UDTDMessagingBPLibrary::GetAvailability(*onResult);

GetToken

Get a current unique device ID used in the notification system:

auto onResult = new FDTDMessagingStringParamsDelegate();
onResult->BindLambda([](const FString& value)
{
  // Your code...
});
UDTDMessagingBPLibrary::GetToken(*onResult);

SetTokenListener

Set a token listener. The listener will be executed when the SDK updates a unique device ID in the notification system.

auto listener = new FDTDMessagingStringParamsDelegate();
listener->BindLambda([](const FString& value)
{
  // Your code...
});
UDTDMessagingBPLibrary::SetTokenListener(*listener);

SetTokenErrorListener

Set a listener for errors in token reception. The listener will be executed when an error occurs while the SDK updates a unique device ID in the notification system.

auto listener = new FDTDMessagingStringParamsDelegate();
listener->BindLambda([](const FString& value)
{
  // Your code...
});
UDTDMessagingBPLibrary::SetTokenErrorListener(*listener);

SetNotificationReceiveListener

Set a listener for notification reception. The listener will be executed when the SDK receives a notification.

auto listener = new FDTDMessagingNotificationParamsDelegate();
listener->BindLambda([](const FDTDNotification& notification)
{
  // Your code...
});
UDTDMessagingBPLibrary::SetNotificationReceiveListener(*listener);

SetInvisibleNotificationReceiveListener

Set a listener for invisible notification reception. The listener will be executed when the SDK receives an invisible notification.

auto listener = new FDTDMessagingNotificationParamsDelegate();
listener->BindLambda([](const FDTDNotification& notification)
{
  // Your code...
});
UDTDMessagingBPLibrary::SetInvisibleNotificationReceiveListener(*listener);

SetNotificationActionListener

Set a listener for notification activation. The listener will be executed when the notification gets activated.

auto listener = new FDTDMessagingNotificationActionParamsDelegate();
listener->BindLambda([](const FDTDNotification& notification, const FDTDNotificationAction& action)
{
  // Your code...
});
UDTDMessagingBPLibrary::SetNotificationActionListener(*listener);

IOSSetNotificationOptions

Set notification parameters.

int32 options = EDTDIOSNotificationOptions::Badge |
  EDTDIOSNotificationOptions::Sound |
  EDTDIOSNotificationOptions::Alert;
UDTDMessagingBPLibrary::IOSSetNotificationOptions(options);

Push Notifications (UWP)

The DevToDev.Messaging package necessary for notifications is available in the NuGet package manager.

1. NuGet Installation

Package Manager UI

Find the DevToDev.Messaging package using the package manager search engine and click Install. The latest version of the package is recommended.

Package Manager Console

In progress...

2. Setup

For the correct package functioning, add handlers invoke to the Windows.UI.Xaml.Application class implementation.

Besides, in the UI editor of the Package.appxmanifest file do the following:

1. Add Background Tasks to the Declarations tab and mark it as System Event. After that enter DevToDev.Background.ToastNotificationBackgroundTask to the Entry Point field.

2. Add Background Tasks to the Declarations tab and mark it as Push Notification. After that enter DevToDev.Background.RawNotificationBackgroundTask to the Entry Point field.

3. Initialization

After the SDK has been initialized you can move to initializing messages. To do this, call the method:

4. Events

It is possible to listen to events from the DevToDev.Messaging package:

1. Push Token - a string that allows to identify the client on a remote server for sending him customized notifications. For listening the unique Push Token ID issue event, it is necessary to be subscribed to the event:

2. To track the errors related to the unique Push Token ID issue, it is necessary to be subscribed to the event:

Where error is a string value containing information about the error.

3. To handle incoming message data, it is necessary to be subscribed to the following event:

Where messageData belongs to the IDictionary<string, string> type and contains data sent from the server together with the message.

4. To handle notification activation events, it is necessary to be subscribed to the event:

Where messageAction is DevToDev.Messaging.DTDMessageAction class instance:

5. Disabling

Call the method to turn notifications off:

11

Push Notifications on Android are sent with the help of the FCM service.

How to create a project in Firebase and integrate Firebase Services into your application, you can find in .

Next, you need to specify the FCM Server key in the push notifications integration settings panel in the application settings section in devtodev service (App → Settings → Push notifications → Push notifications panel)

To get the FCM Server key, go to the Project Settings of your Android project in the Firebase Console and copy the Server key from the Cloud Messaging tab.

Messaging Module Integration

1. If you use Gradle for the applications build, add mavenCentral() into gradle.build file of your application and specify the following relationship in dependencies block:

2. To the app manifest add the following:

3. To add a user icon to your push notification and change its color, add the following strings to the manifest file code:

To add a large user icon to your push notifications, add:

Example:

4. After the DTDAnalytics initializer, add the DTDMessaging initializer.

Example:

5. Subscribe a DTDPushListener to receive information about the DTDMessaging functioning.

Example:

6. Call the DTDMessaging.startPushService() method to activate the Messaging module.

External interface of the DTDMessaging module

DTDPushListener Interface Methods

A Class for Receiving Notification Data (DTDPushMessage).

Basic Class Properties

A Class for Handling the Notification Button Taps (DTDActionButton)