1 of 29

Integration of SDK 2.0+ (new)

SDK Integration

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.

Manual installation

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

2. Add DTDAnalytics.xcframework to the project

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 = [[DTDAnalyticsConfiguration alloc] init];
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

Parameter

Type

Description

currentLevel

int

The player level at the moment of devtodev SDK initialization. It is recommended (but optional) to use to improve data precision.

userId

string

A custom user identifier provided by the developer. If you utilize the default calculation by the device ID, this identifier can be used for finding a user in devtodev.

In case your project utilizes the calculation by the user identifier, you must set this parameter because it becomes the main user identifier in devtodev.

trackingAvailability

DTDTrackingStatus (enum)

The property allows or disallows devtodev tracking of the user. By default, it is set to DTDTrackingStatus.enable. SDK stores the previously assigned value. Pass DTDTrackingStatus.disable if the user opted out of tracking in line with GDPR.

logLevel

DTDLogLevel (enum)

The level of logging the SDK activity. The DTDLogLevel.no value is used by default. For troubleshooting during integration it is recommended to set it to DTDLogLevel.debug, and either switch it off DTDLogLevel.no. Use DTDLogLevel.no in the release version.

Example:

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

DTDAnalyticsConfiguration *config;
config.currentLevel = @1;
config.userId = @"CustomUserID";
config.trackingAvailability = DTDTrackingStatusEnable;
config.logLevel = DTDLogLevelNo;
[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: "App ID", configuration: config)
    }

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

Apps targeted at children

When developing and publishing apps targeted at children under 13 years old, you need to ensure special conditions for data processing. Any mobile app aimed at children or intended for users in a region with strict regulations on child online protection, must comply with current laws.

Please study the following requirements:

If your app has to comply with the legal requirements (COPPA), use the following recommendations:

Implement the coppaControlEnable method. The method disables collection of ad IDs and vendor IDs (IDFA, IDFV).
To comply with Apple’s guidelines
1. Remove AppTrackingTransparency.framework and all the links pointing to it.
2. Remove AdSupport.framework all the links pointing to it.

Call the coppaControlEnable method before SDK initialization. If the method was not called, the SDK will work as before.

DTDAnalytics.coppaControlEnable()
DTDAnalytics.initialize(applicationKey: "App ID", configuration: config)

[DTDAnalytics coppaControlEnable];
[DTDAnalytics applicationKey:@"App ID" configuration:config];

Privacy Manifest

The Privacy Manifest is a new way introduced at WWDC23 for third-party SDK developers to provide information about their privacy policies.

The Privacy Manifest describes the methods for ensuring code confidentiality in the application in a unified format. When publishing the application, Xcode will combine the privacy manifests of all third-party SDKs used in your application into a single, convenient report. This report makes it easier to create more accurate privacy labels (Nutrition Labels).

The Privacy Manifest includes the following sections for data entry:

Privacy Tracking Enabled
Privacy Tracking Domains
Privacy Nutrition Label Types
Privacy Accessed API Types

Privacy Tracking Enabled. A Boolean value indicating whether the application or third-party SDK uses data for tracking, as defined within the App Tracking Transparency framework.

Privacy Tracking Domains. An array of strings listing the internet domains that the application or third-party SDK connects to and participates in tracking.

Privacy Nutrition Label Types. An array of dictionaries describing the types of data collected by the application or third-party SDK. Nutrition Labels are needed to let users know what data the application collects before installing it from the App Store.

Privacy Accessed API Types. An array of dictionaries describing the types of APIs accessed by the application or third-party SDK, which are marked as APIs and require verification for access.

Privacy manifest for Devtodev SDKs:

Analytics module

Privacy Nutrition Label Types

Collected Data Type

Linked to User

Used for Tracking

Collection Purposes

Product Interaction

Analytics

Device ID

Analytics

User ID

Analytics

Purchase History

Analytics

Other Data Types

Analytics

Privacy Accessed API Types

Privacy Accessed API Type

Privacy Accessed API Reasons

User Defaults

CA92.1: Access info from same app, per documentation

Messaging module

Privacy Nutrition Label Types

Collected Data Type

Linked to User

Used for Tracking

Collection Purposes

Device ID

Analytics

Other Data Types

Analytics

Privacy Accessed API Types

Privacy Accessed API Type

Privacy Accessed API Reasons

User Defaults

CA92.1: Access info from same app, per documentation

SDK Signature

Since we distribute our SDKs as binary dependencies, we have implemented a signing practice. Now, when you use a new version of the SDK, Xcode will confirm that it has been signed by us, increasing the integrity of the software supply chain.

macOS

Manual installation

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

Parameter

Type

Description

currentLevel

int

The player level at the moment of devtodev SDK initialization. It is recommended (but optional) to use to improve data precision.

userId

string

A custom user identifier provided by the developer. If you utilize the default calculation by the device ID, this identifier can be used for finding a user in devtodev.

In case your project utilizes the calculation by the user identifier, you must set this parameter because it becomes the main user identifier in devtodev.

trackingAvailability

DTDTrackingStatus (enum)

logLevel

DTDLogLevel (enum)

Example:

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

DTDAnalyticsConfiguration *config;
config.currentLevel = @1;
config.userId = @"CustomUserID";
config.trackingAvailability = DTDTrackingStatusEnable;
config.logLevel = DTDLogLevelNo;
[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: "App ID", configuration: config)
    }

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

Apps targeted at children

Please study the following requirements:

If your app has to comply with the legal requirements (COPPA), use the following recommendations:

Implement the coppaControlEnable method. The method disables collection of ad IDs and vendor IDs (IDFA, IDFV).
To comply with Apple’s guidelines
1. Remove AppTrackingTransparency.framework and all the links pointing to it.
2. Remove AdSupport.framework all the links pointing to it.

Call the coppaControlEnable method before SDK initialization. If the method was not called, the SDK will work as before.

DTDAnalytics.coppaControlEnable()
DTDAnalytics.initialize(applicationKey: "App ID", configuration: config)

[DTDAnalytics coppaControlEnable];
[DTDAnalytics applicationKey:@"App ID" configuration:config];

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.

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

Parameter

Type

Description

currentLevel

Integer

The player level at the moment of devtodev SDK initialization. It’s optional but we recommend using it for improving data accuracy.

userId

String

A custom user ID assigned by the developer. In the case of default calculation by device IDs, the identifier can be used for searching users in devtodev. In case the project uses calculation by user IDs, the parameter is mandatory because it becomes the principal calculation ID in devtodev.

trackingAvailability

DTDTrackingStatus (enum)

The property allows or disallows devtodev tracking of the user. By default, it is set to DTDTrackingStatus.Enable. SDK stores the previously assigned value. Pass DTDTrackingStatus.Disable if the user opted out of tracking in line with GDPR.

logLevel

DTDLogLevel (enum)

The level of logging the SDK activity. The DTDLogLevel.no value is used by default. For troubleshooting during integration it is recommended to set it to DTDLogLevel.Debug, and either switch it off DTDLogLevel.No. Use DTDLogLevel.No in the release version.

Example:

var config = new DevToDev.Analytics.DTDAnalyticsConfiguration();
config.LogLevel = DTDLogLevel.No;
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.

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

Parameter

Type

Description

currentLevel

Integer

The player level at the moment of devtodev SDK initialization. It’s optional but we recommend using it for improving data accuracy.

userId

String

trackingAvailability

DTDTrackingStatus (enum)

logLevel

DTDLogLevel (enum)

The level of logging the SDK activity. The DTDLogLevel.No value is used by default. For troubleshooting during integration, it is recommended to set it to DTDLogLevel.Debug, and either switch it off DTDLogLevel.No or use it only for error handling DTDLogLevel.Error in the release version.

ApplicationVersion

String

The app version during the devtodev SDK initialization. It is recommended that you set the app version before the initialization to make the collection of app version statistics more precise.

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.

Since there’s no option to get any consistent identifier in web browsers, we recommend using as a User ID either a social network ID with your app or an ID that your server assigns to a user. It’s best to assign a User ID and specify it in the config object during the SDK initialization instead of using a setUserId method after the initialization.

If you have a games app, we recommend specifying the current player’s lever either in the config or at the earliest possible moment after the initialization via the setCurrentLevel method.

Config

Parameter

Type

Description

userId

string

Unique user identifier. For example, user’s ID in a social network, or a unique account name used for user identification on your server. If at the time of initialization this identifier is not yet available, specify the identifier later using

the setUserId method.

currentLevel

integer

The player level at the moment of devtodev SDK initialization. Must be greater than 0. It’s optional but we recommend using it for improving data accuracy.

trackingAvailability

boolean

The property allows or disallows devtodev tracking of the user. By default, it is set to true. SDK stores the previously assigned value. Pass false if the user opted out of tracking in line with GDPR.

logLevel

string

The level of logging the SDK activity. The "No" value is used by default. For troubleshooting during integration, it is recommended to set it to "Debug", and either switch it "No" or use it only for error handling "Error" in the release version.

applicationVersion

String

The app version. Cannot be empty.

Example:

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

Unity

SDK Integration

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:

To integrate devtodev analytics SDK, you can use one of the two methods: by using the Unity Package Manager (recommended) or by manually importing the unitypackage.

Integration by using the Unity Package Manager

If you integrated the devtodev package manually, then you need to delete the Assets/DevToDev and Plugins/DevToDev folders.

Open the Package Manager (Window → Package Manager), click + in the top left corner and select Add package from git URL.
Copy the repository URL https://github.com/devtodev-analytics/package_Analytics.git to the input box and click Add.
Wait for the Unity Package Manager to download the package.

If you work with SDK version 3.5.0 and above, and you want to use Google Ad ID, you need to add devtodev-analytics/package_Google. When developing and publishing apps for kids (COPPA), you do not need devtodev-analytics/package_Google. Read more about working with COPPA in the COPPA section.

If you work with SDK version 3.5.0 and above, and you want to use Huawei Ad ID, you need to add https://github.com/devtodev-analytics/package_Huawei.git. When developing and publishing apps for kids (COPPA), you do not need https://github.com/devtodev-analytics/package_Huawei.git. Read more about working with COPPA in the COPPA section.

You can pick a specific SDK version by adding # and a version number at the end of the URL, for example: https://github.com/devtodev-analytics/package_Analytics.git#v3.3.2

Integration by importing unitypackage

Download DTDAnalytics.unitypackage from http://github.com/devtodev-analytics/Unity-sdk-3.0/releases/latest
In the Unity Editor menu, open Assets → Import Package → Custom Package
Select the DTDAnalytics.unitypackage that you have just downloaded
Click Import

If you work with SDK version 3.5.0 and above, and you want to use Google Ad ID, you need to import the DTDGoogle.unitypackage. When developing and publishing apps for kids (COPPA), you do not need the DTDGoogle.unitypackage. Read more about working with COPPA in the COPPA section.

If you work with SDK version 3.5.0 and above, and you want to use Huawei Ad ID, you need to import the DTDHuawei.unitypackage. When developing and publishing apps for kids (COPPA), you do not need the DTDHuawei.unitypackage. Read more about working with COPPA in the COPPA section.

SDK Initialization

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

using DevToDev.Analytics;
using UnityEngine;

public class DTDObject : MonoBehaviour
{
    void Start()
    { 
#if UNITY_ANDROID
        DTDAnalytics.Initialize("androidAppID");
#elif UNITY_IOS
        DTDAnalytics.Initialize("IosAppID");
#elif UNITY_WEBGL
        DTDAnalytics.Initialize("WebAppID");
#elif UNITY_STANDALONE_WIN
        DTDAnalytics.Initialize("winAppID");
#elif UNITY_STANDALONE_OSX
        DTDAnalytics.Initialize("OsxAppID");
#elif UNITY_WSA
        DTDAnalytics.Initialize("UwpAppID");
#endif
    }
}

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

Parameter

Type

Description

CurrentLevel

Integer

The player level at the moment of devtodev SDK initialization. It’s optional but we recommend using it for improving data accuracy.

UserId

String

TrackingAvailability

DTDTrackingStatus (enum)

LogLevel

DTDLogLevel (enum)

ApplicationVersion

String

The app version during the devtodev SDK initialization. Use the property on the WinStandalone platform only. For all other platforms, data is collected automatically.

Example:

var config = new DTDAnalyticsConfiguration
{
    ApplicationVersion = "1.2.3",
    LogLevel = DTDLogLevel.No,
    TrackingAvailability = DTDTrackingStatus.Enable,
    CurrentLevel = 1,
    UserId = "unique_userId"
};

using DevToDev.Analytics;
using UnityEngine;

public class DTDObject : MonoBehaviour
{
    void Start()
    { 
#if UNITY_ANDROID
        DTDAnalytics.Initialize("androidAppID", config);
#elif UNITY_IOS
        DTDAnalytics.Initialize("iOSAppID", config);
#elif UNITY_WEBGL
        DTDAnalytics.Initialize("WebAppID", config);
#elif UNITY_STANDALONE_WIN
        DTDAnalytics.Initialize("winAppID", config);
#elif UNITY_STANDALONE_OSX
        DTDAnalytics.Initialize("OSXAppID", config);
#elif UNITY_WSA
        DTDAnalytics.Initialize("UwpAppID", config);
#endif
    }
}

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.

Universal Windows Platform (WSA)

In the version 2019.2, the Executable Only option was added to the Build Type. This option is incompatible with the SDK because the SDK needs access to the project file in order to register the DevToDev.Background service.

Android

To resolve external android dependencies, you need to use External Dependency Manager for Unity.

Add the following strings to proguard.txt (read more about Unity proguard here):

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

Huawei

Select your project in https://developer.huawei.com/consumer/en/service/josp/agc/index.html#/myProject In the “General information” section find “App information” and download the “agconnect-services.json“ file.
If you imported the DTDGoogle package, delete the imported files Assets\Plugins\DevToDev\Android\DTDGoogleAndroid.dll and Assets\DevToDev\Analytics\Editor\GoogleDependencies.xml
Import the DTDHuawei.unitypackage manually from GitHub or use Unity Package Manager with DTDHuawei package.

In the assets/Plugins/Android/ folder create a settingsTemplate.gradle file with the following content:

import java.nio.file.Files

static void enableJetifier(Project project) {
    project.ext['android.useAndroidX'] = true
    project.ext['android.enableJetifier'] = true
}

static void addBuildscript(Project project) {
    project.buildscript {
        repositories {
            maven { url 'https://plugins.gradle.org/m2/' } 
            maven { url 'https://developer.huawei.com/repo/' }
        }

        dependencies {
            classpath 'com.huawei.agconnect:agcp:1.6.5.300'
        }
    }
}

static void applyPlugins(Project project) {
    if (project.name != 'launcher') return

    project.afterEvaluate {
        it.apply plugin: 'com.huawei.agconnect'
    }
}

static void copyAppGalleryJson(Project project) {
    if (project.name != 'launcher') return

    def destinationFile = new File("${project.rootDir}/launcher/agconnect-services.json")
    if (destinationFile.exists()) return

    def sourceFile = new File("${project.rootDir}/unityLibrary/devtodev.plugin/agconnect-services.json")
    Files.copy(sourceFile.toPath(), destinationFile.toPath())
}

gradle.rootProject {
    it.afterEvaluate {
        it.allprojects {
            enableJetifier(it)
            addBuildscript(it)
            applyPlugins(it)
            copyAppGalleryJson(it)
        }
    }
}

include ':launcher', ':unityLibrary'
**INCLUDES**

Open Window → devtodev and select Create android plugin folder
Copy the “agconnect-services.json“ file to the Assets\Plugins\Android\devtodev.plugin folder
Open Assets → External Dependency Manager → Android ResolverAssets → External Dependency Manager → Android Resolver and click Resolve

To proguard add the following rule:

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

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.

Your app must request tracking authorization before it can get the advertising identifier. See the detailed instruction on how to request it.

If you want to disable tracking of advertising identifiers, you need to open the DTDPostProcesssAnalytics.cs file and comment out the line 39: project.AddFrameworkToProject(targetGuid, "AppTrackingTransparency.framework", true);

iOS SDK Signature and Privacy Manifest

At WWDC23 Apple introduced new privacy manifests and xcframework signature. More information about it can be found here.

Apps targeted at children

Please study the following requirements:

If your app has to comply with the legal requirements (COPPA), use the following recommendations:

Implement the CoppaControlEnable method. The method disables collection of ad IDs and vendor IDs (IDFA, IDFV).
To comply with Apple’s guidelines, remove from Xcode project:
1. AppTrackingTransparency.framework and all the links pointing to it.
2. AdSupport.framework and all the links pointing to it.
3. Set IS_COPPA_ENABLED = true in DTDPostProcessAnalytics.cs (Assets/DevToDev/Analytics/Editor)

Implement the CoppaControlEnable method. The method disables collection of ad IDs and vendor IDs.
If you are using DTDGoogle or DTDHuawei from Unity Package Manager, disable it.

If you are using DTDGoogle.unitypackage, remove the following files:

Assets\DevToDev\Analytics\Editor\GoogleDependencies.xml
Assets\Plugins\DevToDev\Android\DTDGoogleAndroid.aar

If you are using DTDHuawei.unitypackage, remove the following files:

Assets\Plugins\Android\settingsTemplate.gradle
Assets\Plugins\DevToDev\Android\DTDHuaweiAndroid.aar
Assets\DevToDev\Analytics\Editor\HuaweiDependencies.xml

Call the CoppaControlEnable method before SDK initialization. If the method was not called, the SDK will work as before.

DTDAnalytics.CoppaControlEnable();
DTDAnalytics.Initialize("App ID", config);

Unreal Engine

Plugin installation

The SDK is available in GitHub repository. Download the Source code (zip) of latest release. Unzip the archive and copy DTDAnalytics folder 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

HasValue

bool

Option label

Value

int32

Parameter value

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

HasValue

bool

Option label

Value

FString

Parameter value

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

LogLevel

EDTDLogLevel

Logging level

CurrentLevel

FDTDOptionalInt32

Current level

UserId

FDTDOptionalString

User ID

ApplicationVersion

FDTDOptionalString

Application version (Windows)

TrackingAvailability

EDTDTrackingStatus

Tracking settings

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

StringParameters

TMap<FString, FString>

String parameters

IntParameters

TMap<FString, int64>

Integer parameters

FloatParameters

TMap<FString, float>

Real parameters (floating-point numbers)

BoolParameters

TMap<FString, bool>

Boolean parameters

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

Difficulty

FDTDOptionalInt32

Difficulty

Source

FDTDOptionalString

Source

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

SuccessfulCompletion

bool

Successful completion of the progression (‘false’ by default)

Duration

int32

Duration (if 0, duration is calculated automatically)

Spent

TMap<FString, int64>

Resources spent

Earned

TMap<FString, int64>

Resources earned

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

appKey

FString

You can find it in the settings of the corresponding application in devtodev (Settings → SDK → Integration → Credentials)

UDTDAnalyticsBPLibrary::Initialize("AppKey");

SDK initialization with parameters:

Member

Type

Description

appKey

FString

You can find it in the settings of the corresponding application in devtodev (Settings → SDK → Integration → Credentials)

config

FDTDAnalyticsConfiguration

Initialization parameters

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

Godot Engine

Integration Godot SDK

The DevToDev SDK extends the Godot engine in a modular way and supports platforms: MacOS, iOS, Android.

Requirements

Godot engine 4.0+ ()
.
build system.
SDK module source code ()

The SDK module installation

The SDK module is available in . Download the Source code of latest release and copy d2d_analytics folder to the modules(/godot/modules/) folder of Godot engine source code.

To work in the Godot editor, compile the engine source code and the analytics module:

scons platform=macos arch=x86_64
scons platform=macos arch=arm64
lipo -create bin/godot.macos.editor.x86_64 bin/godot.macos.editor.arm64 -output bin/godot.macos.editor.universal

cp -r misc/dist/macos_tools.app ./Godot.app
mkdir -p Godot.app/Contents/MacOS
cp bin/godot.macos.editor.universal Godot.app/Contents/MacOS/Godot
cp modules/d2d_analytics/native/macos/libDTDAnalytics.dylib Godot.app/Contents/MacOS/
chmod +x Godot.app/Contents/MacOS/Godot
codesign --force --timestamp --options=runtime --entitlements misc/dist/macos/editor.entitlements -s - Godot.app

SDK Initialization

For initialization, add the following code at the start of your application:

var config = GDDTDAnalyticsConfiguration.new()
config.logLevel = GDDTDLogLevel.Debug
DTDAnalytics.InitializeWithConfig("AppID", config)

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

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

Example:

var config = GDDTDAnalyticsConfiguration.new() 
config.logLevel = GDDTDLogLevel.No 
config.trackingStatus = GDDTDTrackingStatus.Enable 
config.currentLevel = 1 
config.userId = "unique_userId" 
DTDAnalytics.InitializeWithConfig("AppID", config)

Project export

Export for MacOS

Open the Export Template Manager to download and install templates:

scons platform=macos target=template_debug arch=x86_64
scons platform=macos target=template_debug arch=arm64
lipo -create bin/godot.macos.template_debug.x86_64 bin/godot.macos.template_debug.arm64 -output bin/godot.macos.template_debug.universal

The next step is to prepare a custom template as a macos.zip archive. Don't forget to add the DTDAnalytics native library, copy libDTDAnalytics.dylib to macos_template.app/Contents/MacOS/.

cp -r misc/dist/macos_template.app .
mkdir -p macos_template.app/Contents/MacOS
cp bin/godot.macos.template_debug.universal macos_template.app/Contents/MacOS/godot_macos_debug.universal
cp modules/d2d_analytics/native/macos/libDTDAnalytics.dylib macos_template.app/Contents/MacOS/
chmod +x macos_template.app/Contents/MacOS/godot_*
chmod +x macos_template.app/Contents/MacOS/libDTDAnalytics.dylib
zip -q -9 -r macos.zip macos_template.app

Open the Export menu and specify the path to the prepared custom template:

Export for iOS

Open the Export Template Manager to download and install templates:

scons p=ios target=template_debug
scons p=ios target=template_release
scons p=ios target=template_debug ios_simulator=yes arch=x86_64
scons p=ios target=template_debug ios_simulator=yes arch=arm64

cp -r misc/dist/ios_xcode .
cp bin/libgodot.ios.template_debug.arm64.a ios_xcode/libgodot.ios.debug.xcframework/ios-arm64/libgodot.a
lipo -create bin/libgodot.ios.template_debug.arm64.simulator.a bin/libgodot.ios.template_debug.x86_64.simulator.a -output ios_xcode/libgodot.ios.debug.xcframework/ios-arm64_x86_64-simulator/libgodot.a

cp bin/libgodot.ios.template_release.arm64.a ios_xcode/libgodot.ios.release.xcframework/ios-arm64/libgodot.a
lipo -create bin/libgodot.ios.template_debug.arm64.simulator.a bin/libgodot.ios.template_debug.x86_64.simulator.a -output ios_xcode/libgodot.ios.release.xcframework/ios-arm64_x86_64-simulator/libgodot.a

The next step is to prepare a custom template as an ios.zip archive. Don't forget to add the DTDAnalytics native library, copy DTDAnalytics.xcframework to ios_xcode/.

cp -r modules/d2d_analytics/native/ios/DTDAnalytics.xcframework ios_xcode/
cd "ios_xcode"
zip -q -r ios.zip ./*
cd ..
cp "ios_xcode/ios.zip" ./

In XCode project:

Add DTDAnalytics.xcframework to the project (with Do Not Embed specified)
Create Bridging-Header. To do this, add any swift file to the project (don't delete it later) and select 'Create Bridging Header' in the dialogue box that appears.
Add frameworks:
- AppTrackingTransparency.framework
- AdSupport.framework

Export for Android

Сlick to install android templates:

After installing the template, an android folder will appear in your project.

Move the d2d_analytics/native/androidAnalytics.aar to the android/plugins/ folder in your project. You will also need to create an Analytics.gdap file in android/plugins/ with the following content:

[config]

name="Analytics"
binary_type="local"
binary="Analytics.aar"

[dependencies]

remote=[
    "com.google.code.gson:gson:2.8.9", 
    "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.2", 
    "com.google.android.gms:play-services-ads-identifier:18.0.1",
    "com.devtodev:android-google:1.0.0"
    // Optional (recommended)
    "com.android.installreferrer:installreferrer:2.2"
    ]

custom_maven_repos=["https://repo.maven.apache.org/maven2/"]

Next, Analytics should appear in the Plugins section, check it out:

// Example. For debug on arm64v8 architecture use:
scons platform=android target=template_debug arch=arm64v8
//for release:
scons platform=android target=template_release arch=arm64v8

After successful compilation execute the following commands:

// Example. For debug on arm64v8 architecture use:
scons platform=android target=template_debug arch=arm64v8
//for release:
scons platform=android target=template_release arch=arm64v8

In the next step in godot-4.0-stable/bin you will see godot-lib.template_debug.aar or

godot-lib.template_relaese.aar.

You need to copy and replace this file to the previously installed template in your project at the path:

appName/android/build/libs/debug - for debugging
appName/android/build/libs/release - for release

After these steps, you are ready to export your Android app.

Make sure that Use Gradle Build (in the Gradle Build section), Analytics (in the Plugins section) and the previously compiled Architecture (in the Architectures section) are selected.

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

DTDAnalytics.adImpression(network: "Network name",
                          revenue: 0.15,
                          placement: "Placement of the banner",
                          unit: "Banner title")

Parameter

Type

Restrictions

Description

[DTDAnalytics adImpressionWithNetwork:@"Network name"
                              revenue:0.15f
                            placement:@"Placement of the banner"
                                unit:@"Banner title"];

Parameter

Type

Restrictions

Description

DTDAnalytics.adImpression(
    network = "Network name",
    revenue = 0.45,
    placement = "Placement of the banner",
    unit = "Banner title"
)

DTDAnalytics.INSTANCE.adImpression(
        "Network name",
        0.45,
        "Placement of the banner",
        "Banner title"
);

var network = "Network name";
var revenue = 0.15;
var placement = "Placement of the banner";
var unit = "Banner title";
DTDAnalytics.AdImpression(network, revenue, placement, unit);

var network = "Network name";
var revenue = 0.15;
var placement = "Placement of the banner";
var unit = "Banner title";
DTDAnalytics.AdImpression(network, revenue, placement, unit);

UDTDAnalyticsBPLibrary::AdImpression("NetworkName", 0.36, "BannerPlacement", "BannerTitle");

DTDAnalytics.AdImpression("Network name", 0.15, "Placement of the banner", "Banner title")

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.

let network = DTDSocialNetwork(name: "NetworkName")
DTDAnalytics.socialNetworkConnect(socialNetwork: network)

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.

DTDSocialNetwork *network = [[DTDSocialNetwork alloc] initWithName:@"NetworkName"];
[DTDAnalytics socialNetworkConnect:network];

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.

DTDAnalytics.socialNetworkPost(
    socialNetwork = DTDSocialNetwork.facebook
)

Use the following constants to specify a social network:

DTDSocialNetwork.Companion.getFacebook(), DTDSocialNetwork.Companion.getVkontakte(), DTDSocialNetwork.Companion.getTwitter(), DTDSocialNetwork.Companion.getGoogleplus(), DTDSocialNetwork.Companion.Whatsapp(), DTDSocialNetwork.Companion.getViber(), DTDSocialNetwork.Companion.getEvernote(), DTDSocialNetwork.Companion.getGooglemail(), DTDSocialNetwork.Companion.getLinkedin(), DTDSocialNetwork.Companion.getPinterest(), DTDSocialNetwork.Companion.getQzone(), DTDSocialNetwork.Companion.getReddit(), DTDSocialNetwork.Companion.getRenren(), DTDSocialNetwork.Companion.getTumblr()

Or create an object with the desired social media name.

DTDAnalytics.INSTANCE.socialNetworkConnect(DTDSocialNetwork.Companion.getFacebook());

Use the following constants to specify a social network:

Or create an object with the desired social media name:

var network = new DTDSocialNetwork(name: "NetworkName");
DTDAnalytics.SocialNetworkConnect(socialNetwork: network);

Use the following constants to specify a social network:

Or create an object with the desired social media name:

var network = new DTDSocialNetwork(name: "NetworkName");
DTDAnalytics.SocialNetworkConnect(socialNetwork: network);

window.devtodev.socialNetworkConnect('NetworkName')

UDTDAnalyticsBPLibrary::SocialNetworkConnect(EDTDSocialNetwork::Linkedin);

Or use special method for custom social network:

UDTDAnalyticsBPLibrary::SocialNetworkConnectCustom("SocialNetworkName");

Use the following constants to specify a social network:

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

DTDAnalytics.SocialNetworkConnect(GDDTDSocialNetwork.Facebook())

Or create an object with the desired social media name.

let network = GDDTDSocialNetwork(name: "NetworkName")
DTDAnalytics.SocialNetworkConnect(network)

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

DTDAnalytics.socialNetworkPost(socialNetwork: .facebook, 
                                      reason: "New level reached")

[DTDAnalytics socialNetworkPost:DTDSocialNetwork.facebook withReason:@"New level reached"];

DTDAnalytics.socialNetworkPost(
    socialNetwork = DTDSocialNetwork.facebook,
    reason = "New level reached"
)

 DTDAnalytics.INSTANCE.socialNetworkPost(
        DTDSocialNetwork.Companion.getFacebook(),
        "New level reached"
)

DTDAnalytics.SocialNetworkPost(
    socialNetwork: DTDSocialNetwork.facebook,
    reason: "New level reached");

DTDAnalytics.SocialNetworkPost(
    socialNetwork: DTDSocialNetwork.Facebook,
    reason: "New level reached");

window.devtodev.socialNetworkPost("NetworkName", "New level reached")

UDTDAnalyticsBPLibrary::SocialNetworkPost(EDTDSocialNetwork::Linkedin, "PostReason");

UDTDAnalyticsBPLibrary::SocialNetworkPostCustom("SocialNetworkName", "PostReason");

DTDAnalytics.SocialNetworkPost(GDDTDSocialNetwork.Facebook(), "New level reached")

Referrer

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

let referrerData = [DTDReferralProperty.source: "AdWords",
                    DTDReferralProperty.medium: "CPI",
                    DTDReferralProperty.content: "Snow Boots",
                    DTDReferralProperty.campaign: "Warm Snow Boots",
                    DTDReferralProperty.term: "shoes+boots"]
                    
DTDAnalytics.referrer(utmData: referrerData)

NSDictionary <DTDReferralProperty *, NSString *> * referrerData = @{
  DTDReferralProperty.source: @"AdWords",
  DTDReferralProperty.medium: @"CPI",
  DTDReferralProperty.content: @"Snow Boots",
  DTDReferralProperty.campaign: @"Warm Snow Boots",
  DTDReferralProperty.term: @"shoes+boots",
};
[DTDAnalytics referrer:referrerData];

enum class DTDReferralProperty {
    Source,
    Campaign,
    Content,
    Medium,
    Term;
}

val referrer = mapOf(
        DTDReferralProperty.Medium to "some value",
        DTDReferralProperty.Campaign to "some value"
)    
DTDAnalytics.referrer(utmData = referrer)

public final enum class DTDReferralProperty {
    Source,
    Campaign,
    Content,
    Medium,
    Term;
}

Map<DTDReferralProperty, String> propertyStringHashMap = new HashMap<>();
propertyStringHashMap.put(DTDReferralProperty.Medium, "some value");
propertyStringHashMap.put(DTDReferralProperty.Campaign, "some value");
DTDAnalytics.INSTANCE.referrer(propertyStringHashMap);

var referrer = new Dictionary<DTDReferralProperty, string>
{
    [DTDReferralProperty.Medium] = "some value",
    [DTDReferralProperty.Campaign] = "some value"
};
DTDAnalytics.Referrer(referrer: referrer);

var referrer = new Dictionary<DTDReferralProperty, string>
{
    [DTDReferralProperty.Medium] = "some value",
    [DTDReferralProperty.Campaign] = "some value"
};
DTDAnalytics.Referrer(referrer: referrer);

var referrer = {
    source: "some source",
    term: "some term",
    medium: "some medium",
    source: "some source",
    content: "some content",
    campaign: "some campaign",
};
window.devtodev.referrer(referrer)

TMap<EDTDReferralProperty, FString> referrer;
referrer.Add(EDTDReferralProperty::Source, "Source");
referrer.Add(EDTDReferralProperty::Medium, "Medium ");
referrer.Add(EDTDReferralProperty::Content, "Content ");
referrer.Add(EDTDReferralProperty::Campaign, "Campaign ");
referrer.Add(EDTDReferralProperty::Term, "Term ");
UDTDAnalyticsBPLibrary::Referrer(referrer);

var reffer = GDDTDReferralProperty.new()
reffer.AddCampaign("Warm Snow Boots")
reffer.AddContent("Snow Boots")
reffer.AddMedium("CPI")
reffer.AddSource("AdWords")
reffer.AddTerm("shoes+boots")

DTDAnalytics.Referrer(reffer)

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.

DTDAnalytics.sendBufferedEvents()

[DTDAnalytics sendBufferedEvents];

DTDAnalytics.sendBufferedEvents()

DTDAnalytics.INSTANCE.sendBufferedEvents();

DTDAnalytics.SendBufferedEvents();

DTDAnalytics.SendBufferedEvents();

window.devtodev.sendBufferedEvents()

UDTDAnalyticsBPLibrary::SendBufferedEvents();

DTDAnalytics.SendBufferedEvents()

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:

DispatchQueue.main.async{}

dispatch_async(dispatch_get_main_queue(), ^{ });

Handler(Looper.getMainLooper()).post{}

ContextCompat.getMainExecutor(context).execute(() -> {
    // This is where your UI code goes.
});

var result = await DTDAnalytics.GetUserId();

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

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

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.

DTDAnalytics.setTrackingAvailability(value: true)

[DTDAnalytics trackingAvailability:true];

DTDAnalytics.setTrackingAvailability(value = true)

DTDAnalytics.INSTANCE.setTrackingAvailability(true);

DTDAnalytics.SetTrackingAvailability(trackingValue: true);

DTDAnalytics.SetTrackingAvailability(trackingValue: true);

window.devtodev.setTrackingAvailability(true)

UDTDAnalyticsBPLibrary::SetTrackingAvailability(true);

DTDAnalytics.SetTrackingAvailability(true)

Getting device ID

Get device ID. String type.

DTDAnalytics.getDeviceId { deviceId in
  // your code
}

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

DTDAnalytics.getDeviceId { deviceId ->
  // your code
}

DTDAnalytics.INSTANCE.getDeviceId(deviceId ->
        // your code
        null
);

var devideId = await DTDAnalytics.GetDeviceId();

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

var devideId = window.devtodev.getDeviceId()

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

DTDAnalytics.GetDeviceId(getDeviceHandler)

func getDeviceHandler(deviceId: String):
    print(deviceId)

Getting the devtodev SDK version

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

DTDAnalytics.getSDKVersion { sdkVersion in
  // your code
}

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

DTDAnalytics.getSDKVersion { sdkVersion ->
  // your code
}

DTDAnalytics.INSTANCE.getSdkVersion ( sdkVersion ->
         // your code
         null
);

var sdkVersion = DTDAnalytics.GetSdkVersion();

DTDAnalytics.GetSdkVersion( version => {
  //your code
});

var sdkVersion = window.devtodev.getSDKVersion()

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

DTDAnalytics.GetSdkVersion(getSdkVersionHandler)

func getSdkVersionHandler(sdkVersion: String):
    print(sdkVersion)

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

DTDAnalytics.getTrackingAvailability { trackingAvailability in
  // your code
}

[DTDAnalytics trackingAvailabilityHandler:^(BOOL trackingAvailability) {
  // your code
}];

DTDAnalytics.getTrackingAvailability { trackingAvailability ->
  // your code
}

DTDAnalytics.INSTANCE.getTrackingAvailability( trackingAvailability ->
         // your code
         null
);

var trackingAvailability = await DTDAnalytics.GetTrackingAvailability();

DTDAnalytics.GetTrackingAvailability( tracking => {
  //your code
});

var trackingAvailability = window.devtodev.getTrackingAvailability()

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

DTDAnalytics.GetTrackingAvailability(getTrackingAvailabilityHandler)

func getTrackingAvailabilityHandler(trackingAvailability: bool):
    print(str(trackingAvailability))

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:

DTDAnalytics.setIdentifiersListener(listener: self)

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

func didReceiveDevtodevId(with devtodevId: Int) {
  /// your code
}

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:

@interface Controller ()  <DTDIdentifiersListener>
[DTDAnalytics setIdentifiersListenerWithListener:self];

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

- (void)didReceiveDevtodevIdWith:(NSInteger)devtodevId {
  // your code
}

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:

DTDAnalytics.setIdentifiersListener(object : DTDIdentifiersListener {
            override fun didReceiveDevtodevId(devtodevId: Long) {
               /// your code
            }
        })

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:

DTDAnalytics.INSTANCE.setIdentifiersListener(new DTDIdentifiersListener() {
            @Override
            public void didReceiveDevtodevId(long devtodevId) {
                // your code
            }
});

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:

DTDAnalytics.SetIdentifiersListener(devtodevId =>
{
    // Your code...
});

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:

DTDAnalytics.SetIdentifiersListener(devtodevId =>
{
    // Your code...
});

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

window.devtodev.setIdentifiersListener((devtodevId) =>
{
// Your code...
})

auto listener = new FDTDGetterLongDelegate();
listener->BindLambda([](int64 value)
{
	// Your code...
});
UDTDAnalyticsBPLibrary::SetIdentifiersListener(*listener);

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

DTDAnalytics.SetIdentifiersCallback(identifiersUpdated)

func identifiersUpdated(devtodevID: int):
    print("SetIdentifiersCallback DevtodevID is " + str(devtodevID))

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

Initialization callback

To receive a callback when the SDK initialization is complete, you can use a method that will implement the initialization callback. When the SDK completes the initialization, the callback will be called on the main application thread.

We recommend implementing a callback before calling initialization.

DTDAnalytics.setInitializationCompleteCallback {
  print("Initialized has been finished.")
}
let config = DTDAnalyticsConfiguration()
config.logLevel = .error
DTDAnalytics.initialize(applicationKey: "App ID", configuration: config)

[DTDAnalytics setInitializationCompleteCallback:^{
  NSLog(@"%@", @"Initialized has been finished.");
}];
DTDAnalyticsConfiguration *config = [[DTDAnalyticsConfiguration alloc] init];
config.logLevel = DTDLogLevelError;
[DTDAnalytics applicationKey:@"App ID" configuration:config];

DTDAnalytics.setInitializationCompleteCallback {
    Log.d("TAG", "Initialized has been finished.")
}
val config = DTDAnalyticsConfiguration()
config.logLevel = DTDLogLevel.Error
DTDAnalytics.initialize(appKey = "App ID", analyticsConfiguration = config, context = this)

DTDAnalytics.INSTANCE.setInitializationCompleteCallback(() -> {
    Log.d("TAG", "Initialized has been finished.");
    return null;
});
DTDAnalyticsConfiguration config = new DTDAnalyticsConfiguration();
config.setLogLevel(DTDLogLevel.Error);
DTDAnalytics.INSTANCE.initialize("App ID", config, this);

DTDAnalytics.LogLevel = DTDLogLevel.Error;
DTDAnalytics.SetInitializationCompleteCallback(()=>Console.WriteLine($"Initialization has been finished"));
DTDAnalytics.Initialize("APP_KEY");

DTDAnalytics.SetInitializationCompleteCallback(() =>
{
    Debug.Log("Initialized has been finished.");
});

DTDAnalytics.SetLogLevel(DTDLogLevel.Error);
DTDAnalytics.Initialize("APP_KEY");

func initCompleteCallback():
  print("Initialized has been finished.")

func _ready():
  DTDAnalytics.SetInitializationCompleteCallback(initCompleteCallback)
  var config = GDDTDAnalyticsConfiguration.new()
  config.logLevel = GDDTDLogLevel.Error
  DTDAnalytics.InitializeWithConfig(appKey, config)

Anticheat methods

Recommended sequence of actions when working with transactions

Get response about a completed transaction from the payment system.
Either send data about the received transaction for verification by calling devtodev anti-cheat methods or use your own tools for transaction verification.
If the transaction has successfully passed verification, perform the Payment event.
If the transaction hasn’t passed verification, do not perform the Payment event and mark the user as a cheater.

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.

We strongly discourage you from using verification 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!

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

`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 = "receipt", 
    signature = "signature", 
    publickKey = "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.

DTDAntiCheat.INSTANCE.verifyPayment("receipt", "signature", "publickKey",
                dtdVerifyResponse -> {
                // your code
                    switch (dtdVerifyResponse.getReceiptStatus()) {
                        case ReceiptValid:
                            // your code
                            break;
                        case ReceiptNotValid:
                            // your code
                            break;
                        case ReceiptInternalError:
                            // your code
                            break;
                        case ReceiptServerError:
                            // your code
                            break;
                    }
                    return null;
                });

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

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();
}

`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 publicKey, string receipt, Action completionHandler)

Example:

public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
{
    DTDAntiCheat.VerifyPayment(yourPublicKey, 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.
        }
    });
}

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

public void MyNativeCallback (string publicKey, string receipt, string signature)
{
    DTDAntiCheat.VerifyPayment(publicKey, receipt, signature, 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 receipt, 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 receipt, 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 receipt 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

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

Parameter

Type

Restrictions

Description

DTDAnalytics.adImpression(network: "Network name",
                          revenue: 0.15,
                          placement: "Placement of the banner",
                          unit: "Banner title")

Parameter

Type

Restrictions

Description

[DTDAnalytics adImpressionWithNetwork:@"Network name"
                              revenue:0.15f
                            placement:@"Placement of the banner"
                                unit:@"Banner title"];

Parameter

Type

Restrictions

Description

DTDAnalytics.adImpression(
    network = "Network name",
    revenue = 0.45,
    placement = "Placement of the banner",
    unit = "Banner title"
)

Parameter

Type

Restrictions

Description

DTDAnalytics.INSTANCE.adImpression(
        "Network name",
        0.45,
        "Placement of the banner",
        "Banner title"
);

Parameter

Type

Restrictions

Description

var network = "Network name";
var revenue = 0.15;
var placement = "Placement of the banner";
var unit = "Banner title";
DTDAnalytics.AdImpression(network, revenue, placement, unit);

Parameter

Type

Restrictions

Description

var network = "Network name";
var revenue = 0.15;
var placement = "Placement of the banner";
var unit = "Banner title";
DTDAnalytics.AdImpression(network, revenue, placement, unit);

UDTDAnalyticsBPLibrary::AdImpression("NetworkName", 0.36, "BannerPlacement", "BannerTitle");

Parameter

Type

Restrictions

Description

DTDAnalytics.AdImpression("Network name", 0.15, "Placement of the banner", "Banner title")

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.

let network = DTDSocialNetwork(name: "NetworkName")
DTDAnalytics.socialNetworkConnect(socialNetwork: network)

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.

DTDSocialNetwork *network = [[DTDSocialNetwork alloc] initWithName:@"NetworkName"];
[DTDAnalytics socialNetworkConnect:network];

Use the following constants to specify a social network:

Or create an object with the desired social media name.

DTDAnalytics.socialNetworkPost(
    socialNetwork = DTDSocialNetwork.facebook
)

Use the following constants to specify a social network:

Or create an object with the desired social media name.

DTDAnalytics.INSTANCE.socialNetworkConnect(DTDSocialNetwork.Companion.getFacebook());

Use the following constants to specify a social network:

Or create an object with the desired social media name:

var network = new DTDSocialNetwork(name: "NetworkName");
DTDAnalytics.SocialNetworkConnect(socialNetwork: network);

Use the following constants to specify a social network:

Or create an object with the desired social media name:

var network = new DTDSocialNetwork(name: "NetworkName");
DTDAnalytics.SocialNetworkConnect(socialNetwork: network);

window.devtodev.socialNetworkConnect('NetworkName')

UDTDAnalyticsBPLibrary::SocialNetworkConnect(EDTDSocialNetwork::Linkedin);

Or use special method for custom social network:

UDTDAnalyticsBPLibrary::SocialNetworkConnectCustom("SocialNetworkName");

Use the following constants to specify a social network:

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

DTDAnalytics.SocialNetworkConnect(GDDTDSocialNetwork.Facebook())

Or create an object with the desired social media name.

let network = GDDTDSocialNetwork(name: "NetworkName")
DTDAnalytics.SocialNetworkConnect(network)

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

DTDAnalytics.socialNetworkPost(socialNetwork: .facebook, 
                                      reason: "New level reached")

[DTDAnalytics socialNetworkPost:DTDSocialNetwork.facebook withReason:@"New level reached"];

DTDAnalytics.socialNetworkPost(
    socialNetwork = DTDSocialNetwork.facebook,
    reason = "New level reached"
)

 DTDAnalytics.INSTANCE.socialNetworkPost(
        DTDSocialNetwork.Companion.getFacebook(),
        "New level reached"
)

DTDAnalytics.SocialNetworkPost(
    socialNetwork: DTDSocialNetwork.facebook,
    reason: "New level reached");

DTDAnalytics.SocialNetworkPost(
    socialNetwork: DTDSocialNetwork.Facebook,
    reason: "New level reached");

window.devtodev.socialNetworkPost("NetworkName", "New level reached")

UDTDAnalyticsBPLibrary::SocialNetworkPost(EDTDSocialNetwork::Linkedin, "PostReason");

UDTDAnalyticsBPLibrary::SocialNetworkPostCustom("SocialNetworkName", "PostReason");

DTDAnalytics.SocialNetworkPost(GDDTDSocialNetwork.Facebook(), "New level reached")

Referrer

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

let referrerData = [DTDReferralProperty.source: "AdWords",
                    DTDReferralProperty.medium: "CPI",
                    DTDReferralProperty.content: "Snow Boots",
                    DTDReferralProperty.campaign: "Warm Snow Boots",
                    DTDReferralProperty.term: "shoes+boots"]
                    
DTDAnalytics.referrer(utmData: referrerData)

NSDictionary <DTDReferralProperty *, NSString *> * referrerData = @{
  DTDReferralProperty.source: @"AdWords",
  DTDReferralProperty.medium: @"CPI",
  DTDReferralProperty.content: @"Snow Boots",
  DTDReferralProperty.campaign: @"Warm Snow Boots",
  DTDReferralProperty.term: @"shoes+boots",
};
[DTDAnalytics referrer:referrerData];

enum class DTDReferralProperty {
    Source,
    Campaign,
    Content,
    Medium,
    Term;
}

val referrer = mapOf(
        DTDReferralProperty.Medium to "some value",
        DTDReferralProperty.Campaign to "some value"
)    
DTDAnalytics.referrer(utmData = referrer)

public final enum class DTDReferralProperty {
    Source,
    Campaign,
    Content,
    Medium,
    Term;
}

Map<DTDReferralProperty, String> propertyStringHashMap = new HashMap<>();
propertyStringHashMap.put(DTDReferralProperty.Medium, "some value");
propertyStringHashMap.put(DTDReferralProperty.Campaign, "some value");
DTDAnalytics.INSTANCE.referrer(propertyStringHashMap);

var referrer = new Dictionary<DTDReferralProperty, string>
{
    [DTDReferralProperty.Medium] = "some value",
    [DTDReferralProperty.Campaign] = "some value"
};
DTDAnalytics.Referrer(referrer: referrer);

var referrer = new Dictionary<DTDReferralProperty, string>
{
    [DTDReferralProperty.Medium] = "some value",
    [DTDReferralProperty.Campaign] = "some value"
};
DTDAnalytics.Referrer(referrer: referrer);

var referrer = {
    source: "some source",
    term: "some term",
    medium: "some medium",
    source: "some source",
    content: "some content",
    campaign: "some campaign",
};
window.devtodev.referrer(referrer)

TMap<EDTDReferralProperty, FString> referrer;
referrer.Add(EDTDReferralProperty::Source, "Source");
referrer.Add(EDTDReferralProperty::Medium, "Medium ");
referrer.Add(EDTDReferralProperty::Content, "Content ");
referrer.Add(EDTDReferralProperty::Campaign, "Campaign ");
referrer.Add(EDTDReferralProperty::Term, "Term ");
UDTDAnalyticsBPLibrary::Referrer(referrer);

var reffer = GDDTDReferralProperty.new()
reffer.AddCampaign("Warm Snow Boots")
reffer.AddContent("Snow Boots")
reffer.AddMedium("CPI")
reffer.AddSource("AdWords")
reffer.AddTerm("shoes+boots")

DTDAnalytics.Referrer(reffer)

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.

DTDAnalytics.sendBufferedEvents()

[DTDAnalytics sendBufferedEvents];

DTDAnalytics.sendBufferedEvents()

DTDAnalytics.INSTANCE.sendBufferedEvents();

DTDAnalytics.SendBufferedEvents();

DTDAnalytics.SendBufferedEvents();

window.devtodev.sendBufferedEvents()

UDTDAnalyticsBPLibrary::SendBufferedEvents();

DTDAnalytics.SendBufferedEvents()

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:

DispatchQueue.main.async{}

dispatch_async(dispatch_get_main_queue(), ^{ });

Handler(Looper.getMainLooper()).post{}

ContextCompat.getMainExecutor(context).execute(() -> {
    // This is where your UI code goes.
});

var result = await DTDAnalytics.GetUserId();

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

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

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

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.

DTDAnalytics.setTrackingAvailability(value: true)

[DTDAnalytics trackingAvailability:true];

DTDAnalytics.setTrackingAvailability(value = true)

DTDAnalytics.INSTANCE.setTrackingAvailability(true);

DTDAnalytics.SetTrackingAvailability(trackingValue: true);

DTDAnalytics.SetTrackingAvailability(trackingValue: true);

window.devtodev.setTrackingAvailability(true)

UDTDAnalyticsBPLibrary::SetTrackingAvailability(true);

DTDAnalytics.SetTrackingAvailability(true)

Getting device ID

Get device ID. String type.

DTDAnalytics.getDeviceId { deviceId in
  // your code
}

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

DTDAnalytics.getDeviceId { deviceId ->
  // your code
}

DTDAnalytics.INSTANCE.getDeviceId(deviceId ->
        // your code
        null
);

var devideId = await DTDAnalytics.GetDeviceId();

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

var devideId = window.devtodev.getDeviceId()

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

DTDAnalytics.GetDeviceId(getDeviceHandler)

func getDeviceHandler(deviceId: String):
    print(deviceId)

Getting the devtodev SDK version

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

DTDAnalytics.getSDKVersion { sdkVersion in
  // your code
}

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

DTDAnalytics.getSDKVersion { sdkVersion ->
  // your code
}

DTDAnalytics.INSTANCE.getSdkVersion ( sdkVersion ->
         // your code
         null
);

var sdkVersion = DTDAnalytics.GetSdkVersion();

DTDAnalytics.GetSdkVersion( version => {
  //your code
});

var sdkVersion = window.devtodev.getSDKVersion()

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

DTDAnalytics.GetSdkVersion(getSdkVersionHandler)

func getSdkVersionHandler(sdkVersion: String):
    print(sdkVersion)

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

DTDAnalytics.getTrackingAvailability { trackingAvailability in
  // your code
}

[DTDAnalytics trackingAvailabilityHandler:^(BOOL trackingAvailability) {
  // your code
}];

DTDAnalytics.getTrackingAvailability { trackingAvailability ->
  // your code
}

DTDAnalytics.INSTANCE.getTrackingAvailability( trackingAvailability ->
         // your code
         null
);

var trackingAvailability = await DTDAnalytics.GetTrackingAvailability();

DTDAnalytics.GetTrackingAvailability( tracking => {
  //your code
});

var trackingAvailability = window.devtodev.getTrackingAvailability()

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

DTDAnalytics.GetTrackingAvailability(getTrackingAvailabilityHandler)

func getTrackingAvailabilityHandler(trackingAvailability: bool):
    print(str(trackingAvailability))

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:

DTDAnalytics.setIdentifiersListener(listener: self)

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

func didReceiveDevtodevId(with devtodevId: Int) {
  /// your code
}

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:

@interface Controller ()  <DTDIdentifiersListener>
[DTDAnalytics setIdentifiersListenerWithListener:self];

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

- (void)didReceiveDevtodevIdWith:(NSInteger)devtodevId {
  // your code
}

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:

DTDAnalytics.setIdentifiersListener(object : DTDIdentifiersListener {
            override fun didReceiveDevtodevId(devtodevId: Long) {
               /// your code
            }
        })

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:

DTDAnalytics.INSTANCE.setIdentifiersListener(new DTDIdentifiersListener() {
            @Override
            public void didReceiveDevtodevId(long devtodevId) {
                // your code
            }
});

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:

DTDAnalytics.SetIdentifiersListener(devtodevId =>
{
    // Your code...
});

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:

DTDAnalytics.SetIdentifiersListener(devtodevId =>
{
    // Your code...
});

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

window.devtodev.setIdentifiersListener((devtodevId) =>
{
// Your code...
})

auto listener = new FDTDGetterLongDelegate();
listener->BindLambda([](int64 value)
{
	// Your code...
});
UDTDAnalyticsBPLibrary::SetIdentifiersListener(*listener);

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

DTDAnalytics.SetIdentifiersCallback(identifiersUpdated)

func identifiersUpdated(devtodevID: int):
    print("SetIdentifiersCallback DevtodevID is " + str(devtodevID))

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

Initialization callback

We recommend implementing a callback before calling initialization.

DTDAnalytics.setInitializationCompleteCallback {
  print("Initialized has been finished.")
}
let config = DTDAnalyticsConfiguration()
config.logLevel = .error
DTDAnalytics.initialize(applicationKey: "App ID", configuration: config)

[DTDAnalytics setInitializationCompleteCallback:^{
  NSLog(@"%@", @"Initialized has been finished.");
}];
DTDAnalyticsConfiguration *config = [[DTDAnalyticsConfiguration alloc] init];
config.logLevel = DTDLogLevelError;
[DTDAnalytics applicationKey:@"App ID" configuration:config];

DTDAnalytics.setInitializationCompleteCallback {
    Log.d("TAG", "Initialized has been finished.")
}
val config = DTDAnalyticsConfiguration()
config.logLevel = DTDLogLevel.Error
DTDAnalytics.initialize(appKey = "App ID", analyticsConfiguration = config, context = this)

DTDAnalytics.INSTANCE.setInitializationCompleteCallback(() -> {
    Log.d("TAG", "Initialized has been finished.");
    return null;
});
DTDAnalyticsConfiguration config = new DTDAnalyticsConfiguration();
config.setLogLevel(DTDLogLevel.Error);
DTDAnalytics.INSTANCE.initialize("App ID", config, this);

DTDAnalytics.LogLevel = DTDLogLevel.Error;
DTDAnalytics.SetInitializationCompleteCallback(()=>Console.WriteLine($"Initialization has been finished"));
DTDAnalytics.Initialize("APP_KEY");

DTDAnalytics.SetInitializationCompleteCallback(() =>
{
    Debug.Log("Initialized has been finished.");
});

DTDAnalytics.SetLogLevel(DTDLogLevel.Error);
DTDAnalytics.Initialize("APP_KEY");

func initCompleteCallback():
  print("Initialized has been finished.")

func _ready():
  DTDAnalytics.SetInitializationCompleteCallback(initCompleteCallback)
  var config = GDDTDAnalyticsConfiguration.new()
  config.logLevel = GDDTDLogLevel.Error
  DTDAnalytics.InitializeWithConfig(appKey, config)

Basic methods

Please take a look at our before integrating the events.

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.INSTANCE.realCurrencyPayment(
        "Order ID",
        12.5,
        "Product ID",
        "USD"
);

How to find the transaction ID in GooglePlay transaction?

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

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

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

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

DTDAnalytics.RealCurrencyPayment("orderId", 9.99, "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.

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.

Attention! We strongly recommend that you do not use custom event properties to transfer and store data that fits the definition of !

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", 
    customEventParameters = parameters
)

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

DTDAnalytics.INSTANCE.customEvent("Event name");

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

DTDCustomEventParameters parameters = new DTDCustomEventParameters();
parameters.add("key for string value", "string value");
parameters.add("key for int value", 10);
parameters.add("key for bool value", true);
parameters.add("key for double value", 12.5);
DTDAnalytics.INSTANCE.customEvent("Event name", parameters);

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

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

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

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

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

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

The following data types can be passed using parameters object:

UDTDAnalyticsBPLibrary::CustomEvent("EventName");

If you want to pass custom parameters, use:

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

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

DTDAnalytics.CustomEvent("CustomEvent")

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

var parameters = GDDTDCustomEventParams.new()
parameters.AddStringValue("str_key", "str_value")
parameters.AddBoolValue("bool_key", true)
parameters.AddIntegerValue("int_key", 100)
parameters.AddFloatValue("float_key", 0.0015)
DTDAnalytics.CustomEventWithParams("CustomEventWithParams", parameters)

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

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.

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)

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)

For example:

func purchase(_ product: Product) async throws {
  let result = try await product.purchase()

  switch result {
  case let .success(.verified(transaction)):
    // Successful purchase
    await transaction.finish()
    DTDAnalytics.subscriptionPayment(transaction: transaction, product: product)

  case let .success(.unverified(_, error)):
    // Successful purchase but transaction/receipt can't be verified
    // Could be a jailbroken phone
    print(error)

  case .pending:
    // Transaction waiting on SCA (Strong Customer Authentication) or
    // approval from Ask to Buy
    break
  case .userCancelled:
    // Do nothing
    break

  @unknown default:
    break
  }
}

Fork with Transaction.updates:

private func listenForTransactions() -> Task<Void, Error> {
  return Task.detached {
      // Iterate through any transactions that don't come from a direct call to `purchase()`.
      for await verificationResult in Transaction.updates {
      guard let case .verified(let transaction) = verificationResult else { return }
      if let revocationDate = transaction.revocationDate {
        // Remove access to the product identified by transaction.productID.
        // Transaction.revocationReason provides details about
        // the revoked transaction.
      } else if let expirationDate = transaction.expirationDate,
                    expirationDate < Date() {
        // Do nothing, this subscription is expired.
        return
      } else if transaction.isUpgraded {
        // Do nothing, there is an active transaction
       // for a higher level of service.
       return
      } else {
       // Provide access to the product identified by
       // transaction.productID.
        if let product = self.products.first(where: { $0.id == transaction.productID }) {
          DTDAnalytics.subscriptionPayment(transaction: transaction, product: product)
        }
      }
    }
  }
}

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.

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

DTDAnalytics.isRestoreTransactionHistoryRequired { [weak self] flag in
  if flag {
    Task {
      await self?.restoreTransactions()
    }
  }
}

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

extension Purchases: SKPaymentTransactionObserver {
func restoreTransactions() async {
  var transactions: [Transaction] = []
  for await transaction in Transaction.all {
    if case let .verified(verifiedTransaction) = transaction {
      transactions.append(verifiedTransaction)
    }
  }

  DTDAnalytics.subscriptionHistory(transactions: transactions)
}

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)

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)

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

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

Call the subscriptionPayment method (described below)

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

Example:

DTDAnalytics.INSTANCE.getObfuscatedAccountId(obfuscatedAccountId -> {
              BillingFlowParams flowParams = BillingFlowParams.newBuilder()
                      .setObfuscatedAccountId(obfuscatedAccountId)
                      .build();
                    
              billingClient.launchBillingFlow(activity, flowParams);
              return null;
      }
);

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

DTDAnalytics.INSTANCE.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.

purchaseList: List<String> purchaseList - a string containing list of json objects is passed to the DTDAnalytics.INSTANCE.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.INSTANCE.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.INSTANCE.isRestoreTransactionHistoryRequired is returned asynchronously, outside of the calling thread!

Example:

DTDAnalytics.INSTANCE.isRestoreTransactionHistoryRequired(isNeedRestore -> {
    if (isNeedRestore) {
        billingClient.queryPurchasesAsync(BillingClient.ProductType.SUBS, (billingResult, purchaseList) -> {
            if (billingResult.getResponseCode() == BillingClient.BillingResponseCode.OK) {
                ArrayList<String> purchases = new ArrayList<>();
                purchaseList.forEach(purchase ->
                        purchases.add(purchase.getOriginalJson())
                );
                DTDAnalytics.INSTANCE.subscriptionHistory(purchases);
            }
        });
    }
    return null;
});

In order to work with Unity subscriptions, you need to integrate the subscription module to your project. You can do it by manually importing the unitypackage.

Integration by importing the unitypackage

Import DTDAnalytics.unitypackage to your project
Import DTDSubscriptions.unitypackage to your project.

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

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

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());
    }
}

Onboarding (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.

[DTDAnalytics tutorialStep:1];

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

DTDAnalytics.tutorial(step = 1)

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

DTDAnalytics.INSTANCE.tutorial(1);

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

DTDAnalytics.Tutorial(1);

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

DTDAnalytics.Tutorial(1);

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

window.devtodev.tutorial(1)

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

UDTDAnalyticsBPLibrary::Tutorial(1);

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

DTDAnalytics.Tutorial(1)

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

Level up

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.

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.

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:

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

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

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

DTDAnalytics.INSTANCE.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:

Map<String, Long> resources = new HashMap<>();
resources.put("Currency name 1", 100L);
resources.put("Currency name 2", 10L);
DTDAnalytics.INSTANCE.levelUp(2, resources);

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

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.

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.

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.

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

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.

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

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 resources = GDDTDInt64Resources.new()
resources.AddValue("level_resource_1", 6000)
resources.AddValue("level_resource_2", 95001000)
DTDAnalytics.LevelUpWithBalance(2, resources)

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

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 = balance
)

Map<String, Long> balance = new HashMap<>();
balance.put("Currency name 1", 100L);
balance.put("Currency name 2", 10L);
DTDAnalytics.INSTANCE.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);

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

var resources = GDDTDInt64Resources.new()
resources.AddValue("current_balance_res_1", 222)
resources.AddValue("current_balance_res_2", 1500)
DTDAnalytics.CurrentBalance(resources)

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)

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

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",
    DTDAccrualType = DTDAccrualType.Earned
)

accrualType can receive one of the following values:

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

DTDAnalytics.INSTANCE.currencyAccrual(
        "Currency name 1",
        100, 
        "Source name",
        DTDAccrualType.Earned
);

accrualType can receive one of the following values:

public final enum class DTDAccrualType {
    Earned;
    Bought;
}a

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

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)

AccrualType can receive one of the following values:

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

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

Example:

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

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

DTDAnalytics.CurrencyAccrual("currencyName_1", 500, "store", GDDTDAccrualType.Bought)
DTDAnalytics.CurrencyAccrual("currencyName_2", 10, "market", GDDTDAccrualType.Earned)

acrualType can receive one of the following values:

enum  AccrualType:
    Earned = 0
    Bought = 1

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)

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

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
)
ot
DTDAnalytics.virtualCurrencyPayment(
    purchaseId = "Purchase ID",
    purchaseType = "Purchase Type",
    purchaseAmount = 100,
    map = resources
)

DTDAnalytics.INSTANCE.virtualCurrencyPayment(
        "Purchase ID",
        "Purchase type",
        100,
        10,
        "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.

Map<String, Integer> resources = new HashMap<>();
resources.put("Purchase currency name 1", 100);
resources.put("Purchase currency name 2", 10);
DTDAnalytics.INSTANCE.virtualCurrencyPayment(
        "Purchase ID",
        "Purchase Type",
        100,
        resources
);

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

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

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)

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

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

DTDAnalytics.VirtualCurrencyPayment("purchaseID", "purchaseType", 1000, 15, "resource_1")

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 = GDDTDInt32Resources.new()
resources.AddValue("resource_1", 700)
resources.AddValue("resource_2", 100)
DTDAnalytics.VirtualCurrencyPaymentWithResources("purchaseID", "purchaseType", 500, resources)

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)

DTDStartProgressionEventParameters:

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)

DTDFinishProgressionEventParameters:

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

DTDStartProgressionEventParameters:

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

DTDFinishProgressionEventParameters:

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
)

DTDStartProgressionEventParameters:

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
)

DTDFinishProgressionEventParameters:

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 = new DTDStartProgressionEventParameters();
parameters.setSource("Source");
parameters.setDifficulty(10);
DTDAnalytics.INSTANCE.startProgressionEvent("Progression event name", parameters);

DTDStartProgressionEventParameters:

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

Map<String, Long> spendMap = new HashMap<>();
spendMap.put("currency name 1", 1000L);
spendMap.put("currency name 2", 100L);

Map<String, Long> earnedMap = new HashMap<>();
spendMap.put("currency name 2", 100L);

DTDFinishProgressionEventParameters param = new DTDFinishProgressionEventParameters();
param.setSuccessfulCompletion(true);
param.setDuration(100);
param.setSpent(spendMap);
param.setEarned(earnedMap);

DTDAnalytics.INSTANCE.finishProgressionEvent("Progression event name", param);

DTDFinishProgressionEventParameters:

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

DTDStartProgressionEventParameters:

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

DTDFinishProgressionEventParameters:

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

DTDStartProgressionEventParameters:

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

DTDFinishProgressionEventParameters:

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)

startProgressionEvent event parameters:

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

startProgressionEvent event parameters:

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

UDTDAnalyticsBPLibrary::StartProgressionEvent("EventName");

Start progression event with parameters:

FDTDStartProgressionEventParams:

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

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

Finish progression event with parameters:

FDTDFinishProgressionEventParameters:TMap<FString, int64>

Example:

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

There are two methods in working with progression event:

StartProgressionEvent
FinishProgressionEvent

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

var params = GDDTDStartProgressionEventParams.new()
params.SetDifficulty(10)
params.SetSource("source_1")

DTDAnalytics.StartProgressionEventWithParams("ProgressionEventWithParams", params)

GDDTDStartProgressionEventParameters:

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

var earnedResources = GDDTDInt64Resources.new()
earnedResources.AddValue("resource_1", 200)
earnedResources.AddValue("resource_2", 1500)
	
var spentResources = GDDTDInt64Resources.new()
spentResources.AddValue("resource_1", 100)
spentResources.AddValue("resource_2", 600)
	
var params = GDDTDFinishProgressionEventParams.new()
params.SetSuccessfulCompletion(true)
params.SetEarnedResources(earnedResources)
params.SetSpentResources(spentResources)
params.SetDuration(2000)
DTDAnalytics.FinishProgressionEventWithParams("ProgressionEventWithParams", params)

GDDTDFinishProgressionEventParameters:

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

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

DTDAnalytics.INSTANCE.setUserId("Custom User ID");

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

DTDAnalytics.INSTANCE.getUserId(userID ->
      // your code
      null
);

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:

UDTDAnalyticsBPLibrary::SetUserId("Name");

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

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

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

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

DTDAnalytics.SetUserId("Custom User ID")

To get the current value of the user ID, use the asynchronous method DTDAnalytics.GetUserId(onResult: Callable)

DTDAnalytics.GetUserId(getUserIdHandler)

func getUserIdHandler(userId: String): 
  print(userId)

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.replaceUserId(
    fromUserId = "Old user id", 
    toUserId = "New user id"
)

DTDAnalytics.INSTANCE.replaceUserId("Old user id", "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");

DTDAnalytics.ReplaceUserId("Old user id", "New user id")

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(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 getCurrentLevel(completionHandler: @escaping (Int) -> Void) method

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

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

DTDAnalytics.INSTANCE.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(completionHandler: @escaping (Int) -> Void) method

DTDAnalytics.INSTANCE.getCurrentLevel ( currentLevel ->
       // your code 
       null
);

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:

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:

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

To set the current value to the user level, use SetCurrentLevel(level: int) method:

DTDAnalytics.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(onResult: Callable) method

DTDAnalytics.GetCurrentLevel(getCurrentLevelHandler)

func getCurrentLevelHandler(level: int):
    print("result is: " + str(level))

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)

[DTDUserCard setCheater:true];

DTDUserCard.setCheater(cheater = true)

DTDUserCard.INSTANCE.setCheater(true);

DTDUserCard.SetCheater(cheater: true);

DTDUserCard.SetCheater(cheater: true);

window.devtodev.user.setCheater(true)

UDTDUserCardBPLibrary::SetCheater(true);

DTDUserCard.SetCheater(true)

Tester

DTDUserCard.setTester(tester: true)

[DTDUserCard setTester:true];

DTDUserCard.setTester(tester = true)

DTDUserCard.INSTANCE.setTester(true);

DTDUserCard.SetTester(tester: true);

DTDUserCard.SetTester(tester: true);

window.devtodev.user.setTester(true)

UDTDUserCardBPLibrary::SetTester(true);

DTDUserCard.SetTester(true)

Reserved user properties

Attention! These properties have been removed since the devtodev SDK versions: iOS & macOS 2.4.0, Android 2.5.0, Unity SDK 3.8.0, Godot 1.0.0.

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.

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 (up to 500 symbols), 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.INSTANCE.set("key for string value", "string value");
DTDUserCard.INSTANCE.set("key for int value", 10);
DTDUserCard.INSTANCE.set("key for double value", 12.5);
DTDUserCard.INSTANCE.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:

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

DTDUserCard.INSTANCE.getValue("key for value", value ->
       // your code
       null
);j

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:

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

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

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

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:

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

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

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

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

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

DTDUserCard.SetString("key for string value", "string value")
DTDUserCard.SetInt("key for int value", 10)
DTDUserCard.SetFloat("key for double value", 12.5)
DTDUserCard.SetBool("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 values stored in the user profile on the SDK, you need to use the methods:

TryGetBool(key: String, callback: Callable)

TryGetFloat(key: String, callback: Callable)

TryGetInt(key: String, callback: Callable)

TryGetString(key: String, callback: Callable

DTDUserCard.TryGetInt("intKey", getIntHandler)
DTDUserCard.TryGetString("intKey", getStringHandler)
DTDUserCard.TryGetFloat("intKey", getFloatHandler)
DTDUserCard.TryGetBool("intKey", getBoolHandler)

func getIntHandler(isValid: bool, value: int):
	print("isValid = " + str(isValid) + " integer = " + str(value))

func getStringHandler(isValid: bool, value: String):
	print("isValid = " + str(isValid) + " string = " + value)
	
func getFloatHandler(isValid: bool, value: float):
	print("isValid = " + str(isValid) + " float = " + str(value))
	
func getBoolHandler(isValid: bool, value: bool):
	print("isValid = " + str(isValid) + " bool = " + str(value))

The isValid parameter is responsible for the presence of the requested key in the user card.

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(property = listOf("key for string value", "key for int value"))

DTDUserCard.INSTANCE.unset( "key for string value");

ArrayList<String> properties = new ArrayList<>();
properties.add("key for string value");
properties.add("key for int value");
DTDUserCard.INSTANCE.unset(properties);

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"])

UDTDUserCardBPLibrary::Unset("Key");

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

DTDUserCard.Unset("intKey")

var arrayOfKeys = ["floatKey", "boolKey"]
DTDUserCard.UnsetArray(arrayOfKeys)

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

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.

Description of A/B testing on the SDK side

Step 1

Some operations can take a while because the SDK operates asynchronously. These operations are:

A/B test configuration.

After you’ve created an A/B test in the web interface, the SDK will receive its configuration via the network. Use the remoteConfigWaiting property in the DTDRemoteConfig class to set the maximum time allowed for waiting for the A/B test configuration.

remoteConfigWaitingis set in seconds

By default, the remoteConfigWaiting value is equal to null. This means that the test configuration waiting time is unlimited. The limitation is important in case the test that you are about to execute can influence your app functioning.

Example: DTDRemoteConfig.remoteConfigWaiting = 10

In this case, the SDK will wait for the A/B test configuration for 10 seconds. If it won’t receive the config during the allocated time, it will notify the developer by using the onReceived(result: DTDRemoteConfigReceiveResult) method with Failure value and disable the A/B testing until the next SDK initialization.

Waiting for an A/B test group.

After the SDK finds a test, it will wait for a suitable group to include the user into and start the experiment.

By default, waiting time (groupDefinitionWaiting) is 10 seconds.

You can change this value up or down.

Example: DTDRemoteConfig.groupDefinitionWaiting = 15

In this case, the SDK will wait for a group for no more than 15 seconds. If It can't find a suitable test for 15 seconds, it will be cancelled and its activation will be impossible. After the next SDK initialization (app restart), the user will have another chance to participate in the test.

The DTDRemoteConfig.remoteConfigWaiting and DTDRemoteConfig.groupDefinitionWaitingvalues can be set only prior to SDK initialization!

Step 2

In the DTDRemoteConfig class you need to set the default variables and their values using the DTDRemoteConfig.defaults property.

The variable values in the defaults property do not change on the SDK side.

After setting up DTDRemoteConfig.defaults, you can receive the variable values by using the DTDRemoteConfig.config property.

When working with A/B tests, always use the config property to receive the actual variables and their values!

If for some reasons, the device can not be included in the test (no network or network problems, devtodev did not assign it to a group, incorrect SDK implementation, etc.) DTDRemoteConfig.config will return default values. Using this approach, you can always shape the desirable UI and the business logic of the app.

Step 3

To work with A/B testing, use the DTDAnalytics.initializeWithAbTest initialization method.

If you used DTDAnalytics.initialize previously, you need to replace it with DTDAnalytics.initializeWithAbTest as the SDK initialization method.

The DTDRemoteConfigListener interface is added to the initializeWithAbTest method. It implements three methods:

onReceived(result: DTDRemoteConfigReceiveResult)
onPrepareToChange()
onChanged(result: DTDRemoteConfigChangeResult, error: Error?)

The DTDRemoteConfigListenermethods are not called in the main thread - you need to keep this in mind when interacting with UI elements of the app. Also, do not execute operations that block the thread in the DTDRemoteConfigListener methods, because this will disable the SDK operation (see examples).

To work with A/B testing, use the [DTDAnalytics applicationKey:* abConfigListener:*] initialization method.

If you used [DTDAnalytics applicationKey:*] previously, you need to replace it with [DTDAnalytics applicationKey:* abConfigListener:*] as the SDK initialization method.

The DTDRemoteConfigListener interface is added to the [DTDAnalytics applicationKey:* abConfigListener:*] method. It implements three methods:

-(void)onReceivedResult:(enum DTDRemoteConfigReceiveResult)result
-(void)onPrepareToChange
-(void)onChangedResult:(enum DTDRemoteConfigChangeResult)result error:(NSError *)error

To work with A/B testing, use the DTDAnalytics.initializeWithAbTest initialization method.

If you used DTDAnalytics.initialize previously, you need to replace it with DTDAnalytics.initializeWithAbTest as the SDK initialization method.

The IRemoteConfigListener interface is added to the initializeWithAbTest method. It implements three methods:

onReceived(result: DTDRemoteConfigReceiveResult)
onPrepareToChange()
onChanged(result: DTDRemoteConfigChangeResult, ex: Exception?)

To work with A/B testing, use the DTDAnalytics.INSTANCE.initializeWithAbTest initialization method.

If you used DTDAnalytics.INSTANCE.initialize previously, you need to replace it with DTDAnalytics.INSTANCE.initializeWithAbTest as the SDK initialization method.

The IRemoteConfigListener interface is added to the initializeWithAbTest method. It implements three methods:

void onReceived(@NonNull DTDRemoteConfigReceiveResult result)
void onPrepareToChange()
void onChanged(@NonNull DTDRemoteConfigChangeResult result, @Nullable Exception ex)

To work with A/B testing, use the DTDAnalytics.InitializeWithAbTests initialization method.

If you used DTDAnalytics.Initialize previously, you need to replace it with DTDAnalytics.InitializeWithAbTests as the SDK initialization method.

The DTDRemoteConfigListener interface is added to the InitializeWithAbTests method. It implements three methods:

OnReceived(DTDRemoteConfigReceiveResult result)
OnPrepareToChange()
OnChanged(DTDRemoteConfigChangeResult result, string exceptionMessage = null)

To work with A/B testing, use the DTDAnalytics.InitializeWithAbTests initialization method.

If you used DTDAnalytics.Initialize previously, you need to replace it with DTDAnalytics.InitializeWithAbTests as the SDK initialization method.

The IDTDRemoteConfigListener interface is added to the InitializeWithAbTests method. It implements three methods:

OnReceived(DTDRemoteConfigReceiveResult result)
OnPrepareToChange()
OnChanged(DTDRemoteConfigChangeResult result, string error)

To work with A/B testing, use the UDTDAnalyticsBPLibrary::InitializeWithAbTest initialization method.

If you used UDTDAnalyticsBPLibrary::Initialize previously, you need to replace it with UDTDAnalyticsBPLibrary::InitializeWithAbTest as the SDK initialization method.

Implements three delegate methods:

onRemoteConfigReceive(EDTDRemoteConfigReceiveResult result)
onRemoteConfigPrepareToChange()
onRemoteConfigChange(EDTDRemoteConfigChangeResult result, FString error)

DECLARE_DELEGATE(FDTDRemoteConfigPrepareToChangeDelegate);
DECLARE_DELEGATE_OneParam(FDTDRemoteConfigReceiveResultDelegate, EDTDRemoteConfigReceiveResult);
DECLARE_DELEGATE_TwoParams(FDTDRemoteConfigChangeResultDelegate, EDTDRemoteConfigChangeResult, const FString&);

To work with A/B testing, use the DTDAnalytics.InitializeWithAbTest initialization method.

If you used DTDAnalytics.initialize previously, you need to replace it with DTDAnalytics.initializeWithAbTest as the SDK initialization method.

The InitializeWithAbTest method takes 3 Callable as arguments, to work with A/B tests it is necessary to implement:

onRemoteConfigReceive(result: GDDTDRemoteConfigReceiveResult.ReceiveResult)
onRemoteConfigPrepareToChange()
onRemoteConfigChange(result: GDDTDRemoteConfigChangeResult.ChangeResult, error: String)

Step 4

Methods implementation for working with A/B tests. When suitable conditions for the test occur, the following chain of events gets initiated:

Calling onReceived method
Calling onPrepareToChange method
Calling onChanged method

OnReceived

The onReceived method is triggered every time when the SDK loads A/B test configuration. The result argument returns the following:

Success if the configuration was loaded in the time provided. Time is set by the user in DTDRemoteConfig.remoteConfigWaiting.
Failure if the config wasn’t received during the provided time defined by the user in DTDRemoteConfig.remoteConfigWaiting.
Empty if the configuration was loaded in the time provided, but the list of experiments is empty. Time is set by the user in DTDRemoteConfig.remoteConfigWaiting.

If the DTDRemoteConfig.remoteConfigWaiting’s default value is equal to null, the OnReceived method and DTDRemoteConfigReceiveResult.Success are called when the config is received. The time of the OnReceived call depends on the network speed.

OnPrepareToChange

The onPrepareToChange() method is designed to notify the developer that the configuration of the A/B tests will be changed (the test is found or canceled, switch to a user who is not participating in the experiment, etc. (see Some features in the behavior of interfaces)).

SDK asynchronous behavior causes a gap in time between the moment the suitable conditions for the test occur and its possible activation. You need to keep this in mind when changing the app’s UI and UX and pause the user’s interaction with the app until it comes into action:

onChanged (see onChanged description) and a decision on test participation with a new config is made (see applyConfig description).
A timer on the developer’s side. The timer defines the time allocated for new config waiting. After the time has run out, waiting for the config should be canceled.

See the implementation example (Scenario 1)

After calling onPrepareToChange, the SDK executes an asynchronous request for entering the test. That will result in calling onChanged.

In case of disruption of the Internet connection or loss of focus, the test will be considered canceled until the next app launch.

onChanged

The onChanged method is triggered in one of the following cases:

The DevToDev server offers to enroll in a test. onChanged() with DTDRemoteConfigChangeResult.success is called
The DevToDev server refuses to execute the test. onChanged() with DTDRemoteConfigChangeResult.failure is called
The device has no internet connection. onChanged() with DTDRemoteConfigChangeResult.failure is called
If the offer is received after the 30 second waiting time has expired onChanged() with DTDRemoteConfigChangeResult.failure is called
The test was previously activated (during the initialization) onChanged() with DTDRemoteConfigChangeResult.success is called

If the onChanged method is triggered with status == DTDRemoteConfigChangeResult.success value, the possible options are:

Accept the configuration by calling the DTDRemoteConfig.applyConfig() method If the configuration is accepted, the default parameters and group parameters (issued by the server) will overlap. After that, the parameters of the new configuration will be available in DTDRemoteConfig.config (you can use them to change the behavior or the interface of the app).
Refuse enrollment in the test DTDRemoteConfig.resetConfig()If the test enrollment is refused or the time for decision making is up, the SDK will temporarily flag the test and it will become unavailable until the next initialization. After the next initialization, the test will be available for participation when its requirements are fulfilled.

In the cases where status == DTDRemoteConfigChangeResult.failure, the DTDRemoteConfig.applyConfig() method will be triggered and the default configuration will stay in place.

Examples of SDK integration intended for working with A/B tests

Set the default values DTDRemoteConfig.defaults = ["button_color": "green", "button_size": "8"]

Variable names have to be the same as in the ‘Group settings’ section of the web interface (see ‘web’ above). When the SDK gets included in the A/B test, the devtodev server automatically assigns it to a group.

SDK will not use new variable values that are not set in DTDRemoteConfig.defaults

Example of the DTDRemoteConfig.configvalue variants:

Key/Value

defaults

Control Group

Group A

Group B

button_color

green

blue

gray

button_size

Example of SDK initialization that includes A/B testing:

import UIKit
import DTDAnalytics

@main
class AppDelegate: UIResponder, UIApplicationDelegate, DTDRemoteConfigListener {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Config timeout, optional
        DTDRemoteConfig.remoteConfigWaiting = 10.0
        // Group timeout, optional
        DTDRemoteConfig.groupDefinitionWaiting = 15.0
        // Implementation defaults params
        DTDRemoteConfig.defaults = ["button_color": "green",
                                    "button_size": "8"]
        // Initialize SDK with ab test
        DTDAnalytics.initializeWithAbTest(applicationKey: "appKey",
                                          abConfigListener: self)
        return true
    }

    // The method is called when the configuration has been received
    func onReceived(result: DTDRemoteConfigReceiveResult) {
        print("Configuration received, result \(result)")
    }

    // Called when experiment is found
    func onPrepareToChange() {
        print("Experiment found")
    }

    // Called when SDK receives config
    func onChanged(result: DTDRemoteConfigChangeResult, error: Error?) {
        print("DTDRemoteConfigChangeResult: \(result)")
        if let error = error {
            print("DTDRemoteConfigError: \(error.localizedDescription)")
        }
        DTDRemoteConfig.applyConfig()
        // Use here or notify config listeners that actualConfig is ready
        let btnColorRemoteValue = DTDRemoteConfig.config["button_color"].stringValue
        let btnSizeRemoteValue = DTDRemoteConfig.config["button_size"].stringValue
        print("button color: \(btnColorRemoteValue)")
        print("button size: \(btnSizeRemoteValue)")
    }
}

Set the default values DTDRemoteConfig.defaults = @{"button_color": @"green", @"button_size": @"8"}

SDK will not use new variable values that are not set in DTDRemoteConfig.defaults

Example of the DTDRemoteConfig.configvalue variants:

Key/Value

defaults

Control Group

Group A

Group B

button_color

green

blue

gray

button_size

Example of SDK initialization that includes A/B testing:

#import "AppDelegate.h"
#import "DTDAnalytics/DTDAnalytics-Swift.h"

@interface AppDelegate () <DTDRemoteConfigListener>

@end

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Config timeout, optional
    DTDRemoteConfig.remoteConfigWaiting = 10.0;
    // Group timeout, optional
    DTDRemoteConfig.groupDefinitionWaiting = 15.0;
    // Implementation defaults params
    DTDRemoteConfig.defaults = @{@"button_color": @"green",
                                 @"button_size": @"8"};
    [DTDAnalytics applicationKey:@"appKey" abConfigListener:self];
    return YES;
}

// The method is called when the configuration has been received
- (void)onReceivedResult:(enum DTDRemoteConfigReceiveResult)result {
    NSLog(@"Configuration received, result %ld", (long)result);
}

// Called when experiment is found
- (void)onPrepareToChange {
    NSLog(@"Experiment found");
}

- (void)onChangedResult:(enum DTDRemoteConfigChangeResult)result error:(NSError *)error {
    NSLog(@"DTDRemoteConfigChangeResult: %ld", (long)result);
    if (error) {
        NSLog(@"DTDRemoteConfigError: %@", error.localizedDescription);
    }
    [DTDRemoteConfig applyConfig];
    // Use here or notify config listeners that actualConfig is ready
    NSString *btnColorRemoteValue = DTDRemoteConfig.config[@"button_color"].stringValue;
    NSString *btnSizeRemoteValue = DTDRemoteConfig.config[@"button_size"].stringValue;
    NSLog(@"button color: %@", btnColorRemoteValue);
    NSLog(@"button size: %@", btnSizeRemoteValue);
}
@end

Set the default values DTDRemoteConfig.defaults = mapOf("button_color" to "green", "button_size" to "8")

SDK will not use new variable values that are not set in DTDRemoteConfig.defaults

Example of the DTDRemoteConfig.configvalue variants:

Key/Value

defaults

Control Group

Group A

Group B

button_color

green

blue

gray

button_size

Example of SDK initialization that includes A/B testing:

class MainActivity : AppCompatActivity(), DTDRemoteConfigListener {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // Config timeout, optional
        DTDRemoteConfig.remoteConfigWaiting = 10.0
        // Group timeout, optional
        DTDRemoteConfig.groupDefinitionWaiting = 15.0
        // Implementation defaults params
        DTDRemoteConfig.defaults = mapOf("button_color" to "green", "button_size" to "8")
        // Initialize SDK with ab test
        DTDAnalytics.initializeWithAbTest(appKey = "appKey", context = this, abConfigListener = this)
    } 
    
    /**
     * The method is called when the configuration has been received
     */
    override fun onReceived(result: DTDRemoteConfigReceiveResult) {
       Log.d("D2D", "Configuration received") 
    }
    
    /**
     * Called when experiment is found
     */
    override fun onPrepareToChange() {
       Log.d("D2D", "Experiment found") 
    }

    /**
     * called when SDK receives config
     */
    override fun onChanged(result: DTDRemoteConfigChangeResult, ex: Exception?) {
        Log.d("D2D", "DTDRemoteConfigChangeResult: ${result.name}")
        ex?.let {
            Log.d("D2D", "DTDRemoteConfigErr: ${ex.message}")
        }
        DTDRemoteConfig.applyConfig()
        // Use here or notify config listeners that actualConfig is ready
        val btnColorRemoteValue = DTDRemoteConfig.config["button_color"].stringValue
        val btnSizeRemoteValue = DTDRemoteConfig.config["button_size"].stringValue
        Log.d("D2D", "button color: $btnColorRemoteValue")
        Log.d("D2D", "button size: $btnSizeRemoteValue")
    }
}

Set the default values:

HashMap<String, Object> map = new HashMap<>();
map.put("button_color", "green");
map.put("button_size", "8");
DTDRemoteConfig.INSTANCE.setDefaults(map);

SDK will not use new variable values that are not set in DTDRemoteConfig.defaults

Example of the DTDRemoteConfig.configvalue variants:

Key/Value

defaults

Control Group

Group A

Group B

button_color

green

blue

gray

button_size

Example of SDK initialization that includes A/B testing:

public class MainActivityJava extends AppCompatActivity implements DTDRemoteConfigListener {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Config timeout, optional
        DTDRemoteConfig.INSTANCE.setRemoteConfigWaiting(10.0);
        // Group timeout, optional
        DTDRemoteConfig.INSTANCE.setGroupDefinitionWaiting(15.0);
        // Implementation defaults params
        HashMap<String, Object> map = new HashMap<>();
        map.put("button_color", "green");
        map.put("button_size", "8");
        // Initialize SDK with ab test
        DTDRemoteConfig.INSTANCE.setDefaults(map);
    }

    @Override
    public void onReceived(@NonNull DTDRemoteConfigReceiveResult result) {
        Log.d("D2D", "Configuration received");
    }

    @Override
    public void onPrepareToChange() {
        Log.d("D2D", "Experiment found");
    }

    @Override
    public void onChanged(@NonNull DTDRemoteConfigChangeResult result, @Nullable Exception ex) {
        Log.d("D2D", "DTDRemoteConfigChangeResult: " + result.name());
        if (ex != null) {
            Log.d("D2D", "DTDRemoteConfigErr: " + ex);
        }

        DTDRemoteConfig.INSTANCE.applyConfig();
        // Use here or notify config listeners that actualConfig is ready
        String btnColorRemoteValue = DTDRemoteConfig.INSTANCE.getConfig().get("button_color").getStringValue();
        String btnSizeRemoteValue = DTDRemoteConfig.INSTANCE.getConfig().get("button_size").getStringValue();
        Log.d("D2D", "button color: " + btnColorRemoteValue);
        Log.d("D2D", "button size: " + btnSizeRemoteValue);
    }
}

Set the default values:

DTDRemoteConfig.Defaults = new Dictionary<string, object>
{
   {"button_color", "green"},
   {"button_size", 8}
};

SDK will not use new variable values that are not set in DTDRemoteConfig.Defaults

Example of the DTDRemoteConfig.Config value variants:

Key/Value

defaults

Control Group

Group A

Group B

button_color

green

blue

gray

button_size

Example of SDK initialization that includes A/B testing:

using System.Collections.Generic;
using DevToDev.Analytics;
using DevToDev.Analytics.ABTest;
using UnityEngine;

namespace AbTesting
{
    public class Example : MonoBehaviour, IDTDRemoteConfigListener
    {
        private void Start()
        {
            DontDestroyOnLoad(this);
            // Config timeout, optional
            DTDRemoteConfig.RemoteConfigWaiting = 10.0;
            // Group timeout, optional
            DTDRemoteConfig.GroupDefinitionWaiting = 15.0;
            // Implementation defaults params
            DTDRemoteConfig.Defaults = new Dictionary<string, object>
            {
                {"button_color", "green"},
                {"button_size", 8}
            };

            // Initialize SDK with ab test
            DTDAnalytics.InitializeWithAbTests("app_key", this);
        }

        // The method is called when the configuration has been received
        public void OnReceived(DTDRemoteConfigReceiveResult result)
        {
            Debug.Log($"Configuration received, result {result}");
        }
        
        // Called when experiment is found
        public void OnPrepareToChange()
        {
            Debug.Log("Experiment found");
        }

        // Called when SDK receives config
        public void OnChanged(DTDRemoteConfigChangeResult result, string exceptionText = null)
        {
            Debug.Log($"DTDRemoteConfigChangeResult: {result}");
            if (exceptionText != null)
            {
                Debug.Log($"DTDRemoteConfigError: {exceptionText}");
            }

            // Use here or notify config listeners that actualConfig is ready
            DTDRemoteConfig.ApplyConfig();
            var buttonColorRemoteValue = DTDRemoteConfig.Config["button_color"].StringValue();
            var buttonSizeRemoteValue = DTDRemoteConfig.Config["button_size"].IntValue();
            Debug.Log($"button color: {buttonColorRemoteValue}");
            Debug.Log($"button size: {buttonSizeRemoteValue}");
        }
    }
}

Set the default values:

DTDRemoteConfig.Defaults = new Dictionary<string, object> 
{
  ["button_color"] = "green",
  ["button_size"] = 8
};

SDK will not use new variable values that are not set in DTDRemoteConfig.Defaults

Example of the DTDRemoteConfig.Config value variants:

Key/Value

defaults

Control Group

Group A

Group B

button_color

green

blue

gray

button_size

Example of SDK initialization that includes A/B testing:

using DevToDev.Analytics;
using System.Collections.Generic;
using System.Diagnostics;

class MyRemoteConfigListener : IDTDRemoteConfigListener
{
    /**
     * The method is called when the configuration has been received
     */
    public void OnReceived(DTDRemoteConfigReceiveResult result)
    {
      Debug.WriteLine("Configuration has been received!");
    }
    
    /**
     * Called when experiment is found
     */
    public void OnPrepareToChange()
    {
      Debug.WriteLine("Experiment was found!");
    }
    
    /**
     * Called when SDK receives config
     */
    public void OnChanged(DTDRemoteConfigChangeResult result, string error)
    {
      Debug.WriteLine($"Result: {result}");
      if (result == DTDRemoteConfigChangeResult.Failure)
      {
        Debug.WriteLine($"Error: {error}");
      }
      
      DTDRemoteConfig.ApplyConfig();
      DTDRemoteConfig.ApplyConfig();
      var buttonColorRemoteValue = DTDRemoteConfig.Config["button_color"].StringValue;
      var buttonSizeRemoteValue = DTDRemoteConfig.Config["button_size"].IntValue;
      Debug.WriteLine($"button color: {buttonColorRemoteValue}");
      Debug.WriteLine($"button size: {buttonSizeRemoteValue}");
      // Use here or notify config listeners that config is ready
    }
}
  
public static class Program
{
    public static void Main(string[] args)
    {
        // Config timeout, optional
        DTDRemoteConfig.RemoteConfigWaiting = 10;
        
        // Group timeout, optional
        DTDRemoteConfig.GroupDefinitionWaiting = 15;
        
        // Implementation defaults params
        DTDRemoteConfig.Defaults = new Dictionary<string, object> 
        {
          ["button_color"] = "green",
          ["button_size"] = 8
        };
        
        // Create listener
        var listener = new MyRemoteConfigListener();
        
        // Initialize SDK with ab test
        DTDAnalytics.InitializeWithAbTest("appKey", listener);
    }
}

Set the default values:

// Implementation defaults params
FDTDRemoteConfigDefaults defaults;
defaults.StringDefaults.Add("button_color", "green");
defaults.IntegerDefaults.Add("button_size", 8);

SDK will not use new variable values that are not set in DTDRemoteConfig.defaults

Example of the DTDRemoteConfig.configvalue variants:

Key/Value

defaults

Control Group

Group A

Group B

button_color

green

blue

gray

button_size

Example of SDK initialization that includes A/B testing:

#include "DTDAnalytics/Public/DTDAnalyticsBPLibrary.h"
#include "DTDAnalytics/Public/DTDRemoteConfigBPLibrary.h"

UDTDAnalyticsBPLibrary::SetLogLevel(EDTDLogLevel::Debug);

// Config timeout, optional
UDTDRemoteConfigBPLibrary::SetRemoteConfigWaiting(10.0f);
// Group timeout, optional
UDTDRemoteConfigBPLibrary::SetGroupDefinitionWaiting(15.0f);

// Implementation defaults params
FDTDRemoteConfigDefaults defaults;
defaults.StringDefaults.Add("button_color", "green");
defaults.IntegerDefaults.Add("button_size", 8);

UDTDRemoteConfigBPLibrary::SetDefaults(defaults);

// The method is called when the configuration has been received
const auto onConfigReceive = new FDTDRemoteConfigReceiveResultDelegate();
onConfigReceive->BindLambda([=](EDTDRemoteConfigReceiveResult result)
{	
	UE_LOG(LogTemp, Warning, TEXT("Configuration received, result %s"), *UEnum::GetValueAsString(result));
});

// Called when experiment is found
const auto onPrepareToChange = new FDTDRemoteConfigPrepareToChangeDelegate();
onPrepareToChange->BindLambda([=]()
{
	UE_LOG(LogTemp, Warning, TEXT("Experiment found"));
});

// Called when SDK receives config
const auto onConfigChange = new FDTDRemoteConfigChangeResultDelegate();
onConfigChange->BindLambda([=](EDTDRemoteConfigChangeResult result, const FString& error)
{
	UE_LOG(LogTemp, Warning, TEXT("DTDRemoteConfigChangeResult: %s"), *UEnum::GetValueAsString(result));
	if (!error.IsEmpty()) {
		UE_LOG(LogTemp, Warning, TEXT("DTDRemoteConfigError: %s"), *error);
	}

	// Use here or notify config listeners that actualConfig is ready
	UDTDRemoteConfigBPLibrary::ApplyConfig();

	FString ButtonColorRemoteValue = UDTDRemoteConfigBPLibrary::GetRemoteConfigValue("button_color").StringValue;
        int32 buttonSizeRemoteValue = UDTDRemoteConfigBPLibrary::GetRemoteConfigValue("button_size").IntegerValue;
	UE_LOG(LogTemp, Warning, TEXT("button color: : %s"), *ButtonColorRemoteValue);
	UE_LOG(LogTemp, Warning, TEXT("button size:: %d"), buttonSizeRemoteValue);
});

// Initialize SDK with ab test
UDTDAnalyticsBPLibrary::InitializeWithAbTest("AppKey", *onConfigChange, *onPrepareToChange, *onConfigReceive);

Set the default values DTDRemoteConfig.SetDefaults()

SDK will not use new variable values that are not set in DTDRemoteConfig.defaults

Example of the DTDRemoteConfig value variants:

Key/Value

defaults

Control Group

Group A

Group B

button_color

green

blue

gray

button_size

Example of SDK initialization that includes A/B testing:

func _ready():
    	# Config timeout, optional
	DTDRemoteConfig.SetRemoteConfigWaiting(10)
	# Group timeout, optional
	DTDRemoteConfig.SetGroupDefinitionWaiting(10)
    	# Implementation defaults params
	var defaults = GDDTDRemoteConfigDefaults.new()
	defaults.AddStringValue("button_color", "green")
	defaults.AddIntegerValue("button_size", 8)
	DTDRemoteConfig.SetDefaults(defaults)
    	# Initialize SDK with ab test
	DTDAnalytics.SetLogLevel(GDDTDLogLevel.Debug)
	DTDAnalytics.InitializeWithConfigWithAbTest(
		"appKey",
		onRemoteConfigChange,
		onRemoteConfigPrepareToChange,
		onRemoteConfigReceive)

# The method is called when the configuration has been received
func onRemoteConfigReceive(result: GDDTDRemoteConfigReceiveResult.ReceiveResult):
	match result:
		GDDTDRemoteConfigReceiveResult.ReceiveResult.Failure:
			print("onRemoteConfigReceive result = Failure")
			
		GDDTDRemoteConfigReceiveResult.ReceiveResult.Success:
			print("onRemoteConfigReceive result = Success")
			
		GDDTDRemoteConfigReceiveResult.ReceiveResult.Empty:
			print("onRemoteConfigReceive result = Empty")
			
		_:
			print("onRemoteConfigReceive result = Unknown")

# Called when experiment is found		
func onRemoteConfigPrepareToChange():
	print("Experiment found")
			
# Called when SDK receives config
func onRemoteConfigChange(result: GDDTDRemoteConfigChangeResult.ChangeResult, error: String):
	if !error.is_empty(): 
		print("error = " + error)
		
	match result:
		GDDTDRemoteConfigChangeResult.ChangeResult.Failure:
			print("onRemoteConfigChange result = Failure")	
			
		GDDTDRemoteConfigChangeResult.ChangeResult.Success:
			
			print("onRemoteConfigChange result = Success")
		_: 
			print("onRemoteConfigChange result = Unknown")
			
	DTDRemoteConfig.ApplyConfig()
	
	# Use here or notify config listeners that actualConfig is ready
	var btnColorRemoteValue = DTDRemoteConfig.GetRemoteConfigValue("button_color").GetStringValue()
	var btnSizeRemoteValue = DTDRemoteConfig.GetRemoteConfigValue("button_size").GetStringValue()
	print("button color: " + btnColorRemoteValue)
	print("button size: " + btnSizeRemoteValue)

Some features of A/B testing

When the SDK finds a suitable test(s), it calls the onPrepareToChange method and reports it. Then the SDK starts a timer for 30 seconds and sends a request to the devtodev server. The server returns an experiment number and information about a group. Or the server answers that the user can not participate in the test. This process takes some time. The request and answer can take as little as milliseconds, or much longer (30 seconds maximum) if, for example, the device’s internet connection is bad. Below, you can find several use cases that may help you to solve this problem if your app’s interface is sensitive to waiting for the config from devtodev.

Description of external interfaces

DTDRemoteConfig

When working with this class, the SDK provides synchronization of threads that aims at providing safe operation taking into account the asynchrony of the SDK.

Property

Description

remoteConfigWaiting: Double

Wait time for A/B test configuration.

Default value - 0.0 (measured in seconds)

groupDefinitionWaiting: Double

Wait time for test group.

Default value - 10.0 (measured in seconds)

defaults: [String, Any]

Variables and their default values

config: DTDRemoteConfigCollection

Wrapper for remote parameters in the form of a collection. It allows access to the configuration values by using the subscripting syntaxis.

Actual variables and their values for working with A/B tests

applyConfig()

It applies the A/B testing configuration. After the call, the default parameters get matched with the group parameters.

resetConfig()

It cancels a suitable or running test

cacheTestExperiment()

A debug method for saving a test experiment after restarting the application

Property

Description

remoteConfigWaiting: double

Wait time for A/B test configuration.

Default value - 0.0 (measured in seconds)

groupDefinitionWaiting: double

Wait time for test group.

Default value - 10.0 (measured in seconds)

defaults: NSDictionary<NSString *,id>

Variables and their default values

config: DTDRemoteConfigCollection

Wrapper for remote parameters in the form of a collection. It allows access to the configuration values by using the subscripting syntaxis.

Actual variables and their values for working with A/B tests

(void) applyConfig

It applies the A/B testing configuration. After the call, the default parameters get matched with the group parameters.

(void) resetConfig

It cancels a suitable or running test

(void) cacheTestExperiment

A debug method for saving a test experiment after restarting the application

Property

Description

remoteConfigWaiting: Double

Wait time for A/B test configuration.

Default value - 0.0 (measured in seconds)

groupDefinitionWaiting: Double

Wait time for test group.

Default value - 10.0 (measured in seconds)

defaults: Map<String, Any>

Variables and their default values

config: DTDRemoteConfigCollection

Wrapper for remote parameters in the form of a collection. It allows access to the configuration values by using the subscripting syntaxis.

Actual variables and their values for working with A/B tests

applyConfig()

It applies the A/B testing configuration. After the call, the default parameters get matched with the group parameters.

resetConfig()

It cancels a suitable or running test

cacheTestExperiment()

A debug method for saving a test experiment after restarting the application

Property

Description

setRemoteConfigWaiting()

Wait time for A/B test configuration.

Default value - 0.0 (measured in seconds)

getRemoteConfigWaiting()

Wait time for test group.

setGroupDefinitionWaiting()

Wait time for test group.

Default value - 10.0 (measured in seconds)

getGroupDefinitionWaiting()

Get time for test group.

setDefaults(Map<String, ? extends Object>)

Set map of variables and their default values

Map<String,Object> getDefaults()

Get map of variables and their default values

DTDRemoteConfigCollection getConfig()

Wrapper for remote parameters in the form of a collection. It allows access to the configuration values by using the subscripting syntaxis.

Actual variables and their values for working with A/B tests

applyConfig()

It applies the A/B testing configuration. After the call, the default parameters get matched with the group parameters.

resetConfig()

It cancels a suitable or running test

cacheTestExperiment()

A debug method for saving a test experiment after restarting the application

Property

Description

double RemoteConfigWaiting {get;set;}

Wait time for A/B test configuration.

Default value - 0.0 (measured in seconds)

double GroupDefinitionWaiting {get;set}

Wait time for test group.

Default value - 10.0 (measured in seconds)

Dictionary<string, object> DTDRemoteConfig.Defaults {get;set}

Variables and their default values

DTDRemoteConfigCollection DTDRemoteConfig.Config

Wrapper for remote parameters in the form of a collection. It allows access to the configuration values by using the subscripting syntaxis.

Actual variables and their values for working with A/B tests

void ApplyConfig()

It applies the A/B testing configuration. After the call, the default parameters get matched with the group parameters.

void ResetConfig()

It cancels a suitable or running test

void CacheTestExperiment()

A debug method for saving a test experiment after restarting the application

Property

Description

RemoteConfigWaiting: double

Wait time for A/B test configuration.

Default value - 0.0 (measured in seconds)

GroupDefinitionWaiting: double

Wait time for test group.

Default value - 10.0 (measured in seconds)

Defaults: IDictionary<String, object>

Variables and their default values

Config: DTDRemoteConfigCollection

Wrapper for remote parameters in the form of a collection. It allows access to the configuration values by using the subscripting syntaxis.

Actual variables and their values for working with A/B tests

ApplyConfig()

It applies the A/B testing configuration. After the call, the default parameters get matched with the group parameters.

ResetConfig()

It cancels a suitable or running test

CacheTestExperiment()

A debug method for saving a test experiment after restarting the application

Property

Description

SetRemoteConfigWaiting(float value)

Wait time for A/B test configuration.

Default value - 0.0 (measured in seconds)

float GetRemoteConfigWaiting()

Wait time for test group.

SetGroupDefinitionWaiting(float value)

Wait time for test group.

Default value - 10.0 (measured in seconds)

GetGroupDefinitionWaiting()

Get time for test group.

SetDefaults(const FDTDRemoteConfigDefaults& defaults)

Set USTRUCT with variables and their default values

TMap<FString, FDTDRemoteConfigValue> GetConfig()

Actual variables and their values for working with A/B tests

FDTDRemoteConfigValue GetRemoteConfigValue(const FString& key)

Return actual value for variable key

bool HasKey(const FString& key)

Verify if there are any values associated with the variable key in the remote configuration.

ApplyConfig()

It applies the A/B testing configuration. After the call, the default parameters get matched with the group parameters.

ResetConfig()

It cancels a suitable or running test

CacheTestExperiment()

A debug method for saving a test experiment after restarting the application

Property

Description

void SetRemoteConfigWaiting(int value)

Wait time for A/B test configuration.

Default value - 0 (measured in seconds)

int GetRemoteConfigWaiting()

Wait time for test group.

void SetGroupDefinitionWaiting(int value)

Wait time for test group.

Default value - 10 (measured in seconds)

int GetGroupDefinitionWaiting()

Get time for test group.

void SetDefaults(defaults: GDDTDRemoteConfigDefaults)

Set GDDTDRemoteConfigDefaults with variables and their default values

GDDTDRemoteConfigValue GetRemoteConfigValue(key: String)

Return actual value for variable key

bool HasKey(key: String)

Verify if there are any values associated with the variable key in the remote configuration.

void ApplyConfig()

It applies the A/B testing configuration. After the call, the default parameters get matched with the group parameters.

void ResetConfig()

It cancels a suitable or running test

void CacheTestExperiment()

A debug method for saving a test experiment after restarting the application

DTDRemoteConfigCollection

Wrapper for remote parameters collection. Enables access to configuration values by using subscripting syntax.

Method

hasKey(key: String)

Return true if current configuration has value for a key.

DTDRemoteConfigValue

Wrapper for working with remote configuration variables. It represents a method for data source identification, as well as methods for presenting values in the form of various data types.

type

Description

DTDRemoteConfigSource.Default

The variable is set by default.

DTDRemoteConfigSource.Remote

The variable is set by the test group.

DTDRemoteConfigSource.Empty

The variable is not found in the remote configuration.

Property

type

Description

stringValue

String?

Gets the value as an optional string.

floatValue

Float

Gets the value as a Float.

doubleValue

Double

Gets the value as a Double.

Int32Value

Int32

Gets the value as an Int32.

Int64Value

Int64

Gets the value as an Int64.

integerValue

Int

Gets the value as an Int.

boolValue

Bool

Gets the value as a Bool.

Property

type

Description

stringValue

NSString

Gets the value as an optional string.

floatValue

float

Gets the value as a Float.

doubleValue

double

Gets the value as a Double.

Int32Value

long

Gets the value as an long.

Int64Value

long long

Gets the value as an long long.

integerValue

NSInteger

Gets the value as an NSInteger.

boolValue

BOOL

Gets the value as a Bool.

Property

type

Description

stringValue

String?

Gets the value as an optional string.

floatValue

Float

Gets the value as a Float.

doubleValue

Double

Gets the value as a Double.

intValue

Int

Gets the value as an int.

longValue

Long

Gets the value as an long.

booleanValue

Boolean

Gets the value as a Bool.

Property

type

Description

getStringValue

String

Gets the value as an optional string.

getFloatValue

float

Gets the value as a Float.

getDoubleValue

double

Gets the value as a Double.

getIntValue

int

Gets the value as an Int.

getLongValue

long

Gets the value as an Long.

getBooleanValue

Boolean

Gets the value as a Boolean.

Property

type

Description

StringValue

string

Gets the value as an optional string.

FloatValue

float

Gets the value as a float.

DoubleValue

double

Gets the value as a double.

LongValue

long

Gets the value as an long.

IntValue

int

Gets the value as an int.

BoolValue

bool

Gets the value as a bool.

Property

type

Description

StringValue

String

Gets the value as an optional string.

FloatValue

float

Gets the value as a float.

DoubleValue

double

Gets the value as a double.

Int16Value

Int16

Gets the value as an Int16

Int32Value

Int32

Gets the value as an Int32

Int64Value

Int64

Gets the value as an Int64

BoolValue

bool

Gets the value as a bool.

Property

type

Description

StringValue

FString

Gets the value as an string.

FloatValue

float

Gets the value as a float.

LongValue

int64

Gets the value as an long.

IntValue

int32

Gets the value as an int.

BoolValue

bool

Gets the value as a bool.

Source

EDTDRemoteConfigSource

Gets source of the value.

Property

type

Description

GetStringValue

String

Gets the value as an string.

GetFloatValue

float

Gets the value as a float.

GetIntValue

int

Gets the value as an int.

GetBoolValue

bool

Gets the value as a bool.

GetSource

GDDTDRemoteConfigSource.Source

Gets source of the value.

DTDRemoteConfigListener

It implements methods that report the status of A/B tests.

Method

Description

onReceived(result: DTDRemoteConfigReceiveResult)

It is triggered every time the SDK loads an A/B test configuration. If the remoteConfigWaiting has a default value (null), onReceived does not get called

onPrepareToChange()

It notifies the developer about coming changes in the A/B test configuration.

onChanged(result: DTDRemoteConfigChangeResult,

error: Error?)

It notifies the developer that the configuration has changed. Or about the reason why the configuration could not change.

Method

Description

-(void)onReceivedResult:

(enum DTDRemoteConfigReceiveResult)result

It is triggered every time the SDK loads an A/B test configuration. If the remoteConfigWaiting has a default value (null), onReceived does not get called

-(void)onPrepareToChange

It notifies the developer about coming changes in the A/B test configuration.

- (void)onChangedResult:

(enum DTDRemoteConfigChangeResult)result

error:(NSError *)error

It notifies the developer that the configuration has changed. Or about the reason why the configuration could not change.

Method

Description

onReceived(result: DTDRemoteConfigReceiveResult)

It is triggered every time the SDK loads an A/B test configuration. If the remoteConfigWaiting has a default value (null), onReceived does not get called

onPrepareToChange()

It notifies the developer about coming changes in the A/B test configuration.

onChanged(result: DTDRemoteConfigChangeResult, ex: Exception?)

It notifies the developer that the configuration has changed. Or about the reason why the configuration could not change.

Method

Description

onReceived(DTDRemoteConfigReceiveResult result)

It is triggered every time the SDK loads an A/B test configuration. If the remoteConfigWaiting has a default value (null), onReceived does not get called

onPrepareToChange()

It notifies the developer about coming changes in the A/B test configuration.

onChanged( DTDRemoteConfigChangeResult result, Exception ex)

It notifies the developer that the configuration has changed. Or about the reason why the configuration could not change.

IDTDRemoteConfigListener

Method

Description

void OnReceived(DTDRemoteConfigReceiveResult result);

It is triggered every time the SDK loads an A/B test configuration. If the remoteConfigWaiting has a default value (null), OnReceived does not get called

void OnPrepareToChange();

It notifies the developer about coming changes in the A/B test configuration.

void OnChanged(DTDRemoteConfigChangeResult result, string exceptionText = null);

It notifies the developer that the configuration has changed. Or about the reason why the configuration could not change.

IDTDRemoteConfigListener

Method

Description

OnReceived(DTDRemoteConfigReceiveResult result)

It is triggered every time the SDK loads an A/B test configuration. If the remoteConfigWaiting has a default value (null), OnReceived does not get called

OnPrepareToChange()

It notifies the developer about coming changes in the A/B test configuration.

OnChanged(DTDRemoteConfigChangeResult result, string error)

It notifies the developer that the configuration has changed. Or about the reason why the configuration could not change.

FDTDRemoteConfigReceiveResultDelegate

It is triggered every time the SDK loads an A/B test configuration. If the remoteConfigWaiting has a default value (null), OnReceived does not get called

DECLARE_DELEGATE_OneParam(FDTDRemoteConfigReceiveResultDelegate, EDTDRemoteConfigReceiveResult);

FDTDRemoteConfigPrepareToChangeDelegate

It notifies the developer about coming changes in the A/B test configuration.

DECLARE_DELEGATE(FDTDRemoteConfigPrepareToChangeDelegate);

FDTDRemoteConfigChangeResultDelegate

It notifies the developer that the configuration has changed. Or about the reason why the configuration could not change.

DECLARE_DELEGATE_TwoParams(FDTDRemoteConfigChangeResultDelegate, EDTDRemoteConfigChangeResult, const FString&);

Method

Description

onRemoteConfigReceive(result: GDDTDRemoteConfigReceiveResult.ReceiveResult):

It is triggered every time the SDK loads an A/B test configuration. If the remoteConfigWaiting has a default value (null), onReceived does not get called

onRemoteConfigPrepareToChange()

It notifies the developer about coming changes in the A/B test configuration.

onRemoteConfigChange(result: GDDTDRemoteConfigChangeResult.ChangeResult, error: String)

It notifies the developer that the configuration has changed. Or about the reason why the configuration could not change.

DTDRemoteConfigReceiveResult

It is triggered every time the SDK loads the configuration of A/B tests.

type

Description

DTDRemoteConfigReceiveResult.Success

It is triggered when the configuration of the A/B test is received.

DTDRemoteConfigReceiveResult.Failure

It is triggered if the SDK did not manage to get the A/B test configurations for the time period set in remoteConfigWaiting.

DTDRemoteConfigReceiveResult.Empty

It is triggered when the configuration of the A/B test is received, but the list of experiments is empty.

DTDRemoteConfigChangeResult

Notifies whether the configuration of the A/B test has been changed.

type

Description

DTDRemoteConfigReceiveResult.Success

Configuration is changed.

DTDRemoteConfigReceiveResult.Failure

Configuration change attempt failed.

Data options returned by the configChanged method signature

DTDRemoteConfigChangeResult

Exception message

Description

DTDRemoteConfigChangeResult.Success

null

When receiving an offer from the backend.

DTDRemoteConfigChangeResult.Success

null

When launching the SDK with a previously started test.

DTDRemoteConfigChangeResult.Success

null

When replacing the user with another user who previously started the test.

DTDRemoteConfigChangeResult.Failure

[A/B-Test Module] The Server refused to conduct the test.

If the server refused to provide a test available for participation.

DTDRemoteConfigChangeResult.Failure

[A/B-Test Module] Offer from devtodev not received within the allotted N seconds.

The backend offer is returned after a deadline e.g. due to a bad internet connection.

DTDRemoteConfigChangeResult.Failure

[A/B-Test Module] Offer from devtodev not received within the allotted N seconds.

The SDK was unable to receive an offer from the backend within N seconds e.g, duea bad internet connection or network problems.

DTDRemoteConfigChangeResult.Failure

[A/B-Test Module] In the process of receiving an offer from the server, the user was changed. Offer has been canceled.

When replacing the user with another user at the time of receiving an offer.

DTDRemoteConfigChangeResult.Failure

[A/B-Test Module] Offer refused, because application went into the background.

If a suitable test is found but the user made the app go into the background before the offer was received.

A/B testing examples

Example №1

Hypothesis

Our analytics data show that most of the people make a purchase during their first session. However, only 70% of users open our in-app store during the first session. We hypothesize that if we add a purchase screen to the tutorial then 100% of users will face it and the number of purchases during the first session will increase.

Test criteria

The criteria for test inclusion is starting the tutorial. The DTDAnalytics.tutorial(step: Int) event with step = -1 is the trigger.

Groups

Control group: a 10 step tutorial, no purchase screens

Group А: an 11 step tutorial. At step number 5, we will offer a special offer.

Implementation

// Timer constants
struct Constants {
    static let waitGroupConst = 10.0
}

// Value keys
enum ValueKey: String {
  case showStore
}

class AppConfig {
    static func loadDefaults() {
        let appDefaults: [String: Any] = [
            ValueKey.showStore.rawValue: "false"
        ]
        // Set default values
        DTDRemoteConfig.defaults = appDefaults
    }
    
    static func bool(forKey key: ValueKey) -> Bool {
        return DTDRemoteConfig.config[key.rawValue].boolValue
    }
}

class AppLogic {
    var timer: Timer
    // Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
    func startTutorial() {
        // Send a trigger event that indicates tutorial start
        DTDAnalytics.tutorial(step: -1)
    }
    
    func nextTutotrialStep(_ currentStep: Int) {
        DTDAnalytics.tutorial(step: currentStep)
        if AppConfig.bool(forKey: .showStore) && currentStep == 5 {
            // Offer purchasing of a special offer
        }
    }
}

class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication,
        willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Set the maximum time of waiting for an A/B test group
        DTDRemoteConfig.groupDefinitionWaiting = Constants.waitGroupConst
        // Set default values
        AppConfig.loadDefaults()
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.initializeWithAbTest(applicationKey: "appKey",
                                          configuration: config,
                                          abConfigListener: self)
    }
}

extension AppLogic: DTDRemoteConfigListener {
    // Process the result of waiting for A/B test configuration
    func onReceived(result: DTDRemoteConfigReceiveResult) {
        // It is not used in current example
    }

    // Prepare the app UI for changing the remote configuration
    func onPrepareToChange() {
        // Use the main app thread because you are getting ready for working with the interface
        DispatchQueue.main.async { [weak self] in
            // Display the download progress indicator
            self?.showActivityIndicator()
            // Add a timer that will forcibly remove the download progress indicator
            self?.timer = Timer.scheduledTimer(withTimeInterval: Constants.waitGroupConst, repeats: false) { [weak self] _ in
                self?.hideActivityIndicator()
            }
        }
    }
    
    // Apply the values of the assigned group
    func onChanged(result: DTDRemoteConfigChangeResult, error: Error?) {
        defer {
            // Hide the download progress indicator
            DispatchQueue.main.async { [weak self] in
                self?.timer.invalidate();
                self?.hideActivityIndicator()
            }
        }

        switch result {
        case .success:
            // Apply new values
            DTDRemoteConfig.applyConfig()

        case .failure:
            // Error processing
            if let error = error {
                print(error.localizedDescription)
            }

        @unknown default:
            break
        }
    }
}

// Constants .h + .m
@interface Constants : NSObject
// Timer constants
extern double const waitGroupConst;
// Value keys
extern NSString * const showStore;
@end

@implementation Constants
double const waitGroupConst = 10.0;
NSString * const showStore = @"showStore";
@end

// AppConfig .h + .m
@interface AppConfig: NSObject
+(void) loadDefaults;
+(BOOL) getBoolForKey:(NSString *) key;
@end

@implementation AppConfig
+(void)loadDefaults {
    NSDictionary *appDefaults = @{
        showStore: @NO
    };

    // Set default values
    DTDRemoteConfig.defaults = appDefaults;
}

+(BOOL) getBoolForKey:(NSString *) key {
    return DTDRemoteConfig.config[key].boolValue;
}
@end

// AppLogic .h + .m
@interface AppLogic : UIViewController <DTDRemoteConfigListener>
@property (nonatomic, strong) NSTimer *timer;
@end

@implementation AppLogic

- (void)viewDidLoad {
    [super viewDidLoad];
    [self startTutorial];
}

// Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
- (void) startTutorial {
    // Send a trigger event that indicates tutorial start
    [DTDAnalytics tutorialStep: -1];
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
        [self nextTutotrialStep:5];
    });
}

- (void) nextTutotrialStep:(NSInteger) currentStep {
    [DTDAnalytics tutorialStep: currentStep];
    if ([AppConfig getBoolForKey:showStore] && currentStep == 5) {
        // Offer purchasing of a special offer
    }
}

// Process the result of waiting for A/B test configuration
- (void)onReceivedResult:(enum DTDRemoteConfigReceiveResult)result {
    // It is not used in current example
}

// Prepare the app UI for changing the remote configuration
- (void)onPrepareToChange {
    // Use the main app thread because you are getting ready for working with the interface
    __weak AppLogic *weakSelf = self;
    dispatch_async(dispatch_get_main_queue(), ^{
        // Display the progress indicator
        [weakSelf showActivityIndicator];
        // Add a timer that will forcibly remove the progress indicator
        self.timer = [NSTimer scheduledTimerWithTimeInterval:waitGroupConst repeats:false block:^(NSTimer *timer){
            [weakSelf hideActivityIndicator];
        }];
    });
}

// Apply the values of the assigned group
- (void)onChangedResult:(enum DTDRemoteConfigChangeResult)result error:(NSError *)error {
    switch (result) {
        case DTDRemoteConfigChangeResultSuccess:
            // Apply new values
            [DTDRemoteConfig applyConfig];
            break;

        case DTDRemoteConfigChangeResultFailure:
            // Error processing
            if (error) {
                NSLog(@"DTDRemoteConfigError: %@", error.localizedDescription);
            }

        default:
            break;
    }

    // Hide the progress indicator
    __weak AppLogic *weakSelf = self;
    dispatch_async(dispatch_get_main_queue(), ^{
        [self.timer invalidate];
        [weakSelf hideActivityIndicator];
    });
}

- (void)showActivityIndicator {
    // Display the progress indicator
}

- (void)hideActivityIndicator {
    // Hide the progress indicator
}
@end

// AppDelegate .h + .m
@interface AppDelegate ()
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    AppLogic *appLogicController = [[UIStoryboard storyboardWithName:@"Main" bundle:nil] instantiateViewControllerWithIdentifier:@"AppLogic"];
    UINavigationController *navController = [[UINavigationController alloc]initWithRootViewController:appLogicController];
    self.window.rootViewController = navController;
    [self.window makeKeyAndVisible];

    // Group timeout, optional
    DTDRemoteConfig.groupDefinitionWaiting = waitGroupConst;
    // Implementation defaults params
    [AppConfig loadDefaults];
    [DTDAnalytics applicationKey:appKey abConfigListener:appLogicController];

    return YES;
}
@end

class Constants {
    // Timer constants
    companion object {
        const val waitGroupConst = 10.0
        const val waitGroupConstInMilliseconds = 10000L
    }
}

// Value keys
enum class ValueKey(val value: String) {
    ShowStore("showStore")
}

class AppConfig {
    companion object {
        fun loadDefaults() {
            val appDefaults = mapOf<String, Any>(ValueKey.ShowStore.value to "false")
            DTDRemoteConfig.defaults = appDefaults
        }

        fun bool(key: ValueKey): Boolean {
            return DTDRemoteConfig.config[key.value].booleanValue
        }
    }
}

class AppLogic {
    // Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
    fun startTutorial() {
        // Send a trigger event that indicates tutorial start
        DTDAnalytics.tutorial(step = -1)
    }

    fun nextTutorialStep(currentStep: Int) {
        DTDAnalytics.tutorial(step = currentStep)
        if (AppConfig.bool(ValueKey.ShowStore) && currentStep == 5) {
            // Offer purchasing of a special offer
        }
    }
}

class MainActivity : AppCompatActivity(), DTDRemoteConfigListener {
    //activityIndicator control timer
    var timer: TimerTask? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState, persistentState)
        setContentView(R.layout.activity_main)

        // Set the maximum time of waiting for an A/B test group
        DTDRemoteConfig.groupDefinitionWaiting = Constants.waitGroupConst
        // Set default values
        AppConfig.loadDefaults()
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.initializeWithAbTest(
            appKey = "appKey",
            context = this,
            abConfigListener = this
        )
    }

    // Process the result of waiting for A/B test configuration
    override fun onReceived(result: DTDRemoteConfigReceiveResult) {
        // It is not used in current example
    }

    // Prepare the app UI for changing the remote configuration
    override fun onPrepareToChange() {
        // Use the main app thread because you are getting ready for working with the interface
        runOnUiThread {
            // Display the download progress indicator
            this.showActivityIndicator()
        }
        // Add a timer that will forcibly remove the download progress indicator
        timer = Timer("ActivityIndicator").schedule(Constants.waitGroupConstInMilliseconds) {
            runOnUiThread {
                this.hideActivityIndicator()
            }
        }
    }

    override fun onChanged(result: DTDRemoteConfigChangeResult, ex: Exception?) {
        when (result) {
            DTDRemoteConfigChangeResult.Success -> {
                // Apply new values
                DTDRemoteConfig.applyConfig()
            }
            DTDRemoteConfigChangeResult.Failure -> {
                // Error processing
                ex?.let { Log.e("TAG", ex.toString()) }
            }
        }

        this.timer?.cancel()
        this.timer = null
        
        runOnUiThread {
            this.hideActivityIndicator()
        }

class Constants {
    // Timer constants
    final static double waitGroupConst = 10.0;
    final static long waitGroupConstInMilliseconds = 10000L;
}

enum ValueKey {
    ShowStore("showStore");

    private final String stringValue;

    ValueKey(String toString) {
        stringValue = toString;
    }

    @Override
    public String toString() {
        return stringValue;
    }
}

class AppConfig {
    static void loadDefaults() {
        HashMap<String, Object> map = new HashMap<>();
        map.put(ValueKey.ShowStore.toString(), "false");
        DTDRemoteConfig.INSTANCE.setDefaults(map);
    }

    static Boolean bool(ValueKey key) {
        return DTDRemoteConfig.INSTANCE.getConfig().get(key.toString()).getBooleanValue();
    }
}

class AppLogic {
    // Tutorial open event (e.g. by clicking the 'start tutorial' button)
    void startTutorial() {
        // Send a trigger event that indicates tutorial start
        DTDAnalytics.INSTANCE.tutorial( -1);
    }

    void nextTutorialStep(int currentStep) {
        DTDAnalytics.INSTANCE.tutorial(currentStep);
        if (AppConfig.bool(ValueKey.ShowStore) && currentStep == 5) {
            // Offer purchasing of a special offer
        }
    }
}

class MainActivity extends AppCompatActivity implements DTDRemoteConfigListener {
    //activityIndicator control timer
    Timer timer = null;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Set the maximum time of waiting for an A/B test group
        DTDRemoteConfig.INSTANCE.setGroupDefinitionWaiting(Constants.waitGroupConst);
        // Set default values
        AppConfig.loadDefaults();
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.INSTANCE.initializeWithAbTest("appKey", this, this);
    }

    // Process the result of waiting for A/B test configuration
    @Override
    public void onReceived(@NonNull DTDRemoteConfigReceiveResult result) {
        // It is not used in current example
    }

    // Prepare the app UI for changing the remote configuration
    @Override
    public void onPrepareToChange() {
        // Use the main app thread because you are getting ready for working with the interface
        runOnUiThread(() -> {
            // Display the download progress indicator
            showActivityIndicator();
        });

        timer = new Timer().schedule(new TimerTask() {
            @Override
            public void run() {
                runOnUiThread(() -> hideActivityIndicator());
            }
        }, Constants.waitGroupConstInMilliseconds);
    }

    @Override
    public void onChanged(@NonNull DTDRemoteConfigChangeResult result, @Nullable Exception ex) {
        if (result == DTDRemoteConfigChangeResult.Success) {
            // Apply new values
            DTDRemoteConfig.INSTANCE.applyConfig();
        }

        if (result == DTDRemoteConfigChangeResult.Failure) {
            // Apply new values
            DTDRemoteConfig.INSTANCE.applyConfig();
        }

        if (timer != null) {
            timer.cancel();
            timer = null;
        }

        runOnUiThread(() -> hideActivityIndicator());
    }
}

// Timer constants
public static class Constants
{
    public const float WAIT_GROUP_TIME = 10.0f;
}

// Value keys
public enum ValueKey
{
    showStore
}

public class AppConfig
{
    public void LoadDefaults()
    {
        var appDefaults = new Dictionary<string, object>
        {
            {ValueKey.showStore.ToString(), false}
        };
        DTDRemoteConfig.Defaults = appDefaults;
    }

    public bool GetBool(ValueKey key) => DTDRemoteConfig.Config[key.ToString()].BoolValue();
}

public class AppLogic : MonoBehaviour
{
    private readonly AppConfig _appConfig = new AppConfig();
    private const string APP_KEY = "appKey";
    private SimpleUI _simpleUI;
    private void Start()
    {
        DontDestroyOnLoad(this);
        _simpleUI = FindObjectOfType<SimpleUI>();
        if (_simpleUI == null) throw new NullReferenceException("UIManager not found.");
        // Set the maximum time of waiting for an A/B test group
        DTDRemoteConfig.GroupDefinitionWaiting = Constants.WAIT_GROUP_TIME;
        // Set default values
        _appConfig.LoadDefaults();
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.InitializeWithAbTests(
            appKey: APP_KEY,
            configListener: this);
    }

    // Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
    // Send a trigger event that indicates tutorial start
    public void StartTutorial() => DTDAnalytics.Tutorial(-1);

    public void NextTutorialStep(int step)
    {
        DTDAnalytics.Tutorial(step);
        if (_appConfig.GetBool(ValueKey.showStore) && step == 5)
        {
            // Offer purchasing of a special offer
            Store.Instance.ShowSpecialOffer();
        }
    }

    // Process the result of waiting for A/B test configuration
    public void OnReceived(DTDRemoteConfigReceiveResult result)
    {
        // It is not used in current example
    }

    // Prepare the app UI for changing the remote configuration
    public void OnPrepareToChange()
    {
        // Display the download progress indicator
        _simpleUI.ShowLoadingIndicator(Constants.WAIT_GROUP_TIME);
    }
    
    // Apply the values of the assigned group
    public void OnChanged(DTDRemoteConfigChangeResult result, string exceptionText = null)
    {
        // Hide the download progress indicator
        _simpleUI.HideLoadingIndicator();
        switch (result)
        {
            case DTDRemoteConfigChangeResult.Failure:
                // Error processing
                Debug.LogError(exceptionText);
                break;
            case DTDRemoteConfigChangeResult.Success:
                // Apply new values
                DTDRemoteConfig.ApplyConfig();
                break;
        }
    }
}

// Timer constants
static class Constants
{
    public const float WaitGroupConst = 10.0f;
}

// Value keys
static class ValueKeys
{
    public const string ShowStore = "showStore";
}

static class AppConfg
{
    public static void LoadDafaults()
    {
        DTDRemoteConfig.Defaults = new Dictionary<string, object>
        {
          [ValueKeys.ShowStore] = false
        };
    }
    
    public static bool GetBoolValue(string key)
    {
        return DTDRemoteConfig.Config[key].BoolValue;
    }
}

class Application : IDTDRemoteConfigListener
{
    public void Run()
    {
       // Set the maximum time of waiting for an A/B test group
        DTDRemoteConfig.GroupDefinitionWaiting = Constants.WaitGroupConst;
        // Set default values
        AppConfg.LoadDafaults();
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.InitializeWithAbTest("appKey", this);
        // Your code to show UI
    }

    // Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
    public void StartTutorial()
    {
        // Send a trigger event that indicates tutorial start
        DTDAnalytics.Tutorial(-1);
    }
    
    public void NextTutotrialStep(int step)
    {
        DTDAnalytics.Tutorial(step);
        if (AppConfg.GetBoolValue(ValueKeys.ShowStore) && step == 5)
        {
            // Offer purchasing of a special offer (method do a job in UI thread)
            UI.ShowSpecialOffer();
        }
    }
    
    // Apply the values of the assigned group
    public void OnChanged(DTDRemoteConfigChangeResult result, string error)
    {
        Debug.WriteLine($"[App-ABTests] OnChanged({result}, {error})");
        switch (result)
        {
            case DTDRemoteConfigChangeResult.Failure:
                // Error processing
                break;
            case DTDRemoteConfigChangeResult.Success:
                // Apply new values
                DTDRemoteConfig.ApplyConfig();
                break;
            default:
                break;
        }
        
        // Hide the download progress indicator(method do a job in UI thread)
        UI.HideLoadingIndicator();
    }

    // Prepare the app UI for changing the remote configuration
    public void OnPrepareToChange()
    {
        Debug.WriteLine($"[App-ABTests] OnPrepareToChange()");
        // Display the download progress indicator (method do a job in UI thread)
        UI.ShowLoadingIndicator();
        // Add a timer that will forcibly remove the download progress indicator
        TimerUtil.CallWithDelay(Constants.WaitGroupConst, () =>
        {
            // Hide the download progress indicator(method do a job in UI thread)
            UI.HideLoadingIndicator();
        });
    }

    // Process the result of waiting for A/B test configuration
    public void OnReceived(DTDRemoteConfigReceiveResult result)
    {
        // It is not used in current example
        Debug.WriteLine($"[App-ABTests] OnReceived({result})");
    }
}

// Timer constant
float WAIT_GROUP_TIME = 15.0f;

void SomeLogicClass::Start() {
    // Set the maximum time of waiting for an A/B test group
    UDTDRemoteConfigBPLibrary::SetGroupDefinitionWaiting(WAIT_GROUP_TIME);

    // Set default values
    FDTDRemoteConfigDefaults Defaults;
    Defaults.BoolDefaults.Add("showStore", false);
    UDTDRemoteConfigBPLibrary::SetDefaults(Defaults);

    const auto onConfigReceive = new FDTDRemoteConfigReceiveResultDelegate();
    onConfigReceive->BindUObject(this, &SomeLogicClass::OnConfigReceive);

    const auto onPrepareToChange = new FDTDRemoteConfigPrepareToChangeDelegate();
    onPrepareToChange->BindUObject(this, &SomeLogicClass::OnPrepareToChange);

    const auto onConfigChange = new FDTDRemoteConfigChangeResultDelegate();
    onConfigChange->BindUObject(this, &SomeLogicClass::OnConfigChange);

    // Initialize the SDK for working with A/B testing
    UDTDAnalyticsBPLibrary::InitializeWithAbTest("AppKey", *onConfigChange, *onPrepareToChange, *onConfigReceive);
}

// Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
void SomeLogicClass::StartTutorial() {
    // Send a trigger event that indicates tutorial start
    UDTDAnalyticsBPLibrary::Tutorial(-1);
}

void SomeLogicClass::NextTutorialStep(int32 step)
{
    UDTDAnalyticsBPLibrary::Tutorial(step);
    bool isNeedShowStore = UDTDRemoteConfigBPLibrary::GetRemoteConfigValue("showStore").BoolValue;
    if (isNeedShowStore && step == 5)
    {
        // Offer purchasing of a special offer
        SomeStoreUI::ShowSpecialOffer();
    }
}

// Process the result of waiting for A/B test configuration
void SomeLogicClass::OnConfigReceive(EDTDRemoteConfigReceiveResult result) {
    // It is not used in current example
}

// Prepare the app UI for changing the remote configuration
void SomeLogicClass::OnPrepareToChange() {
    // Display the download progress indicator
    SomeUI::ShowLoadingIndicator(WAIT_GROUP_TIME);
}

// Apply the values of the assigned group
void SomeLogicClass::OnConfigChange(EDTDRemoteConfigChangeResult result, const FString& error) {
    // Hide the download progress indicator
    SomeUI::HideLoadingIndicator();
    switch (result)
    {
    case EDTDRemoteConfigChangeResult::Success:
    	// Apply new values
	UDTDRemoteConfigBPLibrary::ApplyConfig();
	break;
	
    case EDTDRemoteConfigChangeResult::Failure:
	// Error processing
	UE_LOG(LogTemp, Warning, TEXT("DTDRemoteConfigError: %s"), *error);
	break;

    default:
	break;
    }
}

# Control timer
var timer = Timer.new()
# Timer constant
var waitGroupConst = 10.0
var showStore = "showStore"

func loadDefaults():
	var appDefaults = GDDTDRemoteConfigDefaults.new()
	# Value key
	appDefaults.AddBoolValue(showStore, false)
	DTDRemoteConfig.SetDefaults(appDefaults)
	
func getBool(key: String) -> bool: 
	return DTDRemoteConfig.GetRemoteConfigValue(key).GetBoolValue()

# Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
func startTutorial():
    # Send a trigger event that indicates tutorial start
	DTDAnalytics.Tutorial(-1)

func nextTutorialStep(currentStep: int):
	DTDAnalytics.Tutorial(currentStep)
	if (getBool(showStore) && currentStep == 5):
		#Offer purchasing of a special offer
		pass
	
func _ready():
    # Set the maximum time of waiting for an A/B test group
	DTDRemoteConfig.SetGroupDefinitionWaiting(waitGroupConst)
	# Set default values
	loadDefaults()
	#Initialize the SDK for working with A/B testing
	DTDAnalytics.InitializeWithAbTest("appKey",
	onRemoteConfigChange,
	onRemoteConfigPrepareToChange,
	onRemoteConfigReceive)
	DTDAnalytics.SetLogLevel(GDDTDLogLevel.Debug)
	
func onRemoteConfigChange(result: GDDTDRemoteConfigChangeResult.ChangeResult, error: String):
	match result:
		GDDTDRemoteConfigChangeResult.Success:
			# Apply new values
			DTDRemoteConfig.ApplyConfig()
		GDDTDRemoteConfigChangeResult.Failure:
			# Error processing
			print(error)
			
	timer.stop()
	hideActivityIndicator()
	
# Prepare the app UI for changing the remote configuration
func onRemoteConfigPrepareToChange():
    # Display the download progress indicator
	showActivityIndicator()
	# Add a timer that will forcibly remove the download progress indicator
	timer.connect("timeout", hideActivityIndicator)
	timer.one_shot = true
	timer.wait_time = waitGroupConstInMilliseconds
	add_child(timer)
	timer.start()

# Process the result of waiting for A/B test configuration
func onRemoteConfigReceive(result: GDDTDRemoteConfigReceiveResult.ReceiveResult):
	#It is not used in current example
	pass

Example №2

Hypothesis

Our analytics data show that N users installed the app more than half a year ago but still did not make a purchase. We hypothesize that if we offer a huge discount then we can get additional income.

Test criteria

The criteria for test inclusion is the app install date and the “payer” status.

Groups

Control group: current version with usual prices

Group А: it has a discount badge on the main page. After clicking on the badge, a purchase window pops up

Implementation

 // Timer constants
struct Constants {
    static let waitConfigConst = 10.0
    static let waitGroupConst = 15.0
}

// Value keys
enum ValueKey: String {
  case maximumDiscount
}

class AppConfig {
    static func loadDefaults() {
        let appDefaults: [String: Any] = [
            ValueKey.maximumDiscount.rawValue: "false"
        ]
        // Set default values
        DTDRemoteConfig.defaults = appDefaults
    }
    
    static func bool(forKey key: ValueKey) -> Bool {
        return DTDRemoteConfig.config[key.rawValue].boolValue
    }
}

class AppLogic {
    override func viewDidLoad() {
        super.viewDidLoad()
        // Display the launch screen
        showLaunchScreen()
    }
    
    // Launching the main logic of the application
    func startAppForReal() {
        // Update app UI
        updateAppUI()
        // Hide launch screen
        hideLaunchScreen()
    }
    
    func updateAppUI() {
        if bool(forKey: .maximumDiscount) {
            // Display a discount badge clicking on which invokes a purchase window popup
        }
    }
}

class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication,
        willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Set the maximum time of waiting for the A/B test configuration
        DTDRemoteConfig.remoteConfigWaiting = Constants.waitConfigConst
        // Set the maximum time of waiting for an A/B test group
        DTDRemoteConfig.groupDefinitionWaiting = Constants.waitGroupConst
        // Set default values
        AppConfig.loadDefaults()
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.initializeWithAbTest(applicationKey: "appKey",
                                          configuration: config,
                                          abConfigListener: self)
    }
}

extension AppLogic: DTDRemoteConfigListener {
    // Process the result of waiting for A/B test configuration
    func onReceived(result: DTDRemoteConfigReceiveResult) {
        // If the attempt fails, launch the main logic of the application
        if result == .failure {
            DispatchQueue.main.async { [weak self] in
                self?.startAppForReal()
            }
        }
    }

    // Prepare the app UI for changing the remote configuration
    func onPrepareToChange() {
        // It is not used in current example
    }
    
    // Apply the values of the assigned group
    func onChanged(result: DTDRemoteConfigChangeResult, error: Error?) {
        defer {
            // Launch the main logic of the application
            DispatchQueue.main.async { [weak self] in
              self?.startAppForReal()
            }
        }

        switch result {
        case .success:
            // Apply new values
            DTDRemoteConfig.applyConfig()

        case .failure:
            // Error processing
            if let error = error {
                print(error.localizedDescription)
            }

        @unknown default:
            break
        }
    }
}

Note

When receiving the configuration, the SDK always calls the onReceived(result: DTDRemoteConfigReceiveResult) method, and when enrolling in a test - the onPrepareToChange() and onChanged(result: DTDRemoteConfigChangeResult, error: Error?) method. However, you can take some additional precocious measures. You can add a timer as in the following example:

func showLaunchScreen() {
    // Add a timer that will forcibly launch the main logic of the application
    timer = Timer.scheduledTimer(withTimeInterval: waitConfigConst + waitGroupConst, 
                                          repeats: false) { [weak self] _ in
        self?.startAppForReal()
    }
    showActivityIndicator()
}

// Constants .h + .m
@interface Constants : NSObject
// Timer constants
extern double const waitConfigConst;
extern double const waitGroupConst;
// Value keys
extern NSString * const maximumDiscount;
@end

@implementation Constants
double const waitConfigConst = 10.0;
double const waitGroupConst = 15.0;
NSString * const maximumDiscount = @"maximumDiscount";
@end

// AppConfig .h + .m
@interface AppConfig: NSObject
+(void) loadDefaults;
+(BOOL) getBoolForKey:(NSString *) key;
@end

@implementation AppConfig
+(void)loadDefaults {
    NSDictionary *appDefaults = @{
        maximumDiscount: @NO
    };

    // Set default values
    DTDRemoteConfig.defaults = appDefaults;
}

+(BOOL) getBoolForKey:(NSString *) key {
    return DTDRemoteConfig.config[key].boolValue;
}
@end

// AppLogic .h + .m
@interface AppLogic : UIViewController <DTDRemoteConfigListener>
@end

@implementation AppLogic
- (void)viewDidLoad {
    [super viewDidLoad];
    // Display the launch screen
    [self showLaunchScreen];
}

// Launching the main logic of the application
- (void) startAppForReal {
    // Update app UI
    [self updateAppUI];
    // Hide launch screen
    [self hideLaunchScreen];
}

- (void) updateAppUI {
    if ([AppConfig getBoolForKey:maximumDiscount]) {
        // Display a discount badge clicking on which invokes a purchase window popup
    }
}

// Process the result of waiting for A/B test configuration
- (void)onReceivedResult:(enum DTDRemoteConfigReceiveResult)result {
    // If the attempt fails, launch the main logic of the application
    if (result == DTDRemoteConfigReceiveResultFailure) {
        __weak AppLogic *weakSelf = self;
        dispatch_async(dispatch_get_main_queue(), ^{
            [weakSelf startAppForReal];
        });
    }
}

// Prepare the app UI for changing the remote configuration
- (void)onPrepareToChange {
    // It is not used in current example
}

// Apply the values of the assigned group
- (void)onChangedResult:(enum DTDRemoteConfigChangeResult)result error:(NSError *)error {
    switch (result) {
        case DTDRemoteConfigChangeResultSuccess:
            // Apply new values
            [DTDRemoteConfig applyConfig];
            break;

        case DTDRemoteConfigChangeResultFailure:
            // Error processing
            if (error) {
                NSLog(@"DTDRemoteConfigError: %@", error.localizedDescription);
            }

        default:
            break;
    }

    // Launch the main logic of the application
    __weak AppLogic *weakSelf = self;
    dispatch_async(dispatch_get_main_queue(), ^{
        [weakSelf startAppForReal];
    });
}

- (void)showLaunchScreen {
    // Display the launch screen
}

- (void)hideLaunchScreen {
    // Hide launch screen
}
@end

// AppDelegate .h + .m
@interface AppDelegate ()
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    AppLogic *appLogicController = [[UIStoryboard storyboardWithName:@"Main" bundle:nil] instantiateViewControllerWithIdentifier:@"AppLogic"];
    UINavigationController *navController = [[UINavigationController alloc]initWithRootViewController:appLogicController];
    self.window.rootViewController = navController;
    [self.window makeKeyAndVisible];

    // Config timeout, optional
    DTDRemoteConfig.remoteConfigWaiting = waitConfigConst;
    // Group timeout, optional
    DTDRemoteConfig.groupDefinitionWaiting = waitGroupConst;
    // Implementation defaults params
    [AppConfig loadDefaults];
    [DTDAnalytics applicationKey:appKey abConfigListener:appLogicController];

    return YES;
}
@end

Note

When receiving the configuration, the SDK always calls the onReceivedResult method, and when enrolling in a test - the onPrepareToChange and onChangedResult method. However, you can take some additional precocious measures. You can add a timer as in the following example:

-(void) showLaunchScreen {
    // Add a timer that will forcibly launch the main logic of the application
    self.timer = [NSTimer scheduledTimerWithTimeInterval:waitConfigConst + waitGroupConst
                                                 repeats:false 
                                                   block:^(NSTimer *timer){
        [weakSelf startAppForReal];
    }];
    showActivityIndicator()
}

class Constants {
    // Timer constants
    companion object {
        const val waitConfigConst = 10.0
        const val waitConfigConstInMilliseconds = 10000L
        const val waitGroupConst = 15.0
        const val waitGroupConstInMilliseconds = 15000L
    }
}

// Value keys
enum class ValueKey(val value: String) {
    MaximumDiscount("maximumDiscount")
}

class AppConfig {
    companion object {
        fun loadDefaults() {
            val appDefaults = mapOf<String, Any>(ValueKey.MaximumDiscount.value to "false")
            // Set default values
            DTDRemoteConfig.defaults = appDefaults
        }

        fun bool(key: ValueKey): Boolean {
            return DTDRemoteConfig.config[key.value].booleanValue
        }
    }
}

class AppLogic {
    fun viewDidLoad() {
        // Display the launch screen
        showLaunchScreen()
    }

    // Launching the main logic of the application
    fun startAppForReal() {
        // Update app UI
        updateAppUI()
        // Hide launch screen
        hideLaunchScreen()
    }

    fun updateAppUI() {
        if (AppConfig.bool(ValueKey.MaximumDiscount)) {
            // Display a discount badge clicking on which invokes a purchase window popup
        }
    }
}

class MainActivity : AppCompatActivity(), DTDRemoteConfigListener {
    //activityIndicator control timer
    var timer: Timer? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState, persistentState)
        setContentView(R.layout.activity_main)

        // Set the maximum time of waiting for the A/B test configuration
        DTDRemoteConfig.remoteConfigWaiting = Constants.waitConfigConst
        // Set the maximum time of waiting for an A/B test group
        DTDRemoteConfig.groupDefinitionWaiting = Constants.waitGroupConst
        // Set default values
        AppConfig.loadDefaults()
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.initializeWithAbTest(
            appKey = "appKey",
            context = this,
            abConfigListener = this
        )
    }

    // Process the result of waiting for A/B test configuration
    override fun onReceived(result: DTDRemoteConfigReceiveResult) {
        // If the attempt fails, launch the main logic of the application
        if (result == DTDRemoteConfigReceiveResult.Failure) {
            runOnUiThread {
                startAppForReal()
            }
        }
    }


    // Prepare the app UI for changing the remote configuration
    override fun onPrepareToChange() {
        // It is not used in current example
    }

    override fun onChanged(result: DTDRemoteConfigChangeResult, ex: Exception?) {
        when (result) {
            DTDRemoteConfigChangeResult.Success -> {
                // Apply new values
                DTDRemoteConfig.applyConfig()
            }
            DTDRemoteConfigChangeResult.Failure -> {
                // Error processing
                ex?.let { Log.e("TAG", ex.toString()) }
            }
        }

        runOnUiThread {
            startAppForReal()
        }
    }
}

Note

fun showLaunchScreen() {
    // Add a timer that will forcibly launch the main logic of the application
    tiemr = Timer("ActivityIndicator").schedule(
        Constants.waitConfigConstInMilliseconds +
                Constants.waitGroupConstInMilliseconds
    ) {
        runOnUiThread {
            startAppForReal()
        }
    }
    showActivityIndicator()
}

class Constants {
    // Timer constants
    final static double waitGroupConst = 10.0;
    final static long waitGroupConstInMilliseconds = 10000L;

    final static double waitConfigConst = 15.0;
    final static long waitConfigConstInMilliseconds = 15000L;
}

enum ValueKey {
    MaximumDiscount("maximumDiscount");

    private final String stringValue;

    ValueKey(String toString) {
        stringValue = toString;
    }

    @Override
    public String toString() {
        return stringValue;
    }
}

class AppConfig {
    static void loadDefaults() {
        HashMap<String, Object> map = new HashMap<>();
        map.put(ValueKey.MaximumDiscount.toString(), "false");
        DTDRemoteConfig.INSTANCE.setDefaults(map);
    }

    static Boolean bool(ValueKey key) {
        return DTDRemoteConfig.INSTANCE.getConfig().get(key.toString()).getBooleanValue();
    }
}

class AppLogic {
    static void viewDidLoad() {
        // Display the launch screen
        showLaunchScreen();
    }

    // Launching the main logic of the application
    static void startAppForReal() {
        // Update app UI
        updateAppUI();
        // Hide launch screen
        hideLaunchScreen();
    }

    static void updateAppUI() {
        if (AppConfig.bool(ValueKey.MaximumDiscount)) {
            // Display a discount badge clicking on which invokes a purchase window popup
        }
    }
}

class MainActivity extends AppCompatActivity implements DTDRemoteConfigListener {
    //activityIndicator control timer
    Timer timer = null;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Set the maximum time of waiting for the A/B test configuration
        DTDRemoteConfig.INSTANCE.setRemoteConfigWaiting(Constants.waitConfigConst);
        // Set the maximum time of waiting for an A/B test group
        DTDRemoteConfig.INSTANCE.setGroupDefinitionWaiting(Constants.waitGroupConst);
        // Set default values
        AppConfig.loadDefaults();
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.INSTANCE.initializeWithAbTest("appKey", this, this);
    }

    // Process the result of waiting for A/B test configuration
    @Override
    public void onReceived(@NonNull DTDRemoteConfigReceiveResult result) {
        // If the attempt fails, launch the main logic of the application
        if (result == DTDRemoteConfigReceiveResult.Failure) {
            runOnUiThread(AppLogic::startAppForReal);
        }
    }

    // Prepare the app UI for changing the remote configuration
    @Override
    public void onPrepareToChange() {
        // It is not used in current example
    }

    @Override
    public void onChanged(@NonNull DTDRemoteConfigChangeResult result, @Nullable Exception ex) {
        if (result == DTDRemoteConfigChangeResult.Success) {
            // Apply new values
            DTDRemoteConfig.INSTANCE.applyConfig();
        }

        if (result == DTDRemoteConfigChangeResult.Failure) {
            // Error processing
            if (ex != null) {
                Log.e("TAG", ex.toString());
            }
        }

        if (timer != null) {
            timer.cancel();
            timer = null;
        }

        runOnUiThread(AppLogic::startAppForReal);
    }
}

Note

    void showLaunchScreen() {
        // Add a timer that will forcibly launch the main logic of the application
        timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                runOnUiThread(AppLogic::startAppForReal);
            }
        }, Constants.waitConfigConstInMilliseconds +
                Constants.waitGroupConstInMilliseconds);

        showActivityIndicator();
    }

 // Timer constants
public static class Constants
{
    public static float WAIT_GROUP_TIME = 10.0f;
    public static float WAIT_CONFIG_TIME = 15.0f;
}

// Value keys
public enum ValueKey
{
    maximumDiscount
}

public class AppConfig
{
    public void LoadDefaults()
    {
        var appDefaults = new Dictionary<string, object>
        {
            {ValueKey.maximumDiscount.ToString(), false}
        };
        // Set default values
        DTDRemoteConfig.Defaults = appDefaults;
    }
    
    public bool GetBool(ValueKey key) => DTDRemoteConfig.Config[key.ToString()].BoolValue();
}

public class AppLogic : MonoBehaviour, IDTDRemoteConfigListener
{
    private readonly AppConfig _appConfig = new AppConfig();
    private const string APP_KEY = "appKey";
    private SimpleUI _simpleUI;

    private void Start()
    {
        DontDestroyOnLoad(this);
        _simpleUI = FindObjectOfType<SimpleUI>();
        if (_simpleUI == null) throw new NullReferenceException("UIManager not found.");
        // Set the maximum time of waiting for an A/B test group
        DTDRemoteConfig.GroupDefinitionWaiting = Constants.WAIT_GROUP_TIME;
        // Set the maximum time of waiting for the A/B test configuration
        DTDRemoteConfig.RemoteConfigWaiting = Constants.WAIT_CONFIG_TIME;
        // Set default values
        _appConfig.LoadDefaults();
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.InitializeWithAbTests(
            appKey: APP_KEY,
            configListener: this);

        // Show the loading indicator with timer.
        _simpleUI.ShowLoadingIndicator(Constants.WAIT_GROUP_TIME + Constants.WAIT_CONFIG_TIME);
    }

    public void UpdateAppUI()
    {
        if (_appConfig.GetBool(ValueKey.maximumDiscount))
        {
            // Display a discount badge clicking on which invokes a purchase window popup
        }
    }

    // Process the result of waiting for A/B test configuration.    
    public void OnReceived(DTDRemoteConfigReceiveResult result)
    {
        // If the attempt fails, hide the loading indicator and stop timer.
        if (result == DTDRemoteConfigReceiveResult.Failure)
        {
            _simpleUI.HideLoadingIndicator();
        }
    }

    // Prepare the app UI for changing the remote configuration    
    public void OnPrepareToChange()
    {
        // It is not used in current example
    }
    
    // Apply the values of the assigned group
    public void OnChanged(DTDRemoteConfigChangeResult result, string exceptionText = null)
    {
        // Hide the loading indicator and stop timer.
        _simpleUI.HideLoadingIndicator();
        switch (result)
        {
            case DTDRemoteConfigChangeResult.Failure:
                // Error processing
                if (exceptionText != null) Debug.LogError(exceptionText);
                break;
            case DTDRemoteConfigChangeResult.Success:
                // Apply new values
                DTDRemoteConfig.ApplyConfig();
                break;
        }
        
        UpdateAppUI();
    }
}

Note

When receiving the configuration, the SDK always calls the OnReceived(DTDRemoteConfigReceiveResult result) method, and when enrolling in a test - the OnPrepareToChange() and OnChanged(DTDRemoteConfigChangeResult result, string exceptionText = null) method. However, you can take some additional precocious measures. You can add a timer as in the following example:

public class SimpleUI : MonoBehaviour
{
    [SerializeField] private Canvas loadingIndicator;

    private Coroutine _timer;

    private IEnumerator HideAfterTimeout(float timeout, Canvas target)
    {
        yield return new WaitForSeconds(timeout);
        target.gameObject.SetActive(false);
    }

    public void ShowLoadingIndicator(float? timeout = null)
    {
        loadingIndicator.gameObject.SetActive(true);
        if (timeout != null)
            _timer = StartCoroutine(HideAfterTimeout(timeout.Value, loadingIndicator));
    }
    
    public void HideLoadingIndicator()
    {
        loadingIndicator.gameObject.SetActive(false);
        if (_timer != null) StopCoroutine(_timer);
    }
}

using DevToDev.Analytics;
using System.Collections.Generic;
using System.Diagnostics;

// Timer constants
static class Constants
{
    public const float WaitConfigConst = 10.0f;
    public const float WaitGroupConst = 15.0f;
}

// Value keys
static class ValueKeys
{
    public const string MaximumDiscount = "maximumDiscount";
}

static class AppConfg
{
    public static void LoadDafaults()
    {
        // Set default values
        DTDRemoteConfig.Defaults = new Dictionary<string, object>
        {
            [ValueKeys.MaximumDiscount] = false
        };
    }

    public static bool GetBoolValue(string key)
    {
        return DTDRemoteConfig.Config[key].BoolValue;
    }
}

class Application : IDTDRemoteConfigListener
{
    public void Run()
    {
        // Set the maximum time of waiting for an A/B test group
        DTDRemoteConfig.RemoteConfigWaiting = Constants.WaitConfigConst;
        // Set the maximum time of waiting for the A/B test configuration
        DTDRemoteConfig.GroupDefinitionWaiting = Constants.WaitGroupConst;
        // Set default values
        AppConfg.LoadDafaults();
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.InitializeWithAbTest("appKey", this);
        // Show launch screen (method do a job in UI thread)
        UI.ShowLaunchScreen();
    }

    public void ShowMainScene()
    {
        // Show main screen (also hide launch screen) (method do a job in UI thread)
        UI.ShowMainScreen();
        if (AppConfg.GetBoolValue(ValueKeys.MaximumDiscount))
        {
            // Display a discount badge clicking on which invokes a purchase window popup
            // (method do a job in UI thread)
            UI.ShowMaximumDiscount();
        }
    }

    // Apply the values of the assigned group
    public void OnChanged(DTDRemoteConfigChangeResult result, string error)
    {
        Debug.WriteLine($"[App-ABTests] OnChanged({result}, {error})");
        switch (result)
        {
            case DTDRemoteConfigChangeResult.Failure:
                // Error processing
                break;
            case DTDRemoteConfigChangeResult.Success:
                // Apply new values
                DTDRemoteConfig.ApplyConfig();
                break;
            default:
                break;
        }

        // Show main screen (also hide launch screen)
        ShowMainScene();
    }

    // Prepare the app UI for changing the remote configuration   
    public void OnPrepareToChange()
    {
        // It is not used in current example
        Debug.WriteLine($"[App-ABTests] OnPrepareToChange()");
    }

    // Process the result of waiting for A/B test configuration.   
    public void OnReceived(DTDRemoteConfigReceiveResult result)
    {
        Debug.WriteLine($"[App-ABTests] OnReceived({result})");
        // If the attempt fails, show main screen (also hide launch screen)
        if (result == DTDRemoteConfigReceiveResult.Failure)
        {
            ShowMainScene();
        }
    }
}

Note

When receiving the configuration, the SDK always calls the OnReceived(DTDRemoteConfigReceiveResult result) method, and when enrolling in a test - the OnPrepareToChange() and OnChanged(DTDRemoteConfigChangeResult result, string error). However, you can take some additional precocious measures. You can add a timer as in the following example:

public void showLaunchScreen() {
    // Add a timer that will forcibly launch the main logic of the application
    TimerUtil.CallWithDelay(Constants.WaitConfigConst + Constants.WaitGroupConst, () =>
    {
        UI.StartAppForReal();
    });
    UI.ShowActivityIndicator();
}

// Timer constants
static float WAIT_CONFIG_TIME = 15.0f;
static float WAIT_GROUP_TIME = 10.0f;

void SomeLogicClass::Start() {
    // Set the maximum time of waiting for an A/B test group
    UDTDRemoteConfigBPLibrary::SetRemoteConfigWaiting(WAIT_CONFIG_TIME);
    // Set the maximum time of waiting for the A/B test configuration
    DTDRemoteConfigBPLibrary::SetGroupDefinitionWaiting(WAIT_GROUP_TIME);

    // Set default values
    FDTDRemoteConfigDefaults Defaults;
    Defaults.BoolDefaults.Add("maximumDiscount", false);
    UDTDRemoteConfigBPLibrary::SetDefaults(Defaults);

    const auto onConfigReceive = new FDTDRemoteConfigReceiveResultDelegate();
    onConfigReceive->BindUObject(this, &SomeLogicClass::OnConfigReceive);

    const auto onPrepareToChange = new FDTDRemoteConfigPrepareToChangeDelegate();
    onPrepareToChange->BindUObject(this, &SomeLogicClass::OnPrepareToChange);

    const auto onConfigChange = new FDTDRemoteConfigChangeResultDelegate();
    onConfigChange->BindUObject(this, &SomeLogicClass::OnConfigChange);

    // Initialize the SDK for working with A/B testing
    UDTDAnalyticsBPLibrary::InitializeWithAbTest("AppKey", *onConfigChange, *onPrepareToChange, *onConfigReceive);

    // Show the loading indicator with timer.
    SomeUI::showLaunchScreen(WAIT_CONFIG_TIME + WAIT_GROUP_TIME);
}

void SomeLogicClass::UpdateAppUI()
{
    if (UDTDRemoteConfigBPLibrary::GetRemoteConfigValue("maximumDiscount").BoolValue)
    {
        // Display a discount badge clicking on which invokes a purchase window popup
    }
}

// Process the result of waiting for A/B test configuration
void SomeLogicClass::OnConfigReceive(EDTDRemoteConfigReceiveResult result) {
    // If the attempt fails, hide the loading indicator and stop timer.
    if (result == EDTDRemoteConfigReceiveResult::Failure)
    {
        SomeUI::HideLoadingIndicator();
    }
}

// Prepare the app UI for changing the remote configuration
void SomeLogicClass::OnPrepareToChange() {
    // It is not used in current example
}

// Apply the values of the assigned group
void SomeLogicClass::OnConfigChange(EDTDRemoteConfigChangeResult result, const FString& error) {
    // Hide the loading indicator and stop timer.
    SomeUI::HideLoadingIndicator();
    switch (result)
    {
    case EDTDRemoteConfigChangeResult::Success:
        // Apply new values
	UDTDRemoteConfigBPLibrary::ApplyConfig();
	break;
	
    case EDTDRemoteConfigChangeResult::Failure:
	// Error processing
	UE_LOG(LogTemp, Warning, TEXT("DTDRemoteConfigError: %s"), *error);
	break;

    default:
    	break;
    }

    UpdateAppUI();
}

# Control timer
var timer = Timer.new()
# Timer constants
var waitConfigConst = 10.0
var waitGroupConst = 15.0

var maximumDiscount = "maximumDiscount"

func loadDefaults():
	var appDefaults = GDDTDRemoteConfigDefaults.new()
	# Set default values
	appDefaults.AddBoolValue(maximumDiscount, false)
	DTDRemoteConfig.SetDefaults(appDefaults)
	
func getBool(key: String) -> bool: 
	return DTDRemoteConfig.GetRemoteConfigValue(key).GetBoolValue()
	
func viewDidLoad():
	#Display the launch screen
	showLaunchScreen()
	
#Launching the main logic of the application
func startAppForReal():
# Update app UI
	updateAppUI()
# Hide launch screen
	hideLaunchScreen()
	
func updateAppUI() :
	if getBool(maximumDiscount):
	# Display a discount badge clicking on which invokes a purchase window popup
		pass

func _ready():
		# Set the maximum time of waiting for the A/B test configuration
	DTDRemoteConfig.SetRemoteConfigWaiting(waitConfigConst)
		# Set the maximum time of waiting for an A/B test group
	DTDRemoteConfig.SetGroupDefinitionWaiting(waitGroupConst)
		# Set default values
	loadDefaults()
		# Initialize the SDK for working with A/B testing
	var config = GDDTDAnalyticsConfiguration.new()
	DTDAnalytics.InitializeWithConfigWithAbTest("appKey",
	config,
	onRemoteConfigChange,
	onRemoteConfigPrepareToChange,
	onRemoteConfigReceive)

func onRemoteConfigChange(result: GDDTDRemoteConfigChangeResult.ChangeResult, error: String):
	match result:
		GDDTDRemoteConfigChangeResult.Success:
			# Apply new values
			DTDRemoteConfig.ApplyConfig()
		GDDTDRemoteConfigChangeResult.Failure:
			# Error processing
			print(error)
			
	startAppForReal()

# Prepare the app UI for changing the remote configuration
func onRemoteConfigPrepareToChange():
	# It is not used in current example
	pass

# Process the result of waiting for A/B test configuration
func onRemoteConfigReceive(result: GDDTDRemoteConfigReceiveResult.ReceiveResult):
	if (result == GDDTDRemoteConfigReceiveResult.Failure):
		# If the attempt fails, launch the main logic of the application
		startAppForReal()
		
func showLaunchScreen():
	# Add a timer that will forcibly launch the main logic of the application
	timer.connect("ActivityIndicator", startAppForReal)
	timer.one_shot = true
	timer.wait_time = waitConfigConst + waitGroupConst
	add_child(timer)
	timer.start()
	showActivityIndicator()

Example №3

Hypothesis

Our analytics data show that only 60% of our users complete the tutorial. We hypothesize that if we make it easier (group A) or reduce the number of seps (group B), we will increase the percentage of tutorial completion.

Test criteria

New users who have not started the tutorial yet.

Groups

Control group: current version with usual difficulty and usual number of steps

Group А: low difficulty, usual number of steps

Group B: usual difficulty, few steps

Implementation

// Timer constants
struct Constants {
    static let waitConfigConst = 10.0
}

// Value keys
enum ValueKey: String {
    case difficulty
    case stepCount
}

class AppConfig {
    static func loadDefaults() {
        func loadDefaultValues() {
        let appDefaults: [String: Any] = [
            ValueKey.difficulty.rawValue: 3,
            ValueKey.stepCount.rawValue: 10
        ]
        // Set default values
        DTDRemoteConfig.defaults = appDefaults
    }
    
    func integer(forKey key: ValueKey) -> Int {
        DTDRemoteConfig.config[key.rawValue].integerValue
    }
}

class AppLogic {
    // Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
    func startTutorial() {
        // Display the download progress indicator
        showActivityIndicator()
        // Send a trigger event that indicates tutorial start
        DTDAnalytics.tutorial(step: -1)
    }

    // Initiate tutorial completion
    func realStartTutorial() {
        // Hide the download progress indicator
        hideActivityIndicator()
        // Initiate the tutorial by using the remote values (difficulty and stepCount)
        runTutorial(stepCount: integer(forKey: .stepCount), 
                    difficulty: integer(forKey: .difficulty))
    }
}

class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_ application: UIApplication,
        willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Set the maximum time of waiting for the A/B test configuration
        DTDRemoteConfig.remoteConfigWaiting = Constants.waitConfigConst
        // Set default values
        AppConfig.loadDefaults()
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.initializeWithAbTest(applicationKey: "appKey",
                                          configuration: config,
                                          abConfigListener: self)
    }
}

extension AppLogic: DTDRemoteConfigListener {
    // Process the result of waiting for A/B test configuration
    func onReceived(result: DTDRemoteConfigReceiveResult) {
        // It is not used in current example
    }

    // Prepare the app UI for changing the remote configuration
    func onPrepareToChange() {
        // It is not used in current example
    }
    
    // Apply the values of the assigned group
    func onChanged(result: DTDRemoteConfigChangeResult, error: Error?) {
        defer {
            // Initiate tutorial completion
            DispatchQueue.main.async { [weak self] in
                self?.realStartTutorial()
            }
        }

        switch result {
        case .success:
            // Apply new values
            DTDRemoteConfig.applyConfig()

        case .failure:
            // Error processing
            if let error = error {
                print(error.localizedDescription)
            }

        @unknown default:
            break
        }
    }
}

// Constants .h + .m
@interface Constants : NSObject
// Timer constants
extern double const waitConfigConst;
// Value keys
extern NSString * const difficulty;
extern NSString * const stepCount;
@end

@implementation Constants
double const waitConfigConst = 10.0;
NSString * const difficulty = @"difficulty";
NSString * const stepCount = @"stepCount";
@end

// AppConfig .h + .m
@interface AppConfig: NSObject
+(void) loadDefaults;
+(NSInteger) getIntegerForKey:(NSString *) key;
@end

@implementation AppConfig
+(void)loadDefaults {
    NSDictionary *appDefaults = @{
        difficulty: @3,
        stepCount: @10
    };

    // Set default values
    DTDRemoteConfig.defaults = appDefaults;
}

+(NSInteger) getIntegerForKey:(NSString *) key {
    return DTDRemoteConfig.config[key].integerValue;
}
@end

// AppLogic .h + .m
@interface AppLogic : UIViewController <DTDRemoteConfigListener>
@end

@implementation AppLogic

- (void)viewDidLoad {
    [super viewDidLoad];
    // Display the launch screen
    [self startTutorial];
}

// Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
- (void) startTutorial {
    // Display the download progress indicator
    [self showActivityIndicator];
    // Send a trigger event that indicates tutorial start
    [DTDAnalytics tutorialStep:-1];
}

// Initiate tutorial completion
- (void) realStartTutorial {
    // Hide the download progress indicator
    [self hideActivityIndicator];
    // Initiate the tutorial by using the remote values (difficulty and stepCount)
    [self runTutorial: [AppConfig getIntegerForKey:stepCount]
       withDifficulty: [AppConfig getIntegerForKey:difficulty]];
}

- (void) runTutorial:(NSInteger) stepCount withDifficulty:(NSInteger) difficulty {
   // Start tutorial
}

// Process the result of waiting for A/B test configuration
- (void)onReceivedResult:(enum DTDRemoteConfigReceiveResult)result {
    // It is not used in current example
}

// Prepare the app UI for changing the remote configuration
- (void)onPrepareToChange {
    // It is not used in current example
}

// Apply the values of the assigned group
- (void)onChangedResult:(enum DTDRemoteConfigChangeResult)result error:(NSError *)error {
    switch (result) {
        case DTDRemoteConfigChangeResultSuccess:
            // Apply new values
            [DTDRemoteConfig applyConfig];
            break;

        case DTDRemoteConfigChangeResultFailure:
            // Error processing
            if (error) {
                NSLog(@"DTDRemoteConfigError: %@", error.localizedDescription);
            }

        default:
            break;
    }

    // Initiate tutorial completion
    __weak AppLogic *weakSelf = self;
    dispatch_async(dispatch_get_main_queue(), ^{
        [weakSelf realStartTutorial];
    });
}

- (void)showActivityIndicator {
    // Display the launch screen
}

- (void)hideActivityIndicator {
    // Hide launch screen
}
@end

// AppDelegate .h + .m
@interface AppDelegate ()
@end

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    AppLogic *appLogicController = [[UIStoryboard storyboardWithName:@"Main" bundle:nil] instantiateViewControllerWithIdentifier:@"AppLogic"];
    UINavigationController *navController = [[UINavigationController alloc]initWithRootViewController:appLogicController];
    self.window.rootViewController = navController;
    [self.window makeKeyAndVisible];

    // Set the maximum time of waiting for the A/B test configuration
    DTDRemoteConfig.remoteConfigWaiting = waitConfigConst;
    // Implementation defaults params
    [AppConfig loadDefaults];
    [DTDAnalytics applicationKey:appKey abConfigListener:appLogicController];

    return YES;
}
@end

class Constants {
    // Timer constants
    companion object {
        const val waitConfigConst = 10.0
        const val waitConfigConstInMilliseconds = 10000L
    }
}

enum class ValueKey(val value: String) {
    Difficulty("difficulty"),
    StepCount("stepCount")
}

class AppConfig {
    companion object {
        fun loadDefaults() {
            val appDefaults = mapOf<String, Any>(
                ValueKey.Difficulty.value to 3,
                ValueKey.StepCount.value to 10
            )
            // Set default values
            DTDRemoteConfig.defaults = appDefaults
        }

        fun integer(key: ValueKey): Int {
            return DTDRemoteConfig.config[key.value].intValue
        }
    }
}

class AppLogic {
    // Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
    fun startTutorial() {
        // Display the download progress indicator
        showActivityIndicator()
        // Send a trigger event that indicates tutorial start
        DTDAnalytics.tutorial(step = -1)
    }


    // Initiate tutorial completion
    fun realStartTutorial() {
        // Hide the download progress indicator
        hideActivityIndicator()
        // Initiate the tutorial by using the remote values (difficulty and stepCount)
        runTutorial(
            stepCount = AppConfig.integer(ValueKey.StepCount),
            difficulty = AppConfig.integer(ValueKey.Difficulty)
        )
    }
}

class MainActivity : AppCompatActivity(), DTDRemoteConfigListener {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState, persistentState)
        setContentView(R.layout.activity_main)

        // Set the maximum time of waiting for the A/B test configuration
        DTDRemoteConfig.remoteConfigWaiting = Constants.waitConfigConst
        // Set default values
        AppConfig.loadDefaults()
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.initializeWithAbTest(
            appKey = "appKey",
            context = this,
            abConfigListener = this
        )
    }

    // Process the result of waiting for A/B test configuration
    override fun onReceived(result: DTDRemoteConfigReceiveResult) {
        // It is not used in current example
    }


    // Prepare the app UI for changing the remote configuration
    override fun onPrepareToChange() {
        // It is not used in current example
    }

    override fun onChanged(result: DTDRemoteConfigChangeResult, ex: Exception?) {
        when (result) {
            DTDRemoteConfigChangeResult.Success -> {
                // Apply new values
                DTDRemoteConfig.applyConfig()
            }
            DTDRemoteConfigChangeResult.Failure -> {
                // Error processing
                ex?.let { Log.e("TAG", ex.toString()) }
            }
        }

        runOnUiThread {
            realStartTutorial()
        }
    }
}

class Constants {
    // Timer constants
    final static double waitGroupConst = 10.0;
    final static long waitGroupConstInMilliseconds = 10000L;
}

enum ValueKey {
    Difficulty("difficulty"),
    StepCount("stepCount");

    private final String stringValue;

    ValueKey(String toString) {
        stringValue = toString;
    }

    @Override
    public String toString() {
        return stringValue;
    }
}

class AppConfig {
    static void loadDefaults() {
        HashMap<String, Object> map = new HashMap<>();
        map.put(ValueKey.Difficulty.toString(), 3);
        map.put(ValueKey.StepCount.toString(), 10);
        DTDRemoteConfig.INSTANCE.setDefaults(map);
    }

    static Integer integer(ValueKey key) {
        return DTDRemoteConfig.INSTANCE.getConfig().get(key.toString()).getIntValue();
    }
}

class AppLogic {
    // Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
    static void startTutorial() {
        // Display the download progress indicator
        showActivityIndicator();
        // Send a trigger event that indicates tutorial start
        DTDAnalytics.INSTANCE.tutorial(-1);
    }

    // Initiate tutorial completion
    static void realStartTutorial() {
        // Hide the download progress indicator
        hideActivityIndicator();
        // Initiate the tutorial by using the remote values (difficulty and stepCount)
        runTutorial(
                AppConfig.integer(ValueKey.StepCount),
                AppConfig.integer(ValueKey.Difficulty)
        );
    }
}

class MainActivity extends AppCompatActivity implements DTDRemoteConfigListener {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Set the maximum time of waiting for the A/B test configuration
        DTDRemoteConfig.INSTANCE.setRemoteConfigWaiting(Constants.waitGroupConst);
        // Set default values
        AppConfig.loadDefaults();
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.INSTANCE.initializeWithAbTest("appKey", this, this);
    }

    // Process the result of waiting for A/B test configuration
    @Override
    public void onReceived(@NonNull DTDRemoteConfigReceiveResult result) {
        // It is not used in current example
    }

    // Prepare the app UI for changing the remote configuration
    @Override
    public void onPrepareToChange() {
        // It is not used in current example
    }

    @Override
    public void onChanged(@NonNull DTDRemoteConfigChangeResult result, @Nullable Exception ex) {
        if (result == DTDRemoteConfigChangeResult.Success) {
            // Apply new values
            DTDRemoteConfig.INSTANCE.applyConfig();
        }

        if (result == DTDRemoteConfigChangeResult.Failure) {
            // Error processing
            if (ex != null) {
                Log.e("TAG", ex.toString());
            }
        }

        runOnUiThread(AppLogic::realStartTutorial);
    }
}

// Timer constants
public static class Constants
{
    public const float WAIT_CONFIG_TIME = 10.0f;
}
    
// Value keys
public enum ValueKey
{
    difficulty,
    stepCount
}

public class AppConfig
{
    public void LoadDefaults()
    {
        var appDefaults = new Dictionary<string, object>
        {
            {ValueKey.difficulty.ToString(), 3},
            {ValueKey.stepCount.ToString(), 10}
        };
        // Set default values
        DTDRemoteConfig.Defaults = appDefaults;
    }
    
    public int GetInt(ValueKey key) => DTDRemoteConfig.Config[key.ToString()].IntValue();
}

public class AppLogic : MonoBehaviour, IDTDRemoteConfigListener
{
    private readonly AppConfig _appConfig = new AppConfig();
    private const string APP_KEY = "appKey";
    private SimpleUI _simpleUI;
    
    private void Start()
    {
        DontDestroyOnLoad(this);
        _simpleUI = FindObjectOfType<SimpleUI>();
        if (_simpleUI == null) throw new NullReferenceException("UIManager not found.");
        // Set the maximum time of waiting for the A/B test configuration
        DTDRemoteConfig.RemoteConfigWaiting = Constants.WAIT_CONFIG_TIME;
        // Set default values
        _appConfig.LoadDefaults();
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.InitializeWithAbTests(
            appKey: APP_KEY,
            analyticsConfiguration: _analyticsConfiguration,
            configListener: this);
    }

    // Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
    public void StartTutorial()
    {
        // Send a trigger event that indicates tutorial start
        DTDAnalytics.Tutorial(-1);
        // Display the download progress indicator
        _simpleUI.ShowLoadingIndicator(Constants.WAIT_CONFIG_TIME);
    }
    
    // Initiate tutorial completion
    private void RealStartTutorial()
    {
        // Hide the download progress indicator
        _simpleUI.HideLoadingIndicator();
        // Initiate the tutorial by using the remote values (difficulty and stepCount)
        RunTutorial(
            stepCount: DTDRemoteConfig.Config[ValueKey.stepCount].IntValue(),
            difficulty: DTDRemoteConfig.Config[ValueKey.difficulty].IntValue()
        );
    }

    // Process the result of waiting for A/B test configuration
    public void OnReceived(DTDRemoteConfigReceiveResult result)
    {
        // It is not used in current example.
    }

    // Prepare the app UI for changing the remote configuration
    public void OnPrepareToChange()
    {
        // It is not used in current example
    }

    // Apply the values of the assigned group
    public void OnChanged(DTDRemoteConfigChangeResult result, string exceptionText = null)
    {
        switch (result)
        {
            case DTDRemoteConfigChangeResult.Failure:
                // Error processing
                if (exceptionText != null) Debug.LogError(exceptionText);
                break;
            case DTDRemoteConfigChangeResult.Success:
                // Apply new values
                DTDRemoteConfig.ApplyConfig();
                break;
        }
        
        // Initiate tutorial completion
        RealStartTutorial();
    }
}

using DevToDev.Analytics;
using System.Collections.Generic;
using System.Diagnostics;

// Timer constants
static class Constants
{
    public const float WaitConfigConst = 10.0f;
}

// Value keys
static class ValueKeys
{
    public const string Difficulty = "difficulty";
    public const string StepCount = "stepCount";
}

static class AppConfg
{
    public static void LoadDafaults()
    {
        // Set default values
        DTDRemoteConfig.Defaults = new Dictionary<string, object>
        {
            [ValueKeys.Difficulty] = 3,
            [ValueKeys.StepCount] = 10
        };
    }

    public static int GetIntValue(string key)
    {
        return DTDRemoteConfig.Config[key].Int32Value;
    }
}

class Application : IDTDRemoteConfigListener
{
    public void Run()
    {
        // Set the maximum time of waiting for the A/B test configuration
        DTDRemoteConfig.RemoteConfigWaiting = Constants.WaitConfigConst;
        // Set default values
        AppConfg.LoadDafaults();
        // Initialize the SDK for working with A/B testing
        DTDAnalytics.InitializeWithAbTest("appKey", this);
        // Prepare tutorial scene to show
        PrepareTutorialScene();
    }

    // Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
    public void PrepareTutorialScene()
    {
        // Display the download progress indicator
        UI.ShowLoadingIndicator();
        // Send a trigger event that indicates tutorial start
        DTDAnalytics.Tutorial(-1);
    }

    // Initiate tutorial completion
    public void StartTutorialScene()
    {
        var difficulty = AppConfg.GetIntValue(ValueKeys.Difficulty);
        var stepCount = AppConfg.GetIntValue(ValueKeys.StepCount);
        // Hide the download progress indicator (method do a job in UI thread)
        UI.HideLoadingIndicator();
        // Initiate the tutorial by using the remote values (method do a job in UI thread)
        UI.ShowTutorialScreen(difficulty, stepCount);
    }
    
    // Apply the values of the assigned group
    public void OnChanged(DTDRemoteConfigChangeResult result, string error)
    {
        Debug.WriteLine($"[App-ABTests] OnChanged({result}, {error})");
        switch (result)
        {
            case DTDRemoteConfigChangeResult.Failure:
                // Error processing
                break;
            case DTDRemoteConfigChangeResult.Success:
                // Apply new values
                DTDRemoteConfig.ApplyConfig();
                break;
            default:
                break;
        }

        // Initiate tutorial completion
        StartTutorialScene();
    }

    // Prepare the app UI for changing the remote configuration
    public void OnPrepareToChange()
    {
        Debug.WriteLine($"[App-ABTests] OnPrepareToChange()");
         // It is not used in current example
    }

    
    // Process the result of waiting for A/B test configuration
    public void OnReceived(DTDRemoteConfigReceiveResult result)
    {
        Debug.WriteLine($"[App-ABTests] OnReceived({result})");
         // It is not used in current example
    }
}

// Timer constant
const float WAIT_CONFIG_TIME = 10.0f;
    
void SomeLogicClass::Start() {
    // Set the maximum time of waiting for the A/B test configuration
    DTDRemoteConfigBPLibrary::SetRemoteConfigWaiting(WAIT_CONFIG_TIME);

    // Set default values
    FDTDRemoteConfigDefaults Defaults;
    Defaults.IntegerDefaults.Add("difficulty", 3);
    Defaults.IntegerDefaults.Add("stepCount", 10);
    UDTDRemoteConfigBPLibrary::SetDefaults(Defaults);

    const auto onConfigReceive = new FDTDRemoteConfigReceiveResultDelegate();
    onConfigReceive->BindUObject(this, &SomeLogicClass::OnConfigReceive);

    const auto onPrepareToChange = new FDTDRemoteConfigPrepareToChangeDelegate();
    onPrepareToChange->BindUObject(this, &SomeLogicClass::OnPrepareToChange);

    const auto onConfigChange = new FDTDRemoteConfigChangeResultDelegate();
    onConfigChange->BindUObject(this, &SomeLogicClass::OnConfigChange);

    // Initialize the SDK for working with A/B testing
    UDTDAnalyticsBPLibrary::InitializeWithAbTest("AppKey", *onConfigChange, *onPrepareToChange, *onConfigReceive);
}

// Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
void SomeLogicClass::StartTutorial()
{
    // Send a trigger event that indicates tutorial start
    UDTDAnalyticsBPLibrary::Tutorial(-1);
    // Display the download progress indicator
    SomeUI::ShowLoadingIndicator(WAIT_CONFIG_TIME);
}

// Initiate tutorial completion
void SomeLogicClass::RealStartTutorial()
{
    // Hide the download progress indicator
    SomeUI::HideLoadingIndicator();
    // Initiate the tutorial by using the remote values (difficulty and stepCount)
    RunTutorial(UDTDRemoteConfigBPLibrary::GetRemoteConfigValue("difficulty").IntegerValue,
		UDTDRemoteConfigBPLibrary::GetRemoteConfigValue("stepCount").IntegerValue);
}


// Process the result of waiting for A/B test configuration
void SomeLogicClass::OnConfigReceive(EDTDRemoteConfigReceiveResult result) {
    // It is not used in current example.
}

// Prepare the app UI for changing the remote configuration
void SomeLogicClass::OnPrepareToChange() {
    // It is not used in current example
}

// Apply the values of the assigned group
void SomeLogicClass::OnConfigChange(EDTDRemoteConfigChangeResult result, const FString& error) {
    switch (result)
    {
    case EDTDRemoteConfigChangeResult::Success:
    	// Apply new values
	UDTDRemoteConfigBPLibrary::ApplyConfig();
	break;
	
    case EDTDRemoteConfigChangeResult::Failure:
	// Error processing
	UE_LOG(LogTemp, Warning, TEXT("DTDRemoteConfigError: %s"), *error);
	break;

    default:
    	break;
    }

    // Initiate tutorial completion
    RealStartTutorial();
}

# Timer constant
var waitConfigConst = 10.0

var difficulty = "difficulty"
var stepCount = "stepCount"

func loadDefaults():
	var appDefaults = GDDTDRemoteConfigDefaults.new()
	# Set default values
	appDefaults.AddIntegerValue(difficulty, 3)
	appDefaults.AddIntegerValue(stepCount, 10)
	DTDRemoteConfig.SetDefaults(appDefaults)
	
	
func getInteger(key: String) -> int: 
	return DTDRemoteConfig.GetRemoteConfigValue(key).GetIntValue()

# Tutorial open event (e.g. by clicking the ‘start tutorial’ button)
func startTutorial():
	# Display the download progress indicator
	showActivityIndicator()
	#Send a trigger event that indicates tutorial start
	DTDAnalytics.Tutorial(-1)

#  Initiate tutorial completion
func realStartTutorial():
	# Hide the download progress indicator
	hideActivityIndicator()
	#Initiate the tutorial by using the remote values (difficulty and stepCount)
	var stepCount = getInteger(stepCount)
	var difficulty = getInteger(stepCount)

func _ready():
		# Set the maximum time of waiting for an A/B test group
	DTDRemoteConfig.SetRemoteConfigWaiting(waitConfigConst)
		# Set default values
	loadDefaults()
		# Initialize the SDK for working with A/B testing
	DTDAnalytics.InitializeWithAbTest(appKey",
	onRemoteConfigChange,
	onRemoteConfigPrepareToChange,
	onRemoteConfigReceive)

func onRemoteConfigChange(result: GDDTDRemoteConfigChangeResult.ChangeResult, error: String):
	match result:
		GDDTDRemoteConfigChangeResult.Success:
			# Apply new values
			DTDRemoteConfig.ApplyConfig()
		GDDTDRemoteConfigChangeResult.Failure:
			# Error processing
			print(error)
				
	realStartTutorial()

# Prepare the app UI for changing the remote configuration
func onRemoteConfigPrepareToChange():
	# It is not used in current example
	pass

# Process the result of waiting for A/B test configuration
func onRemoteConfigReceive(result: GDDTDRemoteConfigReceiveResult.ReceiveResult):
	# It is not used in current example
	pass

Integration of SDK 2.0+ (new)

SDK Integration

iOS

CocoaPods

Manual installation

Integration features

For Objective-C

For SwiftUI

Apps targeted at children

Privacy Manifest

Privacy manifest for Devtodev SDKs:

Analytics module

Messaging module

SDK Signature

macOS

Manual installation

Integration features

For Objective-C

For SwiftUI

Apps targeted at children

Windows

1. NuGet Installation

Package Manager UI

2. SDK Initialization

1. NuGet Installation

Package Manager UI

2. SDK Initialization

3. SDK Activity

Web

Initialization

Unity

SDK Integration

Integration by using the Unity Package Manager

Integration by importing unitypackage

SDK Initialization

Specific integration features of certain platforms

Windows Standalone

Universal Windows Platform (WSA)

Android

Huawei

iOS

iOS SDK Signature and Privacy Manifest

Apps targeted at children

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:

Godot Engine

Integration Godot SDK

Requirements

The SDK module installation

SDK Initialization

Project export

Export for MacOS

Export for iOS

Export for Android

Setting up Events

Secondary methods

Ad impression

Connecting to social networks

Posting to social networks

Referrer

Force dispatch of accumulated events

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`