1 of 19

Integration of SDK v2.0+

The newest generation of devtodev SDK

SDK Integration

Android

The SDK is available as an AAR (recommended) and JAR library. The library is available in the MavenCentral and GitHub repository.

Step 1. Gradle Build Dependencies

If you use Gradle for building apps specify the following dependencies in the build.gradle file in the dependencies block.

dependencies {
    implementation ‘androidx.preference:preference-ktx:1.1.1
    implementation 'com.android.installreferrer:installreferrer:2.2'
    implementation 'com.google.android.gms:play-services-base:17.6.0'
    implementation 'com.google.code.gson:gson:2.8.6'
    implementation 'com.google.firebase:firebase-core:19.0.0'
    // if you use AAR (recommended) or JAR downloaded from GitHub, please add:
    implementation fileTree(dir: "libs", include: ["*.aar"]) 
    // or just add the dependency
    implementation 'com.devtodev:android-analytics:2.0.0'
}

dependencies {
    implementation ’androidx.preference:preference:1.1.1
    implementation 'com.android.installreferrer:installreferrer:2.2'
    implementation 'com.google.android.gms:play-services-base:17.6.0'
    implementation 'com.google.code.gson:gson:2.8.6'
    implementation 'com.google.firebase:firebase-core:19.0.0'
    // if you use AAR (recommended) or JAR downloaded from GitHub, please add:
    implementation fileTree(dir: "libs", include: ["*.aar"]) 
    // or just add the dependency
    implementation 'com.devtodev:android:2.0.0'
}

Step 2. SDK Initialization

Use the following way to initialize the library in the first Activity onCreate() method:

class MainActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
      
        val analyticsConfiguration = DTDAnalyticsConfiguration()
        analyticsConfiguration.logLevel = DTDLogLevel.Error
        DTDAnalytics.initialize("App ID", analyticsConfiguration, context)
    }
}

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        DTDAnalyticsConfiguration configuration = new DTDAnalyticsConfiguration();
        configuration.setLogLevel(DTDLogLevel.Error);
        DTDAnalytics.initialize("App ID", configuration, context);
    }
}

You can find the App ID in the settings of the respective app in devtodev (Settings → SDK → Integration → Credentials).
config - is a DTDAnalyticsConfiguration object instance that is used for specifying additional properties during initialization.

DTDAnalyticsConfiguration

Example:

let config = DTDAnalyticsConfiguration()
config.currentLevel = 1
config.userId = "CustomUserID"
config.trackingAvailability = DTDTrackingStatus.Enable
config.logLevel = .error
DTDAnalytics.initialize(applicationKey: "appKey", configuration: config)

Step 3. SDK Initialization

Add the following strings to the proguard-rules.pro file of your app

-keep class com.devtodev.** { *; }
-dontwarn com.devtodev.**

iOS

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

Swift Package Manager

In progress...

Manual installation

1. Download the latest version of devtodev SDK from the repository

3. Add frameworks:

AppTrackingTransparency.framework
AdSupport.framework

4. Add initialization todidFinishLaunchingWithOptions method:

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

DTDAnalyticsConfiguration *config;
config.logLevel = DTDLogLevelError;
[DTDAnalytics applicationKey:@"App ID" configuration:config];

An App ID can be found in the settings of the respective app in devtodev (Settings → SDK → Integration → Credentials).
config - an object instance of DTDAnalyticsConfiguration, which is used for specifying additional properties during the initialization.

DTDAnalyticsConfiguration

Example:

let config = DTDAnalyticsConfiguration()
config.currentLevel = 1
config.userId = "CustomUserID"
config.trackingAvailability = .enable
config.logLevel = .error
DTDAnalytics.initialize(applicationKey: "appKey", configuration: config)

DTDAnalyticsConfiguration *config;
config.currentLevel = @1;
config.userId = @"CustomUserID";
config.trackingAvailability = DTDTrackingStatusEnable;
config.logLevel = DTDLogLevelError;
[DTDAnalytics applicationKey:@"App ID" configuration:config];

Integration features

For Objective-C

Create Bridging-Header. To do this, you need to add any swift file to the project (don’t delete it later) and choose ‘Create Bridging Header’ in the offered dialog box.
Make sure that the ‘Build Settings’ for ‘Defines Module’ value evaluates to ‘YES’.
While importing, use: #import <DTDAnalytics/DTDAnalytics-Swift.h>

For SwiftUI

For SDK to function properly, it needs to be integrated at the earliest moment of the app launch. It is recommended that you use the following method of main entry point initialization:

@main
struct TestSwiftUIApp: App {
    init() {
        let config = DTDAnalyticsConfiguration()
        config.logLevel = .debug
        DTDAnalytics.initialize(applicationKey: "appKey", configuration: config)
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

macOS

1. Download the latest version of devtodev SDK from the repository

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

3. Add frameworks:

AppTrackingTransparency.framework
AdSupport.framework

4. Add initialization todidFinishLaunchingWithOptions method:

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

DTDAnalyticsConfiguration *config;
config.logLevel = DTDLogLevelError;
[DTDAnalytics applicationKey:@"App ID" configuration:config];

An App ID can be found in the settings of the respective app in devtodev (Settings → SDK → Integration → Credentials).
config - an object instance of DTDAnalyticsConfiguration, which is used for specifying additional properties during the initialization.

DTDAnalyticsConfiguration

Example:

let config = DTDAnalyticsConfiguration()
config.currentLevel = 1
config.userId = "CustomUserID"
config.trackingAvailability = .enable
config.logLevel = .error
DTDAnalytics.initialize(applicationKey: "appKey", configuration: config)

DTDAnalyticsConfiguration *config;
config.currentLevel = @1;
config.userId = @"CustomUserID";
config.trackingAvailability = DTDTrackingStatusEnable;
config.logLevel = DTDLogLevelError;
[DTDAnalytics applicationKey:@"App ID" configuration:config];

Integration features

For Objective-C

Create Bridging-Header. To do this, you need to add any swift file to the project (don’t delete it later) and choose ‘Create Bridging Header’ in the offered dialog box.
Make sure that the ‘Build Settings’ for ‘Defines Module’ value evaluates to ‘YES’.
While importing, use: #import <DTDAnalytics/DTDAnalytics-Swift.h>

For SwiftUI

For SDK to function properly, it needs to be integrated at the earliest moment of the app launch. It is recommended that you use the following method of main entry point initialization:

@main
struct TestSwiftUIApp: App {
    init() {
        let config = DTDAnalyticsConfiguration()
        config.logLevel = .debug
        DTDAnalytics.initialize(applicationKey: "appKey", configuration: config)
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

Unity

SDK Initialization

This SDK version does not support WebGL. WebGL support will be added in the next releases.

If you have previously used the Unity SDK version 2+, you need to delete the following files and folders in the "Assets" folder of your project:

Attention! When importing to Unity 2020, you may face the following error:

Assembly 'Assets/Plugins/DevToDev/Analytics/Windows/AnalyticsWindowsEditor.dll' will not be loaded due to errors: AnalyticsWindowsEditor references strong named Newtonsoft.Json Assembly references: 13.0.0.0 Found in project: 12.0.0.0. Assembly Version Validation can be disabled in Player Settings "Assembly Version Validation"

The error might occur due to the conflict between our package’s NewtonsoftJson dependency version and the one used in the VersionControl package. There are two ways to resolve this issue:

A. If you don’t use the VersionControl package, remove it from the package list. Choose Window->Package Manager in the Unity window:

In the window that appears, choose Packages: In Project from a drop-down list at the top. After that, select Version Control from the package list and click Remove. B. If you use Unity’s Version Control, you need to replace the newtonsoft.Json package. Open the directory of your main project (the one you want to integrate analytics with) MainProject\Library\PackageCache\ and move the com.unity.nuget.newtonsoft-json folder to the MainProject\Packages\ folder. It should look something like this:

2. Create a script with the following code and attach it to the GameObject that will survive the entire life cycle of the app.

You can find the AppID in the settings of the respective app in devtodev (Settings → SDK → Integration → Credentials).

config - an object instance of DTDAnalyticsConfiguration, which is used for specifying additional properties during the initialization.

DTDAnalyticsConfiguration

Example:

Specific integration features of certain platforms

Windows Standalone

SDK Activity

The SDK can’t control app activity in case you use Windows Standalone therefore this responsibility is shifted to the developer. While initializing the SDK, the activity starts automatically and after that, the activity status will not auto-change. To track app activity, the developer can use the following methods: DTDAnalytics.StartActivity and DTDAnalytics.StopActivity. It is recommended to use the DTDAnalytics.StopActivity method to stop activity when the app goes into the background or gets closed. You can use the DTDAnalytics.StartActivity method to resume activity when the app gets reopened from the taskbar.

For other platforms, there is no need to manually call the DTDAnalytics.StartActivity and DTDAnalytics.StopActivity methods.

Android

iOS

To integrate with Xcode, the SDK uses PostProcessBuild in the DTDPostProcessAnalytics and DTDPostProcessMessaging scripts. If you use custom PostProcessBuild scripts, add them callbackOrder of less than 98 to avoid conflicts.

If you want to disable tracking of advertising identifiers, you need to open the DTDPostProcesssAnalytics.cs file and comment out the line 39.

Windows

1. NuGet Installation

Package Manager UI

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

Package Manager Console

2. SDK Initialization

Initialize the library using the following code:

var config = new DTDAnalyticsConfiguration();
config.LogLevel = DTDLogLevel.Error;
DTDAnalytics.Initialize("App ID", config);

You can find the App ID in the settings of the respective app in devtodev (Settings → SDK → Integration → Credentials).
config - is a DTDAnalyticsConfiguration object instance that is used for specifying additional properties during initialization.

DTDAnalyticsConfiguration

Example:

var config = new DevToDev.Analytics.DTDAnalyticsConfiguration();
config.LogLevel = DTDLogLevel.Error;
config.CurrentLevel = 2;
config.UserId = "CustomUserId";
config.TrackingAvailability = DTDTrackingStatus.Enable;
DevToDev.Analytics.DTDAnalytics.Initialize("App ID", config);

1. NuGet Installation

Package Manager UI

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

Package Manager Console

2. SDK Initialization

Initialize the library using the following code:

var config = new DTDAnalyticsConfiguration();
config.LogLevel = DTDLogLevel.Error;
DTDAnalytics.Initialize("App ID", config);

You can find the App ID in the settings of the respective app in devtodev (Settings → SDK → Integration → Credentials).
config - is a DTDAnalyticsConfiguration object instance that is used for specifying additional properties during initialization.

DTDAnalyticsConfiguration

Example:

var config = new DevToDev.Analytics.DTDAnalyticsConfiguration();
config.LogLevel = DTDLogLevel.Error;
config.CurrentLevel = 2;
config.UserId = "CustomUserId";
config.TrackingAvailability = DTDTrackingStatus.Enable;
config.ApplicationVersion = "1.2.34";
DevToDev.Analytics.DTDAnalytics.Initialize("App ID", config);

3. SDK Activity

The SDK can’t control app activity hence this responsibility is passed on to the developer. During the SDK initialization, the activity is triggered automatically, and later the activity status will not change automatically. For tracking app activity, the developer can use the DTDAnalytics.StartActivity and DTDAnalytics.StopActivity methods. It is recommended that you use the DTDAnalytics.StopActivity method to stop the activity when the app goes into the background or being closed. If the window is re-opened from the taskbar it is recommended to renew the activity by using the DTDAnalytics.StartActivity method.

Web

Please do the following to integrate your web application with devtodev:

1. Add the application to the Space using the wizard for adding applications.

2. To integrate SDK, add the following line to the tag of your page:

<script type="text/javascript" src="https://cdn.devtodev.com/sdk/web/v2/devtodevsdk.js">
</script>

3. Init the SDK.

Initialization

In order for SDK for WEB to start working, it is necessary to perform initialization right after the page is loaded and you have a basic user identifier at your disposal.

window.devtodev.initialize("App ID", config);

You can find the App ID in the settings of the respective app in devtodev (Settings → SDK → Integration → Credentials).
config - is an object that is used for specifying additional properties during initialization.

Config

Example:

var config = {};
config.userId = "Unique user identifier";
config.currentLevel = 2;
config.trackingAvailability = true;
config.LogLevel = "Error";
window.devtodev.initialize("App ID", config);

Unreal Engine

Plugin installation

Unzip the DTDAnalytics.zip archive to the Plugins folder of your project.

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

Example:

PublicDependencyModuleNames.Add("DTDAnalytics");

Data types

class UDTDAnalyticsLibrary

A class that implements analytic methods.

Header file:

#include "DTDAnalytics/Public/DTDAnalyticsBPLibrary.h"

class UDTDUserCardLibrary

A class that implements user card methods.

The class header:

#include "DTDAnalytics/Public/DTDUserCardBPLibrary.h"

enum class EDTDTrackingStatus : uint8

SDK tracking status.

Header file:

#include "DTDAnalytics/Public/DTDTrackingStatus.h"

Values:

Unknown = 0 - leave tracking unchanged
Enable = 1 - tracking enabled
Disable = 2 - tracking disabled

Example:

EDTDTrackingStatus TrackingStatus = EDTDTrackingStatus::Enable;

enum class EDTDLogLevel : uint8

SDK logging level.

Header file:

#include "DTDAnalytics/Public/DTDLogLevel.h"

Values:

Unknown = 0 - leave logging level unchanged
No = 1 - logging disabled
Error = 2 - logging of errors
Warning = 3 - logging of warnings and errors
Info = 4 - logging of information messages, warnings and errors
Debug = 5 - logging of debugging messages, informational messages, warnings and errors

Example:

EDTDLogLevel LogLevel = EDTDLogLevel::Info;

enum class EDTDAccrualType : uint8

Types of resource accumulation.

Header file:

#include "DTDAnalytics/Public/DTDAccrualType.h"

Values:

Earned = 0 - earned resources
Bought = 1 - purchased resources

Example:

EDTDAccrualType AccrualType = EDTDAccrualType::Earned;

enum class EDTDSocialNetwork : uint8

Predefined social media.

Header file:

#include "DTDAnalytics/Public/DTDSocialNetwork.h"

Values:

Facebook = 0
Vkontakte = 1
Twitter = 2
Googleplus = 3
Whatsapp = 4
Viber = 5
Evernote = 6
Googlemail = 7
Linkedin = 8
Pinterest = 9
Reddit = 10
Renren = 11
Tumblr = 12
Qzone = 13

Example:

EDTDSocialNetwork SocialNetwork = EDTDSocialNetwork::Facebook;

enum class EDTDGender: uint8

User gender.

Header file:

#include "DTDAnalytics/Public/DTDGender.h"

Values:

Unknown = 0
Male = 1
Female = 2

Example:

EDTDGender Gender = EDTDGender::Female;

enum class EDTDReferralProperty : uint8

Referral properties.

Header file:

#include "DTDAnalytics/Public/DTDReferralProperty.h"

Values:

Source = 0
Medium = 1
Content = 2
Campaign = 3
Term = 4

Example:

EDTDReferralProperty ReferralProperty = EDTDReferralProperty::Source;

struct FDTDOptionalInt32

An optional parameter of int32 type

Header file:

#include "DTDAnalytics/Public/DTDOptionalInt32.h"

For your convenience, we implemented the conversion constructor:

FDTDOptionalInt32(int32 value) : HasValue(true), Value(value) {}

Example:

FDTDOptionalInt32 OptionalParameter = 1;

struct FDTDOptionalString

An optional parameter of FString type.

Header file:

#include "DTDAnalytics/Public/DTDOptionalString.h

For your convenience, we implemented the conversion constructor:

FDTDOptionalString(FString value) : HasValue(true), Value(value) {}

Example:

FDTDOptionalString OptionalParameter = FString("StringValue");

struct FDTDAnalyticsConfiguration

Configuration of the analytics plugin.

Header file:

#include "DTDAnalytics/Public/DTDAnalyticsConfiguration.h"

Example:

FDTDAnalyticsConfiguration config;
config.LogLevel = EDTDLogLevel::Debug;
config.CurrentLevel = 3;
config.UserId = FString("CUID");
config.ApplicationVersion = FString("1.2.3");
config.TrackingAvailability = EDTDTrackingStatus::Enable;

FDTDCustomEventParams

Custom parameters of a custom event.

Header file:

#include "DTDAnalytics/Public/DTDCustomEventParams.h"

Warning: avoid duplicating keys in parameters of different types, because in native code dictionaries are merged into a single dictionary [string: any].

Example:

FDTDCustomEventParams params;
params.BoolParameters.Add("BoolKey", true);
params.FloatParameters.Add("FloatKey", 3.3);
params.IntParameters.Add("IntKey");
params.StringParameters.Add("StringKey", "StringValue");

struct FDTDStartProgressionEventParams

Parameters of the progression start event.

Header file:

#include "DTDAnalytics/Public/DTDStartProgressionEventParams.h"

Example:

FDTDStartProgressionEventParams params;
params.Difficulty = 3;
params.Source = FString("Source");

struct FDTDFinishProgressionEventParams

Parameters of the progression completion event.

Header file:

#include "DTDAnalytics/Public/DTDFinishProgressionEventParams.h"

Example:

FDTDFinishProgressionEventParams params;
params.Duration = 200;
params.SuccessfulCompletion = true;
params.Earned.Add("CurrencyName1", 1);
params.Spent.Add("CurrencyName2", 2);

Delegates

Header file:

#include "DTDAnalytics/Public/DTDDelegates.h"

Definitions:

DECLARE_DELEGATE_OneParam(FDTDLongListenerDelegate, int64);
DECLARE_DELEGATE_OneParam(FDTDGetterStringDelegate, const FString&);
DECLARE_DELEGATE_OneParam(FDTDGetterBoolDelegate, bool);
DECLARE_DELEGATE_OneParam(FDTDGetterIntDelegate, int32);
DECLARE_DELEGATE_OneParam(FDTDGetterLongDelegate, int64);
DECLARE_DELEGATE_OneParam(FDTDGetterGenderDelegate, EDTDGender);
DECLARE_DELEGATE_TwoParams(FDTDGetterOptionalStringDelegate, bool, const FString&);
DECLARE_DELEGATE_TwoParams(FDTDGetterOptionalBoolDelegate, bool, bool);
DECLARE_DELEGATE_TwoParams(FDTDGetterOptionalFloatDelegate, bool, float);
DECLARE_DELEGATE_TwoParams(FDTDGetterOptionalLongDelegate, bool, int64);
DECLARE_DELEGATE_ThreeParams(FDTDGetterOptionalStringWithKeyDelegate, bool, const FString&, const FString&);
DECLARE_DELEGATE_ThreeParams(FDTDGetterOptionalBoolWithKeyDelegate, bool, const FString&, bool);
DECLARE_DELEGATE_ThreeParams(FDTDGetterOptionalFloatWithKeyDelegate, bool, const FString&, float);
DECLARE_DELEGATE_ThreeParams(FDTDGetterOptionalLongWithKeyDelegate, bool, const FString&, int64);

SDK initialization

SDK initialization without parameters:

UDTDAnalyticsBPLibrary::Initialize("AppKey");

SDK initialization with parameters:

FDTDAnalyticsConfiguration config;
config.LogLevel = EDTDLogLevel::Debug;
config.CurrentLevel = 3;
config.UserId = FString("CUID");
config.ApplicationVersion = FString("1.2.3");
config.TrackingAvailability = EDTDTrackingStatus::Enable;
UDTDAnalyticsBPLibrary::InitializeWithConfig("AppKey", config);

Setting up events

Secondary methods

Ad impression

The event is used for individual tracking of ad revenue on user devices. The method is used if there are CPI data available on the client device (they can be obtained from the ad network SDK).

Do not apply this method if you use ad networks that utilize the server-server protocol for sending ad revenue data (ironSource, AppLovin MAX, and Fyber networks) and you already set up this method of data collection because if you use both data sources, your revenue data may be duplicated.

Parameter

Type

Restrictions

Description

Parameter

Type

Restrictions

Description

Parameter

Type

Restrictions

Description

The event is used to track connections to social media channels.

Use the following constants to specify a social network:

.facebook, .vkontakte , .twitter, .googleplus, .whatsapp, .viber, .evernote, .googlemail, .linkedin, .pinterest, .qzone, .reddit, .renren, .tumblr

Or create an object with the desired social media name.

Use the following constants to specify a social network:

.facebook, .vkontakte , .twitter, .googleplus, .whatsapp, .viber, .evernote, .googlemail, .linkedin, .pinterest, .qzone, .reddit, .renren, .tumblr

Or create an object with the desired social media name.

Use the following constants to specify a social network:

DTDSocialNetwork.facebook, DTDSocialNetwork.vkontakte , DTDSocialNetwork.twitter, DTDSocialNetwork.googleplus, DTDSocialNetwork.whatsapp, DTDSocialNetwork.viber, DTDSocialNetwork.evernote, DTDSocialNetwork.googlemail, DTDSocialNetwork.linkedin, DTDSocialNetwork.pinterest, DTDSocialNetwork.qzone, DTDSocialNetwork.reddit, DTDSocialNetwork.renren, DTDSocialNetwork.tumblr

Or create an object with the desired social media name.

Use the following constants to specify a social network:

Or create an object with the desired social media name:

Use the following constants to specify a social network:

Or create an object with the desired social media name:

Or use special method for custom social network:

Track social media posts and analyze their effectiveness and virality. Pass the event after the post has been approved by social media.

Referrer

If you have referral information, you can pass it using the following method:

Force dispatch of accumulated events

To send an event packet before it is full (10 events, by default) or before the end of the period of its formation (2 minutes, by default), you can use immediate dispatch.

We don’t recommend using this method unless absolutely necessary! When the Real payment event is created, the forced dispatch of the packet occurs automatically.

Setters & Getters

When working with getters you should take into account that the new devtodev SDK is completely asynchronous. The execution result must be processed within the completionHandler.

All set and get methods need to be called only after the initialization of the SDK.

It is also worth remembering that the SDK will call the callback in background queues, so we recommend that you transfer the processing of return values to the queue you need.

For example:

This method denies/allows tracking of user data and also implements the right to be forgotten in accordance with the requirements of the GDPR.

When this method is called with the 'false' value, the SDK sends a command to the server to delete all personal user data that was collected by devtodev in this application, blocking further user data collection.

The user will remain in the devtodev system only as an impersonal unit in the previously aggregated metrics.

If it is set to ‘true', tracking can be enabled again. In this case, the user will be considered new.

To enable/disable user tracking by the devtodev system. Bool type.

Getting device ID

Get device ID. String type.

Getting the devtodev SDK version

Get the version of the integrated devtodev SDK. String type.

Retrieving the saved state of the user tracking permission by the devtodev system. See “Setting User Tracking Status”. Bool type.

Getting devtodev ID

devtodev ID is the primary numeric identifier for the device/user account in the devtodev database. Using devtodev ID, you are sure to find the user in devtodev.

The identifier will be received from the server some time after the initialization of the SDK.

If you have set counting by users, a separate devtodev id will be issued for each device user.

To obtain the devtodev ID, you need to pass the listener to DTDAnalytics:

The delegate must implement the func didReceiveDevtodevId(with devtodevId: Int)

The didReceiveDevtodevId method will be called with every ID change on the server side.

To obtain the devtodev ID, you need to pass the listener to DTDAnalytics:

The delegate must implement the (void)didReceiveDevtodevIdWith:(NSInteger)devtodevId;

The didReceiveDevtodevId method will be called with every ID change on the server side.

To obtain the devtodev ID, you need to pass the DTDIdentifiersListener listener to DTDAnalytics:

The didReceiveDevtodevId method will be called with every ID change on the server side.

To obtain the devtodev ID, you need to pass the DTDIdentifiersListener listener delegate to DTDAnalytics:

The delegate method will be called with every ID change on the server side.

To obtain the devtodev ID, you need to pass the DTDIdentifiersListener listener delegate to DTDAnalytics:

The delegate method will be called with every ID change on the server side.

Anti-cheat methods

Payment Validation

The devtodev service allows you to validate transactions to prevent fraud from influencing your statistics. For this, you need to integrate DTDAntiCheat module.

To validate the transaction you can use the verifyPayment(completionHandler: @escaping (DTDVerifyResponse) -> Void) method immediately during the transaction processing, e.g.:

extension Purchases: SKPaymentTransactionObserver {
    func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
        for transaction in transactions {
            switch transaction.transactionState {
                case .purchased:
                    DTDAntiCheat.verifyPayment { response in
                            switch response.receiptStatus {
                                case .receiptInternalError: 
                                  // your code
                                  break
                                case .receiptValid:
                                  // your code
                                  break
                                case .receiptSandbox:
                                  // your code
                                  break
                                case .receiptServerError:
                                  // your code
                                  break
                                case .receiptNotValid: 
                                  // your code
                                  break
                                @unknown default: break
                            }
                            SKPaymentQueue.default().finishTransaction(transaction)
                        }

                case .restored:
                    SKPaymentQueue.default().finishTransaction(transaction)

                case .failed:
                    SKPaymentQueue.default().finishTransaction(transaction)

                default:
                    break
            }
        }
    }
}

We strongly discourage you from using verifyPayment results for deciding on allowing or denying users to receive their purchases! Employ this method exclusively for preventing fraud transaction data from being sent to devtodev!

`DTDVerifyResponse`

The DTDVerifyResponse object returned while validating the transaction has two properties:

`DTDReceiptStatus`

The enum type returned as a result of validation can receive the following values:

We recommend calling the Real Currency Payment method in all cases except when you receive receiptNotValid or receiptSandbox as a result of the validation.

To validate the transaction you can use the (void)verifyPaymentCompletion:( void (^ _Nonnull)(DTDVerifyResponse * _Nonnull))completionHandler; method immediately during the transaction processing, e.g.:

- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)transactions{
    for(SKPaymentTransaction *transaction in transactions) {
        switch(transaction.transactionState){
            case SKPaymentTransactionStatePurchasing: {
                // Your code ...
                break;
            }

            case SKPaymentTransactionStatePurchased: {
                // Your code ...
                [DTDAntiCheat verifyPaymentCompletion:^(DTDVerifyResponse * _Nonnull response) {
                    switch ([response receiptStatus]) {
                        case ReceiptStatusReceiptInternalError: {

                            break;
                        }
                        case ReceiptStatusReceiptValid: {

                            break;
                        }
                        case ReceiptStatusReceiptSandbox: {

                            break;
                        }
                        case ReceiptStatusReceiptServerError: {

                            break;
                        }
                        case ReceiptStatusReceiptNotValid: {

                            break;
                        }
                    }
                }];
                break;
            }

            case SKPaymentTransactionStateRestored: {
                // Your code ...
                break;
            }

            case SKPaymentTransactionStateFailed: {
                // Your code ...
                break;
            }

            case SKPaymentTransactionStateDeferred: {
                // Your code ...
                break;
            }
        }
    }
}

`DTDVerifyResponse`

The DTDVerifyResponse object returned while validating the transaction has two properties:

`DTDReceiptStatus`

The enum type returned as a result of validation can receive the following values:

We recommend calling the Real Currency Payment method in all cases except when you receive receiptNotValid or receiptSandbox as a result of the validation.

When GooglePlay sends the transaction back to your onActivityResult, validate it by calling the following method: verifyPayment(receipt: String, signature: String, publicKey: String, completionHandler:(DTDVerifyResponse) -> Unit) immediately during the transaction processing, e.g.:

DTDAntiCheat.verifyPayment("receipt", "signature", "publickKey") { dtdVerifyResponse ->
                val verificationResult = dtdVerifyResponse.verificationResult
                /* your code here */
                when (dtdVerifyResponse.receiptStatus) {
                    DTDReceiptStatus.ReceiptValid -> { /* your code here */ }
                    DTDReceiptStatus.ReceiptNotValid -> { /* your code here */ }
                    DTDReceiptStatus.ReceiptServerError -> { /* your code here */ }
                    DTDReceiptStatus.ReceiptInternalError -> { /* your code here */ }
                }
            }

`DTDVerifyResponse`

The DTDVerifyResponse object returned while validating the transaction has two properties:

`DTDReceiptStatus`

The enum type returned as a result of validation can receive the following values:

We recommend calling the Real Currency Payment method in all cases except when you receive receiptNotValid as a result of the validation.

devtodev sends a request for transaction verification to the payment platform and then forwards the answer to the app. To validate the transaction you can use theTask<DTDReceiptStatus> VerifyPayment(string: receipt) method. As an argument pass the PurchaseResults.ReceiptXml property. More information about it here.

Example of verification:

var result = await DTDAntiCheat.VerifyPayment("receipt");
switch (result)
{
    case DTDReceiptStatus.Valid:
        break;
    case DTDReceiptStatus.Invalid:
        break;
    case DTDReceiptStatus.ServerError:
        break;
    case DTDReceiptStatus.InternalError:
        break;
    default:
        throw new ArgumentOutOfRangeException();
}

We strongly discourage you from using VerifyPayment results for deciding on allowing or denying users to receive their purchases! Employ this method exclusively for preventing fraud transaction data from being sent to devtodev!

`DTDVerifyResponse`

The DTDVerifyResponse object returned while validating the transaction has two properties:

`DTDReceiptStatus`

The enum type returned as a result of validation can receive the following values:

We recommend calling the Real Currency Payment method in all cases except when you receive Invalid as a result of the validation.

Google Play

If you use Unity IAP for payment validation, call the following method: void VerifyPayment(string purchasedProduct, string publicKey, Action completionHandler)

Example:

public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
{
    DTDAntiCheat.VerifyPayment(e.purchasedProduct.receipt, yourPublicKey, result =>
    {
        if (result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptValid ||
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptInternalError || 
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptServerError)
        {
            // Code for valid result.
        }
    else
        {
            // Code for invalid result.
        }
    });
}

To validate data received from Google play, use void VerifyPayment(string receipt, string signature, string publicKey, Action completionHandler) when handling the transaction.

public void MyNativeCallback (string receipt, string signature, string publicKey)
{
    DTDAntiCheat.VerifyPayment(receipt, signature,publicKey, result =>
    {
        if (result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptValid ||
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptInternalError || 
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptServerError)
        {
            // Code for valid result.
        }
        else
        {
            // Code for invalid result.
        }
    });
}

Here's how to find your app's public key for licensing (for Google Play platform only, for other platforms the publicKey is not used):

Go to the Google Play Console and sign in. Make sure that you sign in to the account from which the app you are licensing is published (or will be published).
In the app details page, locate the Services & APIs link and click it.
In the Services & APIs page, locate the Licensing & In-App Billing section. Your public key for licensing is given in the Your License Key For This Application field.

App Store

If you use Unity IAP for payment validation, call the following method: void VerifyPayment(string purchasedProduct, Action completionHandler)

public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
{
    DTDAntiCheat.VerifyPayment(e.purchasedProduct.receipt, result =>
    {
        if (result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptValid ||
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptInternalError || 
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptServerError)
        {
            // Code for valid result.
        }
        else
        {
            // Code for invalid result.
        }
    });
}

Windows Store (UWP)

If you use Unity IAP for payment validation, call the following method: void VerifyPayment(string purchasedProduct, Action completionHandler)

public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
{
    DTDAntiCheat.VerifyPayment(e.purchasedProduct.receipt, result =>
    {
        if (result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptValid ||
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptInternalError || 
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptServerError)
        {
            // Code for valid result.
        }
        else
        {
            // Code for invalid result.
        }
    });
}

N.B. You can pass a native XML recipe to the purchasedProduct argument.

`DTDVerifyResponse`

The DTDVerifyResponse object returned while validating the transaction has two properties:

`DTDReceiptStatus`

The enum type returned as a result of validation can receive the following values:

We recommend calling the Real Currency Payment method in all cases except when you receive receiptNotValid or receiptSandbox as a result of the validation.

Push notifications

Android

Android Push Notifications

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`)

iOS

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)

The DTDMessaging plugin will not work without the DTDAnalytics main analytics plugin.

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.

The user can change the allowed parameters at any time in the notification settings.

Possible values:

DTDNotificationOptionProvisional - Provisional push notifications appear in the user's Notification Center, but not on the lock screen. This type of push notification does not have to be explicitly allowed by the user. Start submitting them as soon as the user installs and runs your application. However, the user can also opt in/opt out of notifications, but they will need to do it explicitly.

This setting is used to prevent receiving push notification permission requests at the start, which is intrusive and most users refuse to receive them.

It is also important that when using the DTDNotificationOptionProvisional setting, the user will be able to subscribe to explicit notifications only from the notification center settings.

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

Note: If you disable automatic notification swizzling, DTDMessagingDelegate methods will not be called.

Windows (UWP)

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.

sealed partial class App : Application
{
  protected override void OnLaunched(LaunchActivatedEventArgs e)
  {
    // Your code...
    DTDMessaging.HandleActivatedEvent(e);
  }
  
  protected override void OnActivated(IActivatedEventArgs args)
  {
      // Your code...
      DTDMessaging.HandleActivatedEvent(args);
  }
}

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

Add Background Tasks to the Declarations tab and mark it as System Event. After that enter DevToDev.Background.ToastNotificationBackgroundTask to the Entry Point field.
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

For the DevToDev.Messaging package functioning you need to have the main DevToDev.Analytics package installed. Initialize the SDK before initializing messages. You can read about it in more detail in the SDK initialization section.

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

DTDMessaging.SetMessagingEnabling(true);

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:

DTDMessaging.OnTokenReceived += token => { /* Your code... */ };

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

DTDMessaging.OnTokenFailed += error => { /* Your code... */ };

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:

DTDMessaging.OnMessageReceived += messageData => { /* Your code... */ };

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:

DTDMessaging.OnMessageActivated += messageAction => { /* Your code with token. */ };

Where messageAction is DevToDev.Messaging.DTDMessageAction class instance:

/// <summary>
/// The class contains information about notification's action.
/// </summary>
public sealed class DTDMessageAction
{
    /// <summary>
    /// Action type.
    /// Can be: Open, Url, Share, DeepLink.
    /// </summary>
    public DTDMessageActionType ActionType { get; }

    /// <summary>
    /// Action string.
    /// </summary>
    public string ActionString { get; }

    /// <summary>
    /// Activated button ID.
    /// </summary>
    public string ButtonId { get; }

    /// <summary>
    /// Activated button's text.
    /// </summary>
    public string ButtonText { get; }

    /// <summary>
    /// Notification data.
    /// </summary>
    public IReadOnlyDictionary<string, string> MessageData { get; }
  }

5. Disabling

Call the method to turn notifications off:

DTDMessaging.SetMessagingEnabling(false);

Unreal Engine

Plugin installation

The SDK can be found in the devtodev . Download the latest release of the . 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:

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):

Data types

`class UDTDMessagingBPLibrary`

A class that implements analytic methods.

Header file:

`enum class EDTDNotificationActionType : uint8`

Notification action type

Header file:

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:

`struct FDTDNotificationAction`

Notification action data container.

Header file:

`enum class EDTDIOSNotificationOptions : uint8`

iOS only

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:

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.

Provisional - Provisional push notifications are shown in the User Notification Center but not on the lock screen. This type of push notification doesn’t require an explicit opt-in from the user. You can start sending them as soon as the user installs and launches your app. However, the user can also explicitly enable/disable your notifications.

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:

Delegates:

Initialization

Notification module initialization:

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.

`GetAvailability`

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

`GetToken`

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

`SetTokenListener`

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

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

`SetNotificationReceiveListener`

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

`SetInvisibleNotificationReceiveListener`

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

`SetNotificationActionListener`

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

`IOSSetNotificationOptions`

iOS only

Set notification parameters.

An int32 type value is used as an argument of this method. However, this argument should be calculated by using enumerators of EDTDIOSNotificationOptions and bitwise OR operator.

Unreal Engine

Plugin installation

Unzip the DTDAnalytics.zip archive to the Plugins folder of your project.

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

Example:

PublicDependencyModuleNames.Add("DTDAnalytics");

Data types

class UDTDAnalyticsLibrary

A class that implements analytic methods.

Header file:

#include "DTDAnalytics/Public/DTDAnalyticsBPLibrary.h"

class UDTDUserCardLibrary

A class that implements user card methods.

The class header:

#include "DTDAnalytics/Public/DTDUserCardBPLibrary.h"

enum class EDTDTrackingStatus : uint8

SDK tracking status.

Header file:

#include "DTDAnalytics/Public/DTDTrackingStatus.h"

Values:

Unknown = 0 - leave tracking unchanged
Enable = 1 - tracking enabled
Disable = 2 - tracking disabled

Example:

EDTDTrackingStatus TrackingStatus = EDTDTrackingStatus::Enable;

enum class EDTDLogLevel : uint8

SDK logging level.

Header file:

#include "DTDAnalytics/Public/DTDLogLevel.h"

Values:

Unknown = 0 - leave logging level unchanged
No = 1 - logging disabled
Error = 2 - logging of errors
Warning = 3 - logging of warnings and errors
Info = 4 - logging of information messages, warnings and errors
Debug = 5 - logging of debugging messages, informational messages, warnings and errors

Example:

EDTDLogLevel LogLevel = EDTDLogLevel::Info;

enum class EDTDAccrualType : uint8

Types of resource accumulation.

Header file:

#include "DTDAnalytics/Public/DTDAccrualType.h"

Values:

Earned = 0 - earned resources
Bought = 1 - purchased resources

Example:

EDTDAccrualType AccrualType = EDTDAccrualType::Earned;

enum class EDTDSocialNetwork : uint8

Predefined social media.

Header file:

#include "DTDAnalytics/Public/DTDSocialNetwork.h"

Values:

Facebook = 0
Vkontakte = 1
Twitter = 2
Googleplus = 3
Whatsapp = 4
Viber = 5
Evernote = 6
Googlemail = 7
Linkedin = 8
Pinterest = 9
Reddit = 10
Renren = 11
Tumblr = 12
Qzone = 13

Example:

EDTDSocialNetwork SocialNetwork = EDTDSocialNetwork::Facebook;

enum class EDTDGender: uint8

User gender.

Header file:

#include "DTDAnalytics/Public/DTDGender.h"

Values:

Unknown = 0
Male = 1
Female = 2

Example:

EDTDGender Gender = EDTDGender::Female;

enum class EDTDReferralProperty : uint8

Referral properties.

Header file:

#include "DTDAnalytics/Public/DTDReferralProperty.h"

Values:

Source = 0
Medium = 1
Content = 2
Campaign = 3
Term = 4

Example:

EDTDReferralProperty ReferralProperty = EDTDReferralProperty::Source;

struct FDTDOptionalInt32

An optional parameter of int32 type

Header file:

#include "DTDAnalytics/Public/DTDOptionalInt32.h"

Member

Type

Description

For your convenience, we implemented the conversion constructor:

FDTDOptionalInt32(int32 value) : HasValue(true), Value(value) {}

Example:

FDTDOptionalInt32 OptionalParameter = 1;

struct FDTDOptionalString

An optional parameter of FString type.

Header file:

#include "DTDAnalytics/Public/DTDOptionalString.h

Member

Type

Description

For your convenience, we implemented the conversion constructor:

FDTDOptionalString(FString value) : HasValue(true), Value(value) {}

Example:

FDTDOptionalString OptionalParameter = FString("StringValue");

struct FDTDAnalyticsConfiguration

Configuration of the analytics plugin.

Header file:

#include "DTDAnalytics/Public/DTDAnalyticsConfiguration.h"

Member

Type

Description

Example:

FDTDAnalyticsConfiguration config;
config.LogLevel = EDTDLogLevel::Debug;
config.CurrentLevel = 3;
config.UserId = FString("CUID");
config.ApplicationVersion = FString("1.2.3");
config.TrackingAvailability = EDTDTrackingStatus::Enable;

FDTDCustomEventParams

Custom parameters of a custom event.

Header file:

#include "DTDAnalytics/Public/DTDCustomEventParams.h"

Member

Type

Description

Warning: avoid duplicating keys in parameters of different types, because in native code dictionaries are merged into a single dictionary [string: any].

Example:

FDTDCustomEventParams params;
params.BoolParameters.Add("BoolKey", true);
params.FloatParameters.Add("FloatKey", 3.3);
params.IntParameters.Add("IntKey");
params.StringParameters.Add("StringKey", "StringValue");

struct FDTDStartProgressionEventParams

Parameters of the progression start event.

Header file:

#include "DTDAnalytics/Public/DTDStartProgressionEventParams.h"

Member

Type

Description

Example:

FDTDStartProgressionEventParams params;
params.Difficulty = 3;
params.Source = FString("Source");

struct FDTDFinishProgressionEventParams

Parameters of the progression completion event.

Header file:

#include "DTDAnalytics/Public/DTDFinishProgressionEventParams.h"

Member

Type

Description

Example:

FDTDFinishProgressionEventParams params;
params.Duration = 200;
params.SuccessfulCompletion = true;
params.Earned.Add("CurrencyName1", 1);
params.Spent.Add("CurrencyName2", 2);

Delegates

Header file:

#include "DTDAnalytics/Public/DTDDelegates.h"

Definitions:

DECLARE_DELEGATE_OneParam(FDTDLongListenerDelegate, int64);
DECLARE_DELEGATE_OneParam(FDTDGetterStringDelegate, const FString&);
DECLARE_DELEGATE_OneParam(FDTDGetterBoolDelegate, bool);
DECLARE_DELEGATE_OneParam(FDTDGetterIntDelegate, int32);
DECLARE_DELEGATE_OneParam(FDTDGetterLongDelegate, int64);
DECLARE_DELEGATE_OneParam(FDTDGetterGenderDelegate, EDTDGender);
DECLARE_DELEGATE_TwoParams(FDTDGetterOptionalStringDelegate, bool, const FString&);
DECLARE_DELEGATE_TwoParams(FDTDGetterOptionalBoolDelegate, bool, bool);
DECLARE_DELEGATE_TwoParams(FDTDGetterOptionalFloatDelegate, bool, float);
DECLARE_DELEGATE_TwoParams(FDTDGetterOptionalLongDelegate, bool, int64);
DECLARE_DELEGATE_ThreeParams(FDTDGetterOptionalStringWithKeyDelegate, bool, const FString&, const FString&);
DECLARE_DELEGATE_ThreeParams(FDTDGetterOptionalBoolWithKeyDelegate, bool, const FString&, bool);
DECLARE_DELEGATE_ThreeParams(FDTDGetterOptionalFloatWithKeyDelegate, bool, const FString&, float);
DECLARE_DELEGATE_ThreeParams(FDTDGetterOptionalLongWithKeyDelegate, bool, const FString&, int64);

SDK initialization

SDK initialization without parameters:

Member

Type

Description

UDTDAnalyticsBPLibrary::Initialize("AppKey");

SDK initialization with parameters:

Member

Type

Description

FDTDAnalyticsConfiguration config;
config.LogLevel = EDTDLogLevel::Debug;
config.CurrentLevel = 3;
config.UserId = FString("CUID");
config.ApplicationVersion = FString("1.2.3");
config.TrackingAvailability = EDTDTrackingStatus::Enable;
UDTDAnalyticsBPLibrary::InitializeWithConfig("AppKey", config);

Basic methods

Tutorial

The event allows you to track tutorial completion and identify the stages where you lose new users.

We recommend tracking the starting point (value -1) before beginning the first tutorial stage, then passing the counting number of every completed stage after its completion (integers larger than 0), and at the end, marking the moment of the last tutorial stage completion (value -2).

If your app has an option of skipping the tutorial and the user has used it, then it’s necessary to send a refusal value (value 0) only.

DTDAnalytics.tutorial(step: 1)

The method takes on the step value with an integer type.

Value

Meaning

[DTDAnalytics tutorialStep:1];

The method takes on the step value with an integer type.

Value

Meaning

DTDAnalytics.tutorial(1)

The method takes on the step value with an integer type.

Value

Meaning

DTDAnalytics.Tutorial(1);

The method takes on the step value with an integer type.

Value

Meaning

DTDAnalytics.Tutorial(1);

The method takes on the step value with an int base type.

Value

Meaning

window.devtodev.tutorial(1)

The method takes on the step value with an integer type.

Value

Meaning

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::Tutorial(1);

The method takes on the step value with an int32 base type.

Value

Meaning

Level up

The event allows you to analyze the distribution of players over different game levels, monitor the in-game currency balance by levels. You can find more information about the right moment to use LevelUp event here.

The event should be dispatched right after the level-up. The number of the level reached is passed to the level parameter.

DTDAnalytics.levelUp(level: 2)

To monitor the average account balance of in-game currency by the end of each level, dispatch in-game currencies (resources) names and their amounts to the method signature:

let balance: [String: Int] = ["Currency name 1": 100, "Currency name 2": 10]
DTDAnalytics.levelUp(level: 2, balances: balance)

Attention! The number of tracked in-game currencies or resources (their unique names) should not exceed 30 at all times.

Parameter

Type

Restrictions

Description

The event should be dispatched right after the level-up. The number of the level reached is passed to the level parameter.

[DTDAnalytics levelUp:2];

To monitor the average account balance of in-game currency by the end of each level, dispatch in-game currencies (resources) names and their amounts to the method signature:

NSDictionary *balance = @{@"Currency name 1": @100, @"Currency name 2": @10};
[DTDAnalytics levelUp:2 withBalances:balance];

Attention! The number of tracked in-game currencies or resources (their unique names) should not exceed 30 at all times.

Parameter

Type

Restrictions

Description

The event should be dispatched right after the level-up. The number of the level reached is passed to the level parameter.

DTDAnalytics.levelUp(2)

To monitor the average account balance of in-game currency by the end of each level, dispatch in-game currencies (resources) names and their amounts to the method signature:

val balance = mapOf("Currency name 1" to 100L, "Currency name 2" to 10L)
DTDAnalytics.levelUp(2, balance)

Attention! The number of tracked in-game currencies or resources (their unique names) should not exceed 30 at all times.

Parameter

Type

Restrictions

Description

The event should be dispatched right after the level-up. The number of the level reached is passed to the level parameter.

DTDAnalytics.LevelUp(2);

To monitor the average account balance of in-game currency by the end of each level, dispatch in-game currencies (resources) names and their amounts to the method signature:

var balance = new Dictionary<string, long>();
balance.Add("Currency name 1", 100);
balance.Add("Currency name 2", 200);
DTDAnalytics.LevelUp(2, balance);

Attention! The number of tracked in-game currencies or resources (their unique names) should not exceed 30 at all times.

Parameter

Type

Restrictions

Description

The event should be dispatched right after the level-up. The number of the level reached is passed to the level parameter.

DTDAnalytics.LevelUp(level: 2)

To monitor the average account balance of in-game currency by the end of each level, dispatch in-game currencies (resources) names and their amounts to the method signature:

var balance = new Dictionary<string, long>();
balance.Add("Currency name 1", 100);
balance.Add("Currency name 2", 200);
DTDAnalytics.LevelUp(level: 2, resources: balance);

Attention! The number of tracked in-game currencies or resources (their unique names) should not exceed 30 at all times.

Parameter

Type

Restrictions

Description

The event should be dispatched right after the level-up. The number of the level reached is passed to the level parameter.

devtodev.levelUp(2)

You can send and track the following data along with the level values: an average amount of the in-game currency by the end of the level, user spendings on the level, and amounts of purchased or earned in-game currency/resources. Unfortunately, Web SDK doesn’t allow to automatically calculate spending and receiving of the in-game currency/resources while users are passing the level (data accumulation on the Web might be inaccurate as users might utilize multiple browsers and devices, as well as erase local browser data).

var balance = {
                "Currency name 1" : 100,
                "Currency name 2" : 200
}
var spent = {
                "Currency name 2" : 1
}
var earned = {
                                
                "Currency name 1" : 5
}
var bought = {
                "Currency name 1" : 50,
                "Currency name 2" : 30
}
window.devtodev.levelUp(2, balance, spent,  earned, bought)

Attention! The number of tracked in-game currencies or resources (their unique names) should not exceed 30 at all times.

Parameter

Type

Restrictions

Description

The event should be dispatched right after the level-up. The number of the level reached is passed to the level parameter.

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::LevelUp(2);

To monitor the average account balance of in-game currency by the end of each level, dispatch in-game currencies (resources) names and their amounts to the method signature:

Attention! The number of tracked in-game currencies or resources (their unique names) should not exceed 30 at all times.

Parameter

Type

Restrictions

Description

TMap<FString, int64> balance;
balance.Add("CurrencyName", 123);
UDTDAnalyticsBPLibrary::LevelUpWithBalance(2, balance);

Current Balance

To track the average balance of in-game currency disregarding the level up event, pass the list of in-game currency (resource) names and their amount to the method signature:

let balance: [String: Int] = ["Currency name 1": 100, "Currency name 2": 10]
DTDAnalytics.currentBalance(balance: balance)

 NSDictionary *balance = @{@"Currency name 1": @100, @"Currency name 2": @10};
 [DTDAnalytics currentBalanceWithBalance:balance];

val balance = mapOf("Currency name 1" to 100L, "Currency name 2" to 10L)
DTDAnalytics.currentBalance(balance)

var balance = new Dictionary<string, long>();
balance.Add("Currency name 1", 100);
balance.Add("Currency name 2", 200);
DTDAnalytics.CurrentBalance(balance);

var balance = new Dictionary<string, long>();
balance.Add("Currency name 1", 100);
balance.Add("Currency name 2", 200);
DTDAnalytics.CurrentBalance(balance);

var balance = {
                "Currency name 1" : 100,
                "Currency name 2" : 10
}
window.devtodev.currentBalance(balance);

Parameter

Type

Restrictions

Description

TMap<FString, int64> balance;
balance.Add("CurrencyName", 123);
UDTDAnalyticsBPLibrary::CurrentBalance(balance);

Currency Accrual

You need to dispatch the event after every game account balance refill if you want to track the average in-game currency amount acquired or earned by the players for a certain timeframe or during a level playthrough.

DTDAnalytics.currencyAccrual(currencyName: "Currency name 1", 
                             currencyAmount: 100, 
                             source: "Source name", 
                             accrualType: .earned)

Parameter

Type

Restrictions

Description

acrualType can receive one of the following values:

public enum DTDAccrualType: Int {
    case earned = 0
    case bought = 1
}

[DTDAnalytics currencyName:@"Currency name 1"
              currencyAmount:100
              source:@"Source name"
              accrualType:DTDAccrualTypeEarned];

Parameter

Type

Restrictions

Description

acrualType can receive one of the following values:

typedef enum DTDAccrualType: NSUInteger {
DTDAccrualTypeEarned = 0,
DTDAccrualTypeBought = 1,
} DTDAccrualType;

DTDAnalytics.currencyAccrual(currencyName: "Currency name 1", 
                             currencyAmount: 100, 
                             source: "Source name", 
                             accrualType: DTDAccrualType.Earned)

Parameter

Type

Restrictions

Description

accrualType can receive one of the following values:

enum class DTDAccrualType(val value: Long) {
    Earned(0L),
    Bought(1L);
}

DTDAnalytics.CurrencyAccrual(
    currencyName: "Currency name 1",
    currencyAmount: 100,
    source: "Source name",
    accrualType: DTDAccrualType.Earned);

Parameter

Type

Restrictions

Description

AccrualType can receive one of the following values:

enum DTDAccrualType : long
{
    Earned = 0L,
    Bought = 1L
}

DTDAnalytics.CurrencyAccrual(currencyName: "Currency name 1", 
                             currencyAmount: 100, 
                             source: "Source name", 
                             accrualType: DTDAccrualType.Earned)

Parameter

Type

Restrictions

Description

AccrualType can receive one of the following values:

public enum DTDAccrualType
{
  Earned = 0,
  Bought = 1
}

window.devtodev.CurrencyAccrual(
                                currencyName,
                                currencyAmount,
                                source,
                                accrualType)

Parameter

Type

Restrictions

Description

Example:

window.devtodev.currencyAccrua(
                                "Currency name 1",
                                100,
                                "Source name",
                                0)

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::CurrencyAccrual("CurrencyName", 12, "Source", EDTDAccrualType::Bought);

Virtual Currency Payment

Pass this event after every purchase if you want to track in-game currency spends and items’ popularity. You can apply this event to both games and any apps with virtual currency.

DTDAnalytics.virtualCurrencyPayment(purchaseId: "Purchase ID",
                                    purchaseType: "Purchase type",
                                    purchaseAmount: 100,
                                    purchasePrice: 10,
                                    purchaseCurrency: "Purchase currency")

In case the item is sold for more than one currency/resource, you need to build a dictionary with all the names and amounts of the currencies/resources.

let resources: [String: Int] = ["Purchase currency name 1": 100, 
                                "Purchase currency name 2": 10]
DTDAnalytics.virtualCurrencyPayment(purchaseId: "Purchase ID",
                                    purchaseType: "Purchase Type",
                                    purchaseAmount: 100,
                                    resources: resources)

Parameter

Type

Restrictions

Description

[DTDAnalytics virtualCurrencyPaymentWithPurchaseId:@"Purchase ID"
                                      purchaseType:@"Purchase type"
                                    purchaseAmount:100
                                     purchasePrice:10
                                  purchaseCurrency:@"Purchase currency"];

In case the item is sold for more than one currency/resource, you need to build a dictionary with all the names and amounts of the currencies/resources.

NSDictionary *resources = @{@"Purchase currency name 1": @100,
                            @"Purchase currency name 2": @10};
[DTDAnalytics virtualCurrencyPaymentWithPurchaseId:@"Purchase ID"
                                      purchaseType:@"Purchase Type"
                                    purchaseAmount:100
                                         resources:resources];

Parameter

Type

Restrictions

Description

DTDAnalytics.virtualCurrencyPayment(purchaseId: "Purchase ID",
                                    purchaseType: "Purchase type",
                                    purchaseAmount: 100,
                                    purchasePrice: 10,
                                    purchaseCurrency: "Purchase currency")

In case the item is sold for more than one currency/resource, you need to build a dictionary with all the names and amounts of the currencies/resources.

val resources = mapOf("Purchase currency name 1" to 100,
                      "purchase Currency name 2" to 10)
DTDAnalytics.virtualCurrencyPayment(purchaseId: "Purchase ID",
                                    purchaseType: "Purchase Type",
                                    purchaseAmount: 100,
                                    resources: resources)

Parameter

Type

Restrictions

Description

DTDAnalytics.VirtualCurrencyPayment(
    purchaseId: "Purchase ID",
    purchaseType: "Purchase type",
    purchaseAmount: 100,
    purchasePrice: 10,
    purchaseCurrency: "Purchase currency");

In case the item is sold for more than one currency/resource, you need to build a dictionary with all the names and amounts of the currencies/resources.

var resources = new Dictionary<string, int>
{
    ["Purchase currency name 1"] = 100,
    ["purchase Currency name 2"] = 10
};
DTDAnalytics.VirtualCurrencyPayment(
    purchaseId: "Purchase ID",
    purchaseType: "Purchase Type",
    purchaseAmount: 100,
    resources: resources);

Parameter

Type

Restrictions

Description

DTDAnalytics.VirtualCurrencyPayment(purchaseId: "Purchase ID",
                                    purchaseType: "Purchase type",
                                    purchaseAmount: 100,
                                    purchasePrice: 10,
                                    purchaseCurrency: "Purchase currency")

In case the item is sold for more than one currency/resource, you need to build a dictionary with all the names and amounts of the currencies/resources.

var resources = new Dictionary<string, int>
{
    ["Purchase currency name 1"] = 100,
    ["purchase Currency name 2"] = 10
};
DTDAnalytics.VirtualCurrencyPayment(
    purchaseId: "Purchase ID",
    purchaseType: "Purchase Type",
    purchaseAmount: 100,
    resources: resources);

Parameter

Type

Restrictions

Description

window.devtodev.virtualCurrencyPayment(
                                purchaseId,
                                purchaseType,
                                purchaseAmount, 
                                purchasePrice,
                                purchaseCurrency)

In case the item is sold for more than one currency/resource, you need to build a dictionary with all the names and amounts of the currencies/resources.

var resources = {
                "Purchase currency name 1": 100,
                "purchase Currency name 2": 10
};
window.devtodev.virtualCurrencyPayment(
                "Purchase ID",
                "Purchase type",
                100, 
                resources)

Parameter

Type

Restrictions

Description

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::VirtualCurrencyPayment("PurchaseId", "PurchaseType", 2, 3, "CurrencyName");

In case the item is sold for more than one currency/resource, you need to build a dictionary with all the names (FString) and amounts of the currencies/resources (int32) .

Parameter

Type

Restrictions

var resources = new Dictionary<string, int>
{
    ["Purchase currency name 1"] = 100,
    ["purchase Currency name 2"] = 10
};
DTDAnalytics.VirtualCurrencyPayment(
    purchaseId: "Purchase ID",
    purchaseType: "Purchase Type",
    purchaseAmount: 100,
    resources: resources);

Real Payment

To track payments in a real currency, dispatch this event right after the system validates that the payment went through successfully. The event is fundamental and mandatory for all the app metrics related to monetization.

DTDAnalytics.realCurrencyPayment(orderId: "Order ID", 
                                 price: 12.5, 
                                 productId: "Product ID", 
                                 currencyCode: "USD")

Parameter

Type

Restrictions

Description

[DTDAnalytics realCurrencyPaymentWithOrderId:@"Order ID"
                                       price:12.5
                                   productId:@"Product ID"
                                currencyCode:@"USD"];

Parameter

Type

Restrictions

Description

DTDAnalytics.realCurrencyPayment(orderId: "Order ID", 
                                 price: 12.5, 
                                 productId: "Product ID", 
                                 currencyCode: "USD")

Parameter

Type

Restrictions

Description

How to find the transaction ID in GooglePlay transaction?

Find the INAPP_PURCHASE_DATA object In the JSON fields that are returned in the response data for a purchase order. A unique transaction identifier is the value of orderId property in INAPP_PURCHASE_DATA object. If the order is a test purchase made via the In-app Billing Sandbox, orderId property will be empty.

DTDAnalytics.RealCurrencyPayment(
    orderId: "Order ID",
    price: 12.5,
    productId: "Product ID",
    currencyCode: "USD");

Parameter

Type

Restrictions

Description

DTDAnalytics.RealCurrencyPayment(
    orderId: "Order ID",
    price: 12.5,
    productId: "Product ID",
    currencyCode: "USD");

Parameter

Type

Restrictions

Description

window.devtodev.realCurrencyPayment(
                                orderId,
                                price,
                                productId,
                                currencyCode)

Parameter

Type

Restrictions

Description

Parameter

Type

Restrictions

Description

1UDTDAnalyticsBPLibrary::RealCurrencyPayment("OrderId", 12.5, "ProductId", "USD");

By default (easy to change in the app’s settings) devtodev server invalidates transactions with previously-used identifiers. Besides, the server performs identifier checks by its outer appearance in order to avoid obvious fraud.

If you want to exclude fraud payments from your reports altogether, before creating ‘Real Currency Payment’ event, use devtodev anti-cheat feature.

Subscriptions

The described method is available beginning with version 2.1.0!

Tracking of subscriptions is now available for Apple App Store and Google Play only.

Please note that in order to track subscriptions, you need to do the following:

Call the subscriptionPayment method (described below)
Configure data transfer from the App Store Connect
Configure integration in the devtodev application settings.

To track your income from subscriptions, you need to call the following method at the moment of the subscription purchase even if the user signed up for a trial subscription: func subscriptionPayment(transaction: SKPaymentTransaction, product: SKProduct).

For example:

extension Purchases: SKPaymentTransactionObserver {
  func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
    for transaction in transactions { 
      switch transaction.transactionState {
      case .purchased:
          // Your code ...
          if let product = products?[transaction.payment.productIdentifier] {
             DTDAnalytics.subscriptionPayment(transaction: transaction, product: product)
          }
      case .restored:
          // Your code ...
      case .failed:
          // Your code ...
      default:
          // Your code ...
      }
    }
  }
}

Further user actions - renewal, unsubscription, etc. are tracked by using the data received from AppStore in the server-server format. You will need the corresponding setting for it.

Also, if you want to track changes in the status of the subscriptions purchased before devtodev SDK 2.0 integration, you need to transfer your history of previously purchased subscriptions to devtodev.

The SDK monitors the need for historical data to avoid sending out excessive queries to App Store. Use the DTDAnalytics.isRestoreTransactionHistoryRequiredmethod to check whether or not there is a need in sending out the information about the previously purchased subscriptions to devtodev. The method returns BOOL value.

An example of a purchase history query with verification of the need for it:

DTDAnalytics.isRestoreTransactionHistoryRequired { isNeedRestore in
  if isNeedRestore {
    DispatchQueue.main.async {
      SKPaymentQueue.default().restoreCompletedTransactions()
    }
  }
}

Use the DTDAnalytics.subscriptionHistory method to transfer the list of previously purchased subscriptions received from App Store.

If your project accounts users by user ID (not by device ID) and the device is used by more than one user, you need to filter the transaction history so that it will contain only those transactions that belong to the active user. Otherwise, subscriptions of all device users will be attributed to the user who was the first to launch the app after the integration of subscription tracking.

extension Purchases: SKPaymentTransactionObserver {
  func paymentQueueRestoreCompletedTransactionsFinished(_ queue: SKPaymentQueue) {
    // Your code ...
    let restoredTransactions = queue.transactions.filter { $0.transactionState == .restored }
    DTDAnalytics.subscriptionHistory(transactions: restoredTransactions)
  }
}

To recover the purchase history, the user should be logged in with his Apple ID. Be mindful of this before starting the recovering process.

Please note that in order to track subscriptions, you need to do the following:

Call the subscriptionPayment method (described below)
Configure data transfer from the App Store Connect
Configure integration in the devtodev application settings.

To track your income from subscriptions, you need to call the following method at the moment of the subscription purchase even if the user signed up for a trial subscription: (void)subscriptionPaymentWithTransaction:(SKPaymentTransaction * _Nonnull)transaction product:(SKProduct * _Nonnull)product;

For example:

- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)transactions{
    for(SKPaymentTransaction *transaction in transactions) {
        switch(transaction.transactionState){
            case SKPaymentTransactionStatePurchasing: {
                // Your code ...
                break;
            }

            case SKPaymentTransactionStatePurchased: {
                // Your code ...
                SKProduct *product = [_products objectForKey:transaction.payment.productIdentifier];
                if (product != nil) {
                    [DTDAnalytics subscriptionPaymentWithTransaction:transaction product:product];
                }
                break;
            }

            case SKPaymentTransactionStateRestored: {
                // Your code ...
                break;
            }

            case SKPaymentTransactionStateFailed: {
                // Your code ...
                break;
            }
                
            case SKPaymentTransactionStateDeferred: {
                // Your code ...
                break;
            }
        }
    }
}

Further user actions - renewal, unsubscription, etc. are tracked by using the data received from AppStore in the server-server format. You will need the corresponding setting for it.

The SDK monitors the need for historical data to avoid sending out excessive queries to App Store. Use the (void)isRestoreTransactionHistoryRequiredWithCompletionHandler:( void (^ _Nonnull)(BOOL))completionHandler; method to check whether or not there is a need in sending out the information about the previously purchased subscriptions to devtodev. The method returns BOOL value.

An example of a purchase history query with verification of the need for it:

[DTDAnalytics isRestoreTransactionHistoryRequiredWithCompletionHandler:^(BOOL isNeedRestore){
  if (isNeedRestore == true) {
    dispatch_async(dispatch_get_main_queue(), ^{
      [SKPaymentQueue.defaultQueue restoreCompletedTransactions];
    });
  }
}];

Use the (void)subscriptionHistoryWithTransactions:(NSArray<SKPaymentTransaction *> * _Nonnull)transactions; method to transfer the list of previously purchased subscriptions received from App Store.

-(void)paymentQueueRestoreCompletedTransactionsFinished:(SKPaymentQueue *)queue {
  NSMutableArray *restoredTransactions = [NSMutableArray new];
    for (SKPaymentTransaction *transaction in queue.transactions) {
      if (transaction.transactionState == SKPaymentTransactionStateRestored) {
        [restoredTransactions addObject:transaction];
      }
    }
  [DTDAnalytics subscriptionHistoryWithTransactions:restoredTransactions];
}

To recover the purchase history, the user should be logged in with his Apple ID. Be mindful of this before starting the recovering process.

Please note that in order to track subscriptions, you need to do the following:

Call the subscriptionPayment method (described below)
Configure data transfer from the Google Cloud Platform
Configure integration in the devtodev application settings.

Before sending a request for subscription from your app, during the creation of BillingFlowParams, to the setObfuscatedAccountId function of the BillingFlowParams.newBuilder() object insert obfuscatedAccountId obtained from DTDAnalytics.getObfuscatedAccountId.

Attention! The obfuscated identifier is returned asynchronously, outside of the calling thread!

Example:

DTDAnalytics.getObfuscatedAccountId { obfuscatedAccountId ->
        val flowParams: BillingFlowParams = BillingFlowParams.newBuilder()
                .setObfuscatedAccountId(obfuscatedAccountId)
                .build()
            
        val result = billingClient.launchBillingFlow(activity, flowParams)
}

To track your subscriptions, add this event immediately after the platform confirms that the subscription was approved by the user.

DTDAnalytics.subscriptionPayment(orderId: String,
                                   price: Double,
                               productId: String,
                            currencyCode: String);

How to find the transaction ID in GooglePlay transaction?

Further user actions - renewal, unsubscription, etc. are tracked by using the data received from Google Play in the server-server format. You will need the corresponding setting for it.

The subscriptionHistory method is used for matching users with subscribers who purchased their subscriptions before the SDK 2.0 integration. Otherwise, it will be impossible to establish the affiliation when it gets renewed or cancelled.

To get a list of active subscriptions call billingClient.queryPurchasesAsync. After successfully receiving a response from Google Play Services, pass it to DTDAnalytics.subscriptionHistory(purchaseList: List<String>).

purchaseList: List<String> purchaseList - a string containing list of json objects is passed to the DTDAnalytics.subscriptionHistory method. For the event to run, the json object must contain the following keys:

orderID - a unique transaction identifier
productID - a unique product identifier

The SDK monitors the need for historical data to avoid sending out excessive queries. Use the DTDAnalytics.isRestoreTransactionHistoryRequired method to check whether or not there is a need in sending out the information about the previously purchased subscriptions to devtodev. The method returns a Boolean value.

Attention! DTDAnalytics.isRestoreTransactionHistoryRequired is returned asynchronously, outside of the calling thread!

Example:

DTDAnalytics.isRestoreTransactionHistoryRequired { isNeedRestore ->
  if(isNeedRestore) {
    billingClient.queryPurchasesAsync(BillingClient.SkuType.SUBS) { billingResult, purchaseList ->
      if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
        val purchases = mutableListOf<String>()
        purchaseList.forEach { purchase -> purchases.add(purchase.originalJson) }
        DTDAnalytics.subscriptionHistory(purchases)
      }
    }
  }
}

Download and import the DTDSubscriptions package to your app.

For the DTDSubscriptions module to function you need the DTDAnalytics and Unity IAP modules.

You also need to create an AppleTangle file. Open the Unity editor menu and choose Window → Unity IAP → Receipt Validation Obfuscator (pic. 1).

In case you don’t use the IAP receipt validation, clear the input field under “2. Paste the key here:” and click Obfuscate Google Play Licence Key (pic. 2).

Initialize the DTDAnalytics module (see our instruction manual).
Add DTDSubscriptions.Initialize(IStoreController controller) to the OnInitialized method.

/// <summary>
/// Your IStoreListener implementation of OnInitialized.
/// </summary>
public void OnInitialized(IStoreController controller, IExtensionProvider extensions)
{
   DTDSubscriptions.Initialize(controller);
}

Restore purchase history in order for the module to function correctly.
If you use Google Play, after successful IAP initialization call the DTDSubscriptions.History() method.

To avoid excessive restoring of subscription history, use the DTDSubscriptions.IsRestoreTransactionHistoryRequired(Action<bool> resultCallback) method. If the resultCallback returns true, call the DTDSubscriptions.History() method.

Example:

public void OnInitialized(IStoreController controller, IExtensionProvider extensions)
{
#if UNITY_ANDROID     
     DTDSubscriptions.Initialize(controller);
     DTDSubscriptions.IsRestoreTransactionHistoryRequired((b) =>
     {
        if(b) DTDSubscriptions.History();
     });
#endif
}

If you use AppleStore, first set the DTDSubscriptions.IsRestoring property to true (this will filter out unwanted transactions). After restoring IAP transactions, call the DTDSubscriptions.History() method. After that, set the DTDSubscriptions.IsRestoring property to false.

Example:

public void OnInitialized(IStoreController controller, IExtensionProvider extensions)
{
    DTDSubscriptions.Initialize(controller);
if UNITY_STANDALONE_OSX || UNITY_IOS
    DTDSubscriptions.IsRestoring = true;
    extensions.GetExtension<IAppleExtensions>().RestoreTransactions(result =>
    {
        if (result)
        {
            DTDSubscriptions.IsRestoreTransactionHistoryRequired((b) =>
            {
                if (b) DTDSubscriptions.History();
            });
        }
        DTDSubscriptions.IsRestoring = false;
    });
#endif
}

Add a DTDSubscriptions.Payment(Product product) call to the ProcessPurchase method.

public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
{
   var product = e.purchasedProduct;
   DTDSubscriptions.Payment(product);
   return PurchaseProcessingResult.Complete;
}

Below you can see an example of the entire script:

using DevToDev.Subscriptions;
using UnityEngine;
using UnityEngine.Purchasing;

public class MyIAPManager : IStoreListener
{
    public IStoreController StoreController { get; private set; }

    public void InitializeIAPManager()
    {
        var builder = ConfigurationBuilder.Instance(StandardPurchasingModule.Instance());
        builder.AddProduct("example", ProductType.Subscription);
        UnityPurchasing.Initialize(this, builder);
    }

    /// <summary>
    /// Called when Unity IAP is ready to make purchases.
    /// </summary>
    public void OnInitialized(IStoreController controller, IExtensionProvider extensions)
    {
        StoreController = controller;
        DTDSubscriptions.Initialize(controller);
#if UNITY_ANDROID
        DTDSubscriptions.IsRestoreTransactionHistoryRequired((b) =>
        {
            if (b) DTDSubscriptions.History();
        });
#elif UNITY_STANDALONE_OSX || UNITY_IOS
        DTDSubscriptions.IsRestoring = true;
        extensions.GetExtension<IAppleExtensions>().RestoreTransactions(result =>
        {
            if (result)
            {
                DTDSubscriptions.IsRestoreTransactionHistoryRequired((b) =>
                {
                    if (b) DTDSubscriptions.History();
                });
            }
            DTDSubscriptions.IsRestoring = false;
        });
#endif
    }

    /// <summary>
    /// Called when Unity IAP encounters an unrecoverable initialization error.
    ///
    /// Note that this will not be called if Internet is unavailable; Unity IAP
    /// will attempt initialization until it becomes available.
    /// </summary>
    public void OnInitializeFailed(InitializationFailureReason error)
    {
        Debug.Log($"IAP initialization error {error.ToString()}");
    }

    /// <summary>
    /// Called when a purchase completes.
    ///
    /// May be called at any time after OnInitialized().
    /// </summary>
    public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs e)
    {
        var product = e.purchasedProduct;
        DTDSubscriptions.Payment(product);
        return PurchaseProcessingResult.Complete;
    }

    /// <summary>
    /// Called when a purchase fails.
    /// </summary>
    public void OnPurchaseFailed(Product i, PurchaseFailureReason p)
    {
        Debug.Log(p.ToString());
    }
}

Custom Events

If you want to track non-basic events, you can create custom events of your own. How you are going to apply them, depends solely on you.

DTDAnalytics.customEvent(eventName: "Event name")

If you want to pass custom parameters, use DTDCustomEventParameters class instance.

let parameters = DTDCustomEventParameters()
parameters.add(key: "key for string value", value: "string value")
parameters.add(key: "key for int value", value: 10)
parameters.add(key: "key for bool value", value: true)
parameters.add(key: "key for double value", value: 12.5)

DTDAnalytics.customEvent(eventName: "Event name", parameters: parameters)

Parameter

Type

Restrictions

Description

The following data types can be passed using the DTDCustomEventParameters object:

Type

Restrictions

[DTDAnalytics customEvent:@"Event name"];

If you want to pass custom parameters, use DTDCustomEventParameters class instance.

DTDCustomEventParameters *parameters = [[DTDCustomEventParameters alloc] init];
[parameters addString:@"key for string value" value:@"string value"];
[parameters addInt:@"key for int value" value:10];
[parameters addBool:@"key for bool value" value:true];
[parameters addDouble:@"key for double value" value:12.5];

[DTDAnalytics customEvent:@"Event name" withParameters:parameters];

Parameter

Type

Restrictions

Description

The following data types can be passed using the DTDCustomEventParameters object:

Type

Restrictions

DTDAnalytics.customEvent(eventName: "Event name")

If you want to pass custom parameters, use DTDCustomEventParameters class instance.

let parameters = DTDCustomEventParameters()
parameters.add(key: "key for string value", value: "string value")
parameters.add(key: "key for int value", value: 10)
parameters.add(key: "key for bool value", value: true)
parameters.add(key: "key for double value", value: 12.5)

DTDAnalytics.customEvent(eventName: "Event name", parameters: parameters)

Parameter

Type

Restrictions

Description

The following data types can be passed using the DTDCustomEventParameters object:

Type

Restrictions

DTDAnalytics.CustomEvent(eventName: "Event name");

If you want to pass custom parameters, use DTDCustomEventParameters class instance.

var parameters = new DTDCustomEventParameters();
parameters.Add(key: "key for string value", value: "string value");
parameters.Add(key: "key for int value", value: 10);
parameters.Add(key: "key for bool value", value: true);
parameters.Add(key: "key for double value", value: 12.5);
DTDAnalytics.CustomEvent(eventName: "Event name", parameters: parameters);

Parameter

Type

Restrictions

Description

The following data types can be passed using the DTDCustomEventParameters object:

Type

Restrictions

DTDAnalytics.CustomEvent(eventName: "Event name");

If you want to pass custom parameters, use DTDCustomEventParameters class instance.

var parameters = new DTDCustomEventParameters();
parameters.Add(key: "key for string value", value: "string value");
parameters.Add(key: "key for int value", value: 10);
parameters.Add(key: "key for bool value", value: true);
parameters.Add(key: "key for double value", value: 12.5);
DTDAnalytics.CustomEvent(eventName: "Event name", parameters: parameters);

Parameter

Type

Restrictions

Description

The following data types can be passed using the DTDCustomEventParameters object:

Type

Restrictions

window.devtodev.customEvent(eventName, parameters)

If you want to pass custom parameters, use an object with parameters.

window.devtodev.customEvent("Event name", {
        "key for string value" : "string value",
        "key for int value": 10,
        "key for bool value": true,
        "key for double value": 12.5
})

Parameter

Type

Restrictions

Description

The following data types can be passed using parameters object:

Type

Restrictions

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::CustomEvent("EventName");

If you want to pass custom parameters, use:

Parameter

Type

Restrictions

Description

The following data types can be passed using the DTDCustomEventParameters object:

Type

Restrictions

FDTDCustomEventParams params;
params.BoolParameters.Add("BoolKey", true);
params.FloatParameters.Add("FloatKey", 3.3);
params.IntParameters.Add("IntKey");
params.StringParameters.Add("StringKey", "StringValue");
UDTDAnalyticsBPLibrary::CustomEventWithParams("EventName", params);

devtodev supports no more than 300 custom event names in a single project. Events that exceed the limit of custom event names will be discarded. Try to integrate the tracked actions by type to the event name level, and move the characteristic tags in the parameters.

For example, if you need to track purchasing “Paper” and “Pen” items, then you don’t need to create two events with the names “Paper Purchase” and “Pen Purchase”. Create a “Purchase” event and add an “Item” parameter to it with the appropriate “Paper” or “Pen” value. This way, you can use just one event to track many items.

For a string parameter, you can use no more than 50,000 unique values for the entire history of events. If the number of unique values exceeds the limit, the parameter gets locked by the system and gets discarded from the received data. Therefore, we don’t recommend using highly variable parameters like user IDs or time as string values (moreover, they are automatically added to the event).

We strongly recommend that you do not change the data type passed in the same parameter. If you change the data type in a parameter, it will be duplicated with the same name, which may cause issues while processing reports.

Progression event

First of all, the progression event is used in games with short (within one game session) areas/game levels, e.g. match 3 games. You can use the event to collect data on how well or how fast users complete levels, how difficult it is for them, how many resources they gained or spent, and other parameters.

There are two methods in working with progression event:

startProgressionEvent
finishProgressionEvent

When a player spawns at a location, the following method is called:

let parameters = DTDStartProgressionEventParameters()
parameters.source = "Source"
parameters.setDifficulty(difficulty: 10)

DTDAnalytics.startProgressionEvent(eventName: "Progression event name", 
                                   parameters: parameters)

Parameter

Type

Restrictions

Description

DTDStartProgressionEventParameters:

Parameter

Type

Restrictions

Description

Once the player completes the location successfully, the following method is called:

let parameters = DTDFinishProgressionEventParameters()
parameters.successfulCompletion = true
parameters.duration = 100
parameters.spent = ["currency name 1": 1000,
                    "currency name 2": 50]
parameters.earned = ["currency name 2": 100]

DTDAnalytics.finishProgressionEvent(eventName: "Progression event name", 
                                    parameters: parameters)

Parameter

Type

Restrictions

Description

DTDFinishProgressionEventParameters:

Parameter

Type

Restrictions

Description

There are two methods in working with progression event:

startProgressionEvent
finishProgressionEvent

When a player spawns at a location, the following method is called:

DTDStartProgressionEventParameters * parameters = [[DTDStartProgressionEventParameters alloc] init];
parameters.source = @"Source";
[parameters setDifficultyWithDifficulty:10];

[DTDAnalytics startProgressionEvent:@"Progression event name" withParameters:parameters];

Parameter

Type

Restrictions

Description

DTDStartProgressionEventParameters:

Parameter

Type

Restrictions

Description

Once the player completes the location successfully, the following method is called:

DTDFinishProgressionEventParameters *parameters = [[DTDFinishProgressionEventParameters alloc] init];
parameters.successfulCompletion = true;
parameters.duration = 100;
parameters.spent = @{@"currency name 1": @1000,
                     @"currency name 2": @50};
parameters.earned = @{@"currency name 2": @100};

[DTDAnalytics finishProgressionEvent:@"Progression event name" withParameters:parameters];

Parameter

Type

Restrictions

Description

DTDFinishProgressionEventParameters:

Parameter

Type

Restrictions

Description

There are two methods in working with progression event:

startProgressionEvent
finishProgressionEvent

When a player spawns at a location, the following method is called:

let parameters = DTDStartProgressionEventParameters()
parameters.source = "Source"
parameters.setDifficulty(difficulty: 10)

DTDAnalytics.startProgressionEvent(eventName: "Progression event name", 
                                   parameters: parameters)

Parameter

Type

Restrictions

Description

DTDStartProgressionEventParameters:

Parameter

Type

Restrictions

Description

Once the player completes the location successfully, the following method is called:

let parameters = DTDFinishProgressionEventParameters()
parameters.successfulCompletion = true
parameters.duration = 100
parameters.spent = ["currency name 1": 1000,
                    "currency name 2": 50]
parameters.earned = ["currency name 2": 100]

DTDAnalytics.finishProgressionEvent(eventName: "Progression event name", 
                                    parameters: parameters)

Parameter

Type

Restrictions

Description

DTDFinishProgressionEventParameters:

Parameter

Type

Restrictions

Description

There are two methods in working with progression event:

StartProgressionEvent
FinishProgressionEvent

When a player spawns at a location, the following method is called:

var parameters = new DTDStartProgressionEventParameters();
parameters.Source = "Source";
parameters.Difficulty = 10;
DTDAnalytics.StartProgressionEvent(
    eventName: "Progression event name",
    parameters: parameters);

Parameter

Type

Restrictions

Description

DTDStartProgressionEventParameters:

Parameter

Type

Restrictions

Description

Once the player completes the location successfully, the following method is called:

var parameters = new DTDFinishProgressionEventParameters();
parameters.SuccessfulCompletion = true;
parameters.Duration = 100;
parameters.Spent = new Dictionary<string, long>
{
    ["currency name 1"] = 1000,
    ["currency name 2"] = 50
};
parameters.Earned = new Dictionary<string, long>
{
    ["currency name 2"] = 100
};
DTDAnalytics.FinishProgressionEvent(
    eventName: "Progression event name",
    parameters: parameters);

Parameter

Type

Restrictions

Description

DTDFinishProgressionEventParameters:

Parameter

Type

Restrictions

Description

There are two methods in working with progression event:

StartProgressionEvent
FinishProgressionEvent

When a player spawns at a location, the following method is called:

var parameters = new DTDStartProgressionEventParameters();
parameters.Source = "Source";
parameters.Difficulty = 10;
DTDAnalytics.StartProgressionEvent(
    eventName: "Progression event name",
    parameters: parameters);

Parameter

Type

Restrictions

Description

DTDStartProgressionEventParameters:

Parameter

Type

Restrictions

Description

Once the player completes the location successfully, the following method is called:

var parameters = new DTDFinishProgressionEventParameters();
parameters.SuccessfulCompletion = true;
parameters.Duration = 100;
parameters.Spent = new Dictionary<string, long>
{
    ["currency name 1"] = 1000,
    ["currency name 2"] = 50
};
parameters.Earned = new Dictionary<string, long>
{
    ["currency name 2"] = 100
};
DTDAnalytics.FinishProgressionEvent(
    eventName: "Progression event name",
    parameters: parameters);

Parameter

Type

Restrictions

Description

DTDFinishProgressionEventParameters:

Parameter

Type

Restrictions

Description

There are two methods in working with progression event:

startProgressionEvent
finishProgressionEvent

When a player spawns at a location, the following method is called:

window.devtodev.startProgressionEvent(eventName, parameters)

Parameter

Type

Restrictions

Description

startProgressionEvent event parameters:

Parameter

Type

Restrictions

Description

Example:

window.devtodev.startProgressionEvent("Location 11", {
                difficulty: 10,
                source: "Location 10"
})

Once the player completes the location (instead of successfully or not), the following method is called:

window.devtodev.finishProgressionEvent("Progression event name", {
                successfulCompletion,
                duration,
                spent,
                earned
})

Parameter

Type

Restrictions

Description

startProgressionEvent event parameters:

Parameter

Type

Restrictions

Description

Example:

window.devtodev.finishProgressionEvent("Location 11", {
                true,
                100,
                spent: {
                                "currency name 1": 1000,
                                "currency name 2": 50 
                },
                earned: {
                                "currency name 2": 100
                }
})

There are two methods in working with progression event:

startProgressionEvent
finishProgressionEvent

When a player spawns at a location, the following method is called (one of them):

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::StartProgressionEvent("EventName");

Start progression event with parameters:

Parameter

Type

Restrictions

Description

FDTDStartProgressionEventParams:

Parameter

Type

Restrictions

Description

Example:

StartProgressionEventParams params;
params.Difficulty = 3;
params.Source = "Source";
UDTDAnalyticsBPLibrary::StartProgressionEventWithParams("EventName", params);

Once the player completes the location (instead of successfully or not), the following method is called (one of them):

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::FinishProgressionEvent("EventName");window.devtodev.finishProgressionEvent("Progression event name", {

Finish progression event with parameters:

Parameter

Type

Restrictions

Description

FDTDFinishProgressionEventParameters:TMap<FString, int64>

Parameter

Type

Restrictions

Description

Example:

FDTDFinishProgressionEventParams params;
params.Duration = 200;
params.SuccessfulCompletion = true;
params.Earned.Add("CurrencyName1", 1);
params.Spent.Add("CurrencyName2", 2);
UDTDAnalyticsBPLibrary::FinishProgressionEventWithParams("EventName", params);

The user can only be in one area at a time. When moving to another area (including nested ones), the previous location must be completed. Information about events that have not been completed by calling the finishProgressionEvent method during a game session (the finishProgressionEvent method call is not integrated, or the user uses the cached app, or the app has crashed) is not included in the statistics.

If you want to use this event to track actions that take more than one game session, you can prepare the required data and call both methods when the action is completed (successfully or unsuccessfully). For example, you can use this event to track the main questline.

User profile

User ID

This method is used to initialize the user in applications where you have set calculation by user ID specified by the developer, applications that are part of a cross-platform project.

You can also use this method when calculating by device ID (by default) to pass in the user ID used on your servers so that you can easily find the user on devtodev.

We recommend that you pass this parameter in the initialization configuration (userId property of an instance of theDTDAnalyticsConfiguration class).

Do not pass an empty string ("") to the setUserID method as the user ID. Assigning an empty string is a command to assign a default value to the user ID (it is equal to the current device ID). In applications with calculation by user ID, this can lead to unnecessary registrations.

To set a new value as the user ID, use the setUserId method.

DTDAnalytics.setUserId(userId: "Custom User ID")

To get the current value of the user ID, use the asynchronous method getDeviceId(_ completionHandler: @escaping (String) -> Void)

DTDAnalytics.getUserId { userId in
  // your code
}

We recommend that you pass this parameter in the initialization configuration (userId property of an instance of theDTDAnalyticsConfiguration class).

To set a new value as the user ID, use the setUserId method.

[DTDAnalytics userId:@"Custom User ID"];

To get the current value of the user ID, use the asynchronous method (void)deviceIdHandler:( void (^ _Nonnull)(NSString * _Nonnull))completion-Handler;

[DTDAnalytics userIdHandler:^(NSString * _Nonnull userId) {
  // your code
}];

We recommend that you pass this parameter in the initialization configuration (userId property of an instance of theDTDAnalyticsConfiguration class).

To set a new value as the user ID, use the setUserId method.

DTDAnalytics.setUserId(userId: "Custom User ID")

To get the current value of the user ID, use the asynchronous method getDeviceId(block: (String) -> Unit)

DTDAnalytics.getUserId { userId ->
  // your code
}

We recommend that you pass this parameter in the initialization configuration (userId property of an instance of theDTDAnalyticsConfiguration class).

Do not pass an empty string ("") to the SetUserID method as the user ID. Assigning an empty string is a command to assign a default value to the user ID (it is equal to the current device ID). In applications with calculation by user ID, this can lead to unnecessary registrations.

To set a new value as the user ID, use the SetUserId method.

DTDAnalytics.SetUserId(userId: "Custom User ID")

To get the current value of the user ID, use the asynchronous method:

var userId = await DTDAnalytics.GetUserId();

We recommend that you pass this parameter in the initialization configuration (userId property of an instance of theDTDAnalyticsConfiguration class).

To set a new value as the user ID, use the SetUserId method.

DTDAnalytics.SetUserId(userId: "Custom User ID")

To get the current value of the user ID, use the asynchronous method:

DTDAnalytics.GetUserId(id =>
{
  //your code
});

We recommend that you pass this parameter in the initialization configuration (userId property in config object).

To set a new value as the user ID, use the setUserId method.

window.devtodev.setUserId("Custom User ID")

To get the current value of the user ID, use the getUserIdmethod

var userId = window.devtodev.getUserId()

We recommend that you pass this parameter in the initialization configuration (UserId property of an instance of the FDTDAnalyticsConfiguration class).

To set a new value as the user ID, use method:

Arguments

Type

Description

UDTDAnalyticsBPLibrary::SetUserId("Name");

To get the current value of the user ID, use the asynchronous method:

Arguments

Type

Description

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

Replace

This method is used in very rare cases. It is applicable in the case when the calculation of users in the project is carried out by the user ID specified by the developer. In this case, the application can change this identifier. For example, calculation in the application is carried out by user emails and in the application, it is possible to change this email to another one. At the time of replacement, you need to call this method, specifying the user's previous email and the one with which it was replaced.

DTDAnalytics.replace(fromUserId: "Old user id", toUserId: "New user id")

[DTDAnalytics replaceFromUserId:@"Old user id" toUserId:@"New user id"];

DTDAnalytics.replace(fromUserId: "Old user id", toUserId: "New user id")

DTDAnalytics.Replace(fromUserId: "Old user id", toUserId: "New user id");

DTDAnalytics.Replace(fromUserId: "Old user id", toUserId: "New user id");

window.devtodev.replace( "Old user id", "New user id")

Arguments

Type

Description

UDTDAnalyticsBPLibrary::ReplaceUserId("UserIdBefore", "UserIdAfter");

Do not use this method to re-login as a different user! The setUserId method is used for relogging.

Current user level

This method is used in cross-platform and data synchronized applications. The method is required to update user level data.

To set the current value to the user level, use setCurrentLevel(currentLevel: Int) method:

DTDAnalytics.setCurrentLevel(value: 2)

We recommend that you use the setCurrentLevel method immediately after using the setUserID method or specify the current user level in the initialization configuration (the level property of an instance of the DTDAnalyticsConfiguration).

Do not use the setCurrentLevel method when the user reaches a new level. In this case, you must use the levelUp method.

To get the user-level value stored by the SDK, use getCurrentLevel(completionHandler: @escaping (Int) -> Void) method

DTDAnalytics.getCurrentLevel { level in
  // your code
}

To set the current value to the user level, use (void)currentLevel:(NSInteger)currentLevel; method:

[DTDAnalytics currentLevel:2];

Do not use the setCurrentLevel method when the user reaches a new level. In this case, you must use the levelUp method.

To get the user-level value stored by the SDK, use (void)currentLevelHandler:( void (^ _Nonnull)(NSInteger))completionHandler; method

[DTDAnalytics currentLevelHandler:^(NSInteger level) {
  // your code
}];

To set the current value to the user level, use method:

DTDAnalytics.setCurrentLevel(value: 2)

Do not use the setCurrentLevel method when the user reaches a new level. In this case, you must use the levelUp method.

To get the user-level value stored by the SDK, use getCurrentLevel(completionHandler: @escaping (Int) -> Void) method

DTDAnalytics.getCurrentLevel { level ->
  // your code
}

To set the current value to the user level, use method:

DTDAnalytics.SetCurrentLevel(level: 3);

We recommend that you use the SetCurrentLevel method immediately after using the SetUserID method or specify the current user level in the initialization configuration (the level property of an instance of the DTDAnalyticsConfiguration).

Do not use the SetCurrentLevel method when the user reaches a new level. In this case, you must use the LevelUp method.

To get the user-level value stored by the SDK, use GetCurrentLevel method:

var currentLevel = await DTDAnalytics.GetCurrentLevel();

To set the current value to the user level, use method:

DTDAnalytics.SetCurrentLevel(level: 3);

Do not use the SetCurrentLevel method when the user reaches a new level. In this case, you must use the LevelUp method.

To get the user-level value stored by the SDK, use GetCurrentLevel method:

DTDAnalytics.GetCurrentLevel(level =>
{
  //your code
});

To set the current value to the user level, use method:

window.devtodev.setCurrentLevel(2)

Do not use the setCurrentLevel method when the user reaches a new level. In this case, you must use the levelUp method.

To get the user-level value stored by the SDK, use getCurrentLevel method.

var currentLevel = window.devtodev.getCurrentLevel()

To set the current value to the user level, use method:

Arguments

Type

Description

UDTDAnalyticsBPLibrary::SetCurrentLevel(7);

Do not use the SetCurrentLevel method when the user reaches a new level. In this case, you must use the LevelUp method.

To get the user-level value stored by the SDK, use method:

Arguments

Type

Description

auto onResult = new FDTDGetterIntDelegate();
onResult->BindLambda([](int32 value)
{
	// Your code...
});
UDTDAnalyticsBPLibrary::GetCurrentLevel(*onResult);

Cheater

If you have your own methods for detecting cheaters in the application, you can tag such users. Actions taken by these users will not be counted in statistics.

DTDUserCard.setCheater(cheater: true)

To get the current value of the 'Cheater' flag, use getCheater(completionHandler: @escaping (Bool) -> Void)

DTDUserCard.getCheater { isCheater in
  // your code
}

[DTDUserCard setCheater:true];

To get the current value of the 'Cheater' flag, use(void)getCheaterHandler:( void (^ _Nonnull)(BOOL))completionHandler;

[DTDUserCard getCheaterHandler:^(BOOL cheater) {
  // your code
}];

DTDUserCard.setCheater(cheater: true)

To get the current value of the 'Cheater' flag, use getCheater(handler: (Boolean) -> Unit)

DTDUserCard.getCheater { isCheater ->
  // your code
}

DTDUserCard.SetCheater(cheater: true);

To get the current value of the 'Cheater' flag, use

var isCheater = await DTDUserCard.GetCheater();

DTDUserCard.SetCheater(cheater: true);

To get the current value of the 'Cheater' flag, use

DTDUserCard.GetCheater(cheater=>
{
  //your code
});

window.devtodev.user.setCheater(true)

To get the current value of the 'Cheater' flag, use getCheater method:

var isCheater = window.devtodev.user.getCheater()

Arguments

Type

Description

UDTDUserCardBPLibrary::SetCheater(true);

To get the current value of the 'cheater' flag, use

Arguments

Type

Description

auto onResult = new FDTDGetterBoolDelegate();
onResult->BindLambda([](bool value)
{
	// Your code...
});
UDTDUserCardBPLibrary::GetCheater(*onResult);

Reserved user properties

Attention! We strongly discourage the storage of personal user data! If you plan to pass this data, be sure to indicate this in the ‘Nutrition label’ when submitting the application to the App Store review.

Property

Setter

Getter

Example:

UDTDUserCardBPLibrary::SetEmail("Email");

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

Custom user property

Each devtodev project can have up to 30 custom user properties. User custom property values can be a number, a string, or a boolean value.

This is how you can set properties on the current user profile:

DTDUserCard.set(key: "key for string value", value: "string value")
DTDUserCard.set(key: "key for int value", value: 10)
DTDUserCard.set(key: "key for double value", value: 12.5)
DTDUserCard.set(key: "key for bool value", value: true)

It is important to remember that the key for custom user properties has a length limit. If the limit is exceeded (from 1 to 64 characters), the key will be truncated to the maximum allowed length

To get the current value stored in the user profile on the SDK, you need to use the method:

getValue(key: String, _completionHandler: @escaping (Any) -> Void)

DTDUserCard.getValue(key: "key for value") { value in
  // your code
}

When using the getValue method, note that the Anyreturn type will need to be cast to the data type you want.

This is how you can set properties on the current user profile:

[DTDUserCard setString:@"key for string value" value:@"string value"];
[DTDUserCard setInt:@"key for int value" value:10];
[DTDUserCard setDouble:@"key for double value" value:12.5];
[DTDUserCard setBool:@"key for bool value" value:true];

It is important to remember that the key for custom user properties has a length limit. If the limit is exceeded (from 1 to 64 characters), the key will be truncated to the maximum allowed length

To get the current value stored in the user profile on the SDK, you need to use the method:

(void)getValueWithKey:(NSString * _Nonnull)key :(void (^ _Nonnull)(id _Nullable))completionHandler;

[DTDUserCard getValueWithKey:@"key for value" :^(id object) {
  // your code
}];

When using the getValue method, note that the Anyreturn type will need to be cast to the data type you want.

This is how you can set properties on the current user profile:

DTDUserCard.set(key: "key for string value", value: "string value")
DTDUserCard.set(key: "key for int value", value: 10)
DTDUserCard.set(key: "key for double value", value: 12.5)
DTDUserCard.set(key: "key for bool value", value: true)

It is important to remember that the key for custom user properties has a length limit. If the limit is exceeded (from 1 to 64 characters), the key will be truncated to the maximum allowed length

To get the current value stored in the user profile on the SDK, you need to use the method:

getValue(key: String, handler: (Any?) -> Unit)

DTDUserCard.getValue(key: "key for value") { value ->
  // your code
}

When using the getValue method, note that the Anyreturn type will need to be cast to the data type you want.

This is how you can set properties on the current user profile:

DTDUserCard.Set(key: "key for string value", value: "string value");
DTDUserCard.Set(key: "key for int value", value: 10);
DTDUserCard.Set(key: "key for double value", value: 12.5);
DTDUserCard.Set(key: "key for bool value", value: true);

It is important to remember that the key for custom user properties has a length limit. If the limit is exceeded (from 1 to 64 characters), the key will be truncated to the maximum allowed length

To get the current value stored in the user profile on the SDK, you need to use the method:

var value = await DTDUserCard.Get(key: "key for value");
switch (value)
{
    case bool boolValue:
        break;
    case long longValue:
        break;
    case double doubleValue:
        break;
    case string stringValue:
        break;
}

When using the Get method, note that the object return type will need to be cast to the data type you want.

This is how you can set properties on the current user profile:

DTDUserCard.Set(key: "key for string value", value: "string value");
DTDUserCard.Set(key: "key for int value", value: 10);
DTDUserCard.Set(key: "key for double value", value: 12.5);
DTDUserCard.Set(key: "key for bool value", value: true);

It is important to remember that the key for custom user properties has a length limit. If the limit is exceeded (from 1 to 64 characters), the key will be truncated to the maximum allowed length

To get the current value stored in the user profile on the SDK, you need to use the method:

DTDUserCard.GetValue("key", value =>
{
    switch (value)
    {
    case bool boolValue:
        break;
    case long longValue:
        break;
    case double doubleValue:
        break;
    case string stringValue:
        break;
    }             
})
DTDUserCard.Get(key: "key for value");

When using the Get method, note that the object return type will need to be cast to the data type you want.

This is how you can set properties on the current user profile:

window.devtodev.user.set("key for string value",  "string value")
window.devtodev.user.set("key for int value", 10)
window.devtodev.user.set("key for double value", 12.5)
window.devtodev.user.set("key for bool value", true)

It is important to remember that the key for custom user properties has a length limit. If the limit is exceeded (from 1 to 64 characters), the key will be truncated to the maximum allowed length

To get the current value stored in the user profile on the SDK, you need to use the method:

window.devtodev.user.getValue("key for value")

This is how you can set properties on the current user profile:

Arguments

Type

Description

UDTDUserCardBPLibrary::SetBool("BoolKey", true);

Arguments

Type

Description

UUDTDUserCardBPLibrary::SetFloat("FloatKey", 3.333);

Arguments

Type

Description

UDTDUserCardBPLibrary::SetLong("LongKey", 1000);

Arguments

Type

Description

UDTDUserCardBPLibrary::SetString("StringKey", "StringValue");

It is important to remember that the key for custom user properties has a length limit. If the limit is exceeded (from 1 to 64 characters), the key will be truncated to the maximum allowed length

To get the current value stored in the user profile on the SDK, you need to use methods:

Arguments

Type

Description

FString key = FString(TEXT("Key"));
auto onResult = new FDTDGetterOptionalBoolWithKeyDelegate();
onResult->BindLambda([](bool success, const FString& key, bool value)
{
	// Your code...
});
UDTDUserCardBPLibrary::TryGetBool(key, *onResult);

Arguments

Type

Description

FString key = FString(TEXT("Key"));
auto onResult = new FDTDGetterOptionalFloatWithKeyDelegate();
onResult->BindLambda([](bool success, const FString& key, float value)
{
	// Your code...
});
UDTDUserCardBPLibrary::TryGetFloat(key, *onResult);

Arguments

Type

Description

FString key = FString(TEXT("Key"));
auto onResult = new FDTDGetterOptionalIntWithKeyDelegate();
onResult->BindLambda([](bool success, const FString& key, int64 value)
{
	// Your code...
});
UDTDUserCardBPLibrary::TryGetLong(key, *onResult);

Arguments

Type

Description

FString key = FString(TEXT("Key"));
auto onResult = new FDTDGetterOptionalStringWithKeyDelegate();
onResult->BindLambda([](bool success, const FString& key, const FString& value)
{
	// Your code...
});
UDTDUserCardBPLibrary::TryGetString(key, *onResult);

Unset user property

It removes a property or a list of properties and their values from the current user profile.

DTDUserCard.unset(property: "key for string value")
DTDUserCard.unset(properties: ["key for string value", 
                               "key for int value"])

[DTDUserCard unsetProperty:@"key for string value"];
[DTDUserCard unset:@[@"key for string value",
                     @"key for int value"]];

DTDUserCard.unset(property: "key for string value")
DTDUserCard.unset(properties: listOf("key for string value", "key for int value"))

DTDUserCard.Unset(keys: "key 1");
DTDUserCard.Unset(keys: "key 1", "key 2", "key 3");

DTDUserCard.Unset(keys: "key 1");
DTDUserCard.Unset(keys: "key 1", "key 2", "key 3");

window.devtodev.user.unset("key for string value")
window.devtodev.user.unset(["key for string value", "key for int value"])

Arguments

Type

Description

UDTDUserCardBPLibrary::Unset("Key");

Arguments

Type

Description

TArray<FString> keys;
keys.Add("Key1");
keys.Add("Key2");
UDTDUserCardBPLibrary::UnsetArray(keys);

Unset all user properties

To remove all properties from the user card, use:

DTDUserCard.clearUser()

Keep in mind that the cheater mark is not cleared from the user card; you can only uncheck the mark manually using the setCheater method.

[DTDUserCard clearUser];

Keep in mind that the cheater mark is not cleared from the user card; you can only uncheck the mark manually using the setCheater method.

DTDUserCard.clearUser()

Keep in mind that the cheater mark is not cleared from the user card; you can only uncheck the mark manually using the setCheater method.

DTDUserCard.ClearUser();

Keep in mind that the cheater mark is not cleared from the user card; you can only uncheck the mark manually using the SetCheater method.

DTDUserCard.ClearUser();

Keep in mind that the cheater mark is not cleared from the user card; you can only uncheck the mark manually using the SetCheater method.

window.devtodev.user.clearUser()

Keep in mind that the cheater mark is not cleared from the user card; you can only uncheck the mark manually using the setCheater method.

UDTDUserCardBPLibrary::ClearUser();

Keep in mind that the cheater mark is not cleared from the user card; you can only uncheck the mark manually using the SetCheater method.

Integration of SDK v2.0+

SDK Integration

Android

Step 1. Gradle Build Dependencies

Step 2. SDK Initialization

Step 3. SDK Initialization

iOS

CocoaPods

Swift Package Manager

Manual installation

Integration features

For Objective-C

For SwiftUI

macOS

Integration features

For Objective-C

For SwiftUI

Unity

SDK Initialization

Specific integration features of certain platforms

Windows Standalone

Android

iOS

Windows

1. NuGet Installation

Package Manager UI

Package Manager Console

2. SDK Initialization

1. NuGet Installation

Package Manager UI

Package Manager Console

2. SDK Initialization

3. SDK Activity

Web

Initialization

Unreal Engine

Plugin installation

Data types

class UDTDAnalyticsLibrary

class UDTDUserCardLibrary

enum class EDTDTrackingStatus : uint8

enum class EDTDLogLevel : uint8

enum class EDTDAccrualType : uint8

enum class EDTDSocialNetwork : uint8

enum class EDTDGender: uint8

enum class EDTDReferralProperty : uint8

struct FDTDOptionalInt32

struct FDTDOptionalString

struct FDTDAnalyticsConfiguration

FDTDCustomEventParams

struct FDTDStartProgressionEventParams

struct FDTDFinishProgressionEventParams

Delegates

SDK initialization

SDK initialization without parameters:

SDK initialization with parameters:

Setting up events

Secondary methods

Ad impression

Connecting to social networks

Posting to social networks

Referrer

Force dispatch of accumulated events

Setters & Getters

Setting User Tracking Status (GDPR)

Getting device ID

Getting the devtodev SDK version

Obtaining user tracking status (GDPR)

Getting devtodev ID

Anti-cheat methods

Payment Validation

DTDVerifyResponse

DTDReceiptStatus

DTDVerifyResponse

DTDReceiptStatus

DTDVerifyResponse

DTDReceiptStatus

DTDVerifyResponse

DTDReceiptStatus

Google Play

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

External interface of the `DTDMessaging` module

`DTDPushListener` Interface Methods

A Class for Receiving Notification Data (`DTDPushMessage`).

A Class for Handling the Notification Button Taps (`DTDActionButton`)

External interface of the `DTDMessaging` module

Optional `DTDMessagingDelegate` methods

`DTDMediaAttachmentExtension`

`class UDTDMessagingBPLibrary`

`enum class EDTDNotificationActionType : uint8`

`struct FDTDNotification`

`struct FDTDNotificationAction`

`enum class EDTDIOSNotificationOptions : uint8`

`Delegates`

`SetAvailability`

`GetAvailability`

`GetToken`

`SetTokenListener`

`SetTokenErrorListener`

`SetNotificationReceiveListener`

`SetInvisibleNotificationReceiveListener`

`SetNotificationActionListener`

`IOSSetNotificationOptions`