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

Google implementation

Step 1. Declare repositories

In the Project build.gradle file, declare the mavenCentral repository:

repositories {
   //.. other repositories 
   mavenCentral()
}

Step 2. Add Gradle Build Dependencies

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

dependencies {
    // Requirement
    implementation ("com.google.code.gson:gson:*.*.*")
    implementation ("com.google.android.gms:play-services-ads-identifier:*.*.*")
    // Starting from version 2.2.3 and above, it is required
    implementation ("com.devtodev:android-google:*.*.*")

    // if you use AAR (recommended) or JAR downloaded from GitHub, please add:
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar"))))

    // or just add the dependency, get the latest version from
    // https://mvnrepository.com/artifact/com.devtodev/android-analytics
    implementation ("com.devtodev:android-analytics:*.*.*")

    // Optional (recommended)
    implementation ("com.android.installreferrer:installreferrer:*.*.*")
}

dependencies {
    // Requirement
    implementation 'com.google.code.gson:gson:*.*.*'
    implementation 'com.google.android.gms:play-services-ads-identifier:*.*.*'
    // Starting from version 2.2.3 and above, it is required
    implementation 'com.devtodev:android-google:*.*.*'
    
    // if you use AAR (recommended) or JAR downloaded from GitHub, please add:
    implementation fileTree(dir: "libs", include: ["*.aar"]) 
    
    // or just add the dependency, get the latest version from
    // https://mvnrepository.com/artifact/com.devtodev/android-analytics
    implementation 'com.devtodev:android-analytics:*.*.*'
    
    // Optional (recommended)
    implementation 'com.android.installreferrer:installreferrer:*.*.*'
}

Peculiarities of working with dependencies

Working with Advertising ID with Android API level less than 26

If you plan to use com.google.android.gms:play-services-ads-identifier:18.2.0 and above, you need to add com.android.tools:desugar_jdk_libs to maintain backward compatibility with devices with API level less than 26, see Use Java 8 language features and APIs | Android Studio | Android Developers

android {
    defaultConfig {
        // Required when setting minSdkVersion to 20 or lower
        multiDexEnabled = true
    }
    compileOptions {
        // Flag to enable support for the new language APIs
        coreLibraryDesugaringEnabled = true
        // Sets Java compatibility to Java 8
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
dependencies {
    // For AGP 7.4+
    coreLibraryDesugaring ("com.android.tools:desugar_jdk_libs:2.0.3")
    // For AGP 7.3
    // coreLibraryDesugaring ("com.android.tools:desugar_jdk_libs:1.2.3")
    // For AGP 4.0 to 7.2
    // coreLibraryDesugaring ("com.android.tools:desugar_jdk_libs:1.1.9")
}

android {
    defaultConfig {
        // Required when setting minSdkVersion to 20 or lower
        multiDexEnabled true
    }
    compileOptions {
        // Flag to enable support for the new language APIs
        coreLibraryDesugaringEnabled true
        // Sets Java compatibility to Java 8
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}
dependencies {
    // For AGP 7.4+
    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.3'
    // For AGP 7.3
    // coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.2.3'
    // For AGP 4.0 to 7.2
    // coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.1.9'
}

We also recommend AGP 8.0+ as it makes it easier to configure com.android.tools:desugar_jdk_libs

Huawei implementation

Step 1. Declare repositories

If you use Gradle for compiling apps, declare the following dependencies in the build.gradle file in the dependency block:

repositories {
   //.. other repositories 
   mavenCentral()
   maven { url 'https://developer.huawei.com/repo/' }
}

allprojects {
    repositories {
        //.. other repositories
        mavenCentral()
        // Configure the Maven repository address for the HMS Core SDK.
        maven {url 'https://developer.huawei.com/repo/'}
    }
}

Step 2. Add Gradle Build Dependencies

In the Project build.gradle file declare the agconnect plugin

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

In the application build.gradle file declare the following dependencies:

dependencies {
    // Requirement
    implementation ("com.google.code.gson:gson:*.*.*")
    implementation ("com.huawei.agconnect:agconnect-core:*.*.*")
    implementation ("com.huawei.hms:opendevice:*.*.*")
    // Starting from version 2.2.3 and above, it is required
    implementation ("com.devtodev.android-huawei:*.*.*")
    implementation ("com.huawei.hms:ads-identifier:*.*.*")
    
    // if you use AAR (recommended) or JAR downloaded from GitHub, please add:
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar"))))
    
    // or just add the dependency, get the latest version from
    // https://mvnrepository.com/artifact/com.devtodev/android-analytics
    implementation ("com.devtodev:android-analytics:*.*.*")
}

dependencies {
    // Requirement
    implementation 'com.google.code.gson:gson:*.*.*'
    implementation 'com.huawei.agconnect:agconnect-core:*.*.*'
    implementation 'com.huawei.hms:ads-identifier:*.*.*'
    implementation 'com.huawei.hms:opendevice:*.*.*'
    // Starting from version 2.2.3 and above, it is required
    implementation 'com.devtodev.android-huawei:*.*.*'
    
    // if you use AAR (recommended) or JAR downloaded from GitHub, please add:
    implementation fileTree(dir: "libs", include: ["*.aar"]) 
    
    // or just add the dependency, get the latest version from
    // https://mvnrepository.com/artifact/com.devtodev/android-analytics
    implementation 'com.devtodev:android-analytics:*.*.*'
}

And add a plugin:

plugins {
    //.. other plugins
    id 'com.huawei.agconnect'
}

For more information see huawei official documents.

Step 3. AppGallery

The com.devtodev.android-huawei framework works with OAID and ODID IDs. In case the OAID is undefined, we use the ODID. For both IDs to work correctly, take the following steps:

1. Create a project and an app in AppGallery. Open AppGalleryConnect → Project Settings.

2. Sign your app using a certificate (see here).

3. Enter SHA-256 certificate in the App information section. Read more about certificate creation here.

After taking all the steps described above, open the ‘App information’ section and download agconnect-services.json. You need to place this file in the app folder (read more).

SDK Initialization

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

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

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

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

• config - is a DTDAnalyticsConfiguration object instance that is used for specifying additional properties during initialization.

DTDAnalyticsConfiguration

Example:

val config = DTDAnalyticsConfiguration()
config.currentLevel = 1
config.userId = "CustomUserID"
config.trackingAvailability = DTDTrackingStatus.Enable
config.logLevel = DTDLogLevel.No
DTDAnalytics.initialize("App ID", config, context = this)

DTDAnalyticsConfiguration config = new DTDAnalyticsConfiguration();
config.setCurrentLevel(1);
config.setUserId("CustomUserID");
config.setTrackingAvailability(DTDTrackingStatus.Enable);
config.setLogLevel(DTDLogLevel.No);
DTDAnalytics.INSTANCE.initialize("App ID", config, context);

SDK obfuscation rules

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

-keep class com.devtodev.** { *; }
-dontwarn com.devtodev.**
// For Google Mobile Services 
-keep class com.google.android.gms.** { *; }
// For Huawei Mobile Services 
-keep class com.huawei.hms.**{*;}

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.

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

1. Implement the coppaControlEnable method. The method disables collection of ad IDs and vendor IDs.

2. If your app is using Google services, remove the following dependencies from gradle:

   Copy

   'com.google.android.gms:play-services-ads-identifier'  
   'com.devtodev:android-google'

3. If your app is using Huawei services, remove the following dependencies from gradle:

   Copy

   'com.huawei.hms:ads-identifier' 
   'com.huawei.hms:opendevice' 
   'com.devtodev.android-huawei'

DTDAnalytics.coppaControlEnable()
DTDAnalytics.initialize("App ID", config, context = this)

DTDAnalytics.INSTANCE.coppaControlEnable();
DTDAnalytics.INSTANCE.initialize("App ID", config, context);

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

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

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

2. Make sure that the ‘Build Settings’ for ‘Defines Module’ value evaluates to ‘YES’.

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

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

1. Implement the coppaControlEnable method. The method disables collection of ad IDs and vendor IDs (IDFA, IDFV).

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

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

Privacy Accessed API Types

Messaging module

Privacy Nutrition Label Types

Privacy Accessed API Types

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.

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

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

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

2. Make sure that the ‘Build Settings’ for ‘Defines Module’ value evaluates to ‘YES’.

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

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

1. Implement the coppaControlEnable method. The method disables collection of ad IDs and vendor IDs (IDFA, IDFV).

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

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

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

Integration

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/devtodevsdk-2.2.js">
</script>

1. Initialize the SDK.

Initialization

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

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

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

• config – is an object that is used for specifying additional properties during initialization.

Config

Example:

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

Version 2.2 (28 Mar 2025)

Added A/B test functionality (Beta)

Version 2.1 (06 Dec 2024)

Reserved user properties, which carry information about the user's personal data, are excluded from the SDK.

SDK Integration

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

1. Open the Package Manager (Window → Package Manager), click + in the top left corner and select Add package from git URL.

2. Copy the repository URL https://github.com/devtodev-analytics/package_Analytics.git to the input box and click Add.

   

   
3. Wait for the Unity Package Manager to download the package.

4. For Android projects, add an identification package:

Integration by importing unitypackage

1. Download DTDAnalytics.unitypackage from http://github.com/devtodev-analytics/Unity-sdk-3.0/releases/latest.

2. In the Unity Editor menu, open Assets → Import Package → Custom Package.

3. Select the DTDAnalytics.unitypackage that you have just downloaded.

4. Click Import.

5. For Android projects, import an identification package:

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

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)

Android

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

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

Huawei

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

   
2. If you imported the DTDGoogle package, delete the imported files Assets\Plugins\DevToDev\Android\DTDGoogleAndroid.dll and Assets\DevToDev\Analytics\Editor\GoogleDependencies.xml

   
3. Import the DTDHuawei.unitypackage manually from GitHub or use Unity Package Manager with DTDHuawei package.

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

   Copy

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

5. Open Window → devtodev and select Create android plugin folder

   
6. Copy the “agconnect-services.json“ file to the Assets\Plugins\Android\devtodev.plugin folder

   
7. Open Assets → External Dependency Manager → Android ResolverAssets → External Dependency Manager → Android Resolver and click Resolve

   
8. To proguard add the following rule:

   Copy

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

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

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.

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

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

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 EDTDReferralProperty : uint8

Referral properties.

Header file:

#include "DTDAnalytics/Public/DTDReferralProperty.h"

Values:

• Source = 0

• Medium = 1

• Content = 2

• Campaign = 3

• Term = 4

Example:

EDTDReferralProperty ReferralProperty = EDTDReferralProperty::Source;

struct FDTDOptionalInt32

An optional parameter of int32 type

Header file:

#include "DTDAnalytics/Public/DTDOptionalInt32.h"

For your convenience, we implemented the conversion constructor:

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

Example:

FDTDOptionalInt32 OptionalParameter = 1;

struct FDTDOptionalString

An optional parameter of FString type.

Header file:

#include "DTDAnalytics/Public/DTDOptionalString.h

For your convenience, we implemented the conversion constructor:

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

Example:

FDTDOptionalString OptionalParameter = FString("StringValue");

struct FDTDAnalyticsConfiguration

Configuration of the analytics plugin.

Header file:

#include "DTDAnalytics/Public/DTDAnalyticsConfiguration.h"

Example:

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

FDTDCustomEventParams

Custom parameters of a custom event.

Header file:

#include "DTDAnalytics/Public/DTDCustomEventParams.h"

Example:

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

struct FDTDStartProgressionEventParams

Parameters of the progression start event.

Header file:

#include "DTDAnalytics/Public/DTDStartProgressionEventParams.h"

Example:

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

struct FDTDFinishProgressionEventParams

Parameters of the progression completion event.

Header file:

#include "DTDAnalytics/Public/DTDFinishProgressionEventParams.h"

Example:

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

Delegates

Header file:

#include "DTDAnalytics/Public/DTDDelegates.h"

Definitions:

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

enum class EDTDGender: uint8 (Deprecated)

User gender.

Header file:

#include "DTDAnalytics/Public/DTDGender.h"

Values:

• Unknown = 0

• Male = 1

• Female = 2

Example:

EDTDGender Gender = EDTDGender::Female;

SDK initialization

SDK initialization without parameters:

UDTDAnalyticsBPLibrary::Initialize("AppKey");

SDK initialization with 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 SDK integration

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

Requirements

• Godot engine 4.0+ (Source code)

• Python 3.6+.

• SCons 3.0+ build system.

• SDK module source code (GitHub repository)

The SDK module installation

The SDK module is available in GitHub repository. 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

Find out more about compiling for MacOS

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:

Open a terminal, go to the root directory of the engine source code. Compile a custom template for MacOS (see Building export templates for MacOS), select Debug or Release build and processor architecture. To support both architectures in a single Universal 2 binary, use lipo:

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:

Open a terminal, go to the root directory of the engine source code. And compile a custom template for iOS (see Compiling for iOS). To work with the iOS simulator, compile the sources with the ios_simulator=yes flag. To support both architectures in a single Universal 2 binary, use lipo:

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:

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

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

   
3. Add frameworks:

   • AppTrackingTransparency.framework

   • AdSupport.framework

Export for Android

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

The next step is to compile the Godot engine for Android (see Android compilation), choose debug or release build, and select the processor architecture.

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