Please perform the following actions to integrate your application with devtodev system:

• add the application to the Space using the wizard for adding application

• download the latest version of devtodev SDK or install via CocoaPods

• integrate SDK into your application. The integration may be whether partial or including all the possibilities.

CocoaPods

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

1. Firstly, install CocoaPods using

   Copy

   gem install cocoapods

2. Create a file in your Xcode project called Podfile and add the following:

   Copy

   pod 'devtodev'

3. Run

   Copy

   pod install

   in your Xcode project directory. 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 GitHub repository.

2. Include devtodev.framework dependency:

3. Link against the embedded framework:

   Add devtodev.framework to the Linked Frameworks and Libraries section.

4. For the correct SDK functioning add the following frameworks:

   • Security.framework (Optional)

   • UIKit.framework (Optional)

   • UserNotifications (Optional)

   • StoreKit.framework

   • AdSupport.framework

5. Add init method into didFinishLaunchingWithOptions method of your AppDelegate.m

   Copy

   /**
   * devtodev App Id and Secret key can be found in the devtodev application
   * settings page (“My apps” → App Name → “Settings” → “Integration”)
   */
   [DevToDev initWithKey:applicationId andSecretKey:secretKey];

6. If the application you integrate SDK in is a part of a cross-platform project, then the user data initialization is required. Since the analytics of cross-platform projects is based on an unique user (unlike the usual projects where it is based on device identifiers), you have to:

   • Set the unique cross-platform user identifier (it will be used for cross-platform project data collection).

   • Actualize the user data. Mostly it is about game applications where the player has a game level as a characteristic. For such projects, you need to set the current player level.

We recommend you set the user identifier before SDK initialization, otherwise the user identifier from the previous session will be used since the SDK initialization moment till the setUserID method call.

/**
* Method allows to initialize the user. It applies when SDK initialization or user relogin.
* @param NSString activeUserId - unique cross-platform user identifier (max. 64 symbols)
*/
[DevToDev setUserId:@"activeUserId"];

/**
* Method sets the current user level. Using this method allows to actualize 
* the SDK user data in game cross-platform applications.
* @param NSUInteger level - number of current game level of the user
*/
[DevToDev setCurrentLevel:level];

/**
* devtodev App Id and Secret key can be found in the devtodev application
* settings page ("Settings" → "SDK" → "Integration")
*/
[DevToDev initWithKey:applicationId andSecretKey:secretKey];

Debug mode

To enable the debug mode and make SDK notifications displayed in the console use this method:

/**
* @param BOOL isActive
*/
[DevToDev setActiveLog: (BOOL) isActive];

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

2. To start working with the SDK, add the DevToDev.winmd and DevToDev.Background.winmd to the project references.

3. Initialize the library at Application Launching event.

/**
* <param name="appKey">App ID</param>
* <param name="appSecret">Application secret key</param>
*/
DevToDev.SDK.Initialize(string appKey, string appSecret);

App ID and Secret key can be found in the application settings (Open "Settings" → "SDK" → "Integration").

Example:

DevToDev.SDK.Initialize("3f2504e0-4f89-11d3-9a0c-0305e82c3301", "a8f5f167f44f4964e6c998dee827110c");

If the application you integrate SDK in is a part of cross-platform project, then the user data initialization is required.

Since the analytics of a cross-platform projects is based on a unique user (unlike the usual projects where it is based on device identifiers), you have to:

• Set the unique cross-platform user identifier (it will be used for a cross-platform project data collection).

• Actualize the user data. Mostly it is about game applications where the player has a game level as a characteristic. For such projects you need to set the current player level.

DevToDev.SDK.UserID = "activeUserId"; //cross-platform user identifier (64 symbols max.)

/**
* <param name="appKey">App ID</param>
* <param name="appSecret">Application secret key</param>
*/
DevToDev.SDK.Initialize(string appKey, string appSecret);

/**
* <param name="level">Current level</param>
*/
DevToDev.SDK.SetCurrentLevel(int level);

Debug mode

To enable the debug mode and make SDK notifications displayed in the console use this method:

//to enable logging
DevToDev.SDK.LogEnabled = true;

//to disable loging
DevToDev.SDK.LogEnabled = false;

SDK is available as a library in AAR (recommended) and JAR. The library is available in Maven Central repository and on GitHub repository.

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

dependencies {
    implementation 'com.devtodev:android:1.14.10'
    implementation 'com.android.installreferrer:installreferrer:2.2'
    implementation 'com.google.android.gms:play-services-base:17.6.0'
    implementation 'com.google.firebase:firebase-core:19.0.0'
    implementation 'androidx.preference:preference:1.1.1' //or higher, required for SDK version 1.14.8 and higher
}

In case you don't use Gradle, you can download it here and add the library into the project.

Step 2. Initialize the library in the first Activity method onCreate() in the following way:

public class MyActivity extends Activity {
      @Override
      public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          // Initialization devtodev SDK
          DevToDev.init(this, APP_ID, SECRET_KEY);
      }
}

App ID and Secret key can be found in the application settings: "Settings" → "SDK" → "Integration".

<service
android:name="com.devtodev.push.logic.DTDFcmMessagingService"
android:enabled="false">
</service>

If you want to use our SDK to work with push notifications, see this doc.

Step 3. Add the following lines at the bottom of proguard.config

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

Additional initialization

If the application you integrate SDK in is a part of a cross-platform project, then the user data initialization is required.

Since the analytics of cross-platform projects is based on a unique user (unlike the usual projects where it is based on device identifiers), you have to:

• Set the unique cross-platform user identifier (it will be used for cross-platform project data collection).

• Actualize the user data. Mostly it is about game applications where the player has a game level as a characteristic. For such projects you need to set the current player level.

/**
* Method allows to initialize the user. It applies when SDK initialization or user relogin.
* @param String activeUserId - unique cross-platform user identifier (max. 64 symbols)
*/
DevToDev.setUserId(activeUserId);

/**
* Method sets the current user level. Using this method allows to actualize the SDK user data
* in game cross-platform applications.
* @param int level - number of current game level of the user
*/
DevToDev.setCurrentLevel(currentLevel);

/**
* devtodev SDK initialization
* @param String appId - devtodev App Id
* @param String secretKey - Secret key
* devtodev App Id and Secret key can be found in the devtodev application
* settings page ("Settings" → "SDK" → "Integration")
*/
DevToDev.init(getBaseContext(), appId, secretKey);

Debug mode

To enable the debug mode and make SDK notifications displayed in the console use this method:

/**
* @param logLevel
*/
DevToDev.setLogLevel(LogLevel logLevel);

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

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

2. Integration samples of devtodev SDK for WEB are available on GitHub.

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

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

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.

/**
* @param {string} apiKey - devtodev API key, unique API key can be found in the application
* settings ("Settings" → "SDK" → "Integration")
* @param {string} userId - Unique user identifier.
* For example, user’s ID in a social network, or a unique account name used
* for user identification on your server.
* @param {string} previousUserId - Previous unique user identifier. Optional.
* It is used in case of change of the user identifier.
*/

devtodev.init(apiKey, userId, previousUserId);

Unique API key can be found in the application settings: "Settings" → "SDK" → "Integration".

Cross-platform application Initialization

In cross-platform applications, the additional user identifier can be used. It is a user cross-platform ID which is unique for all of the platforms. And if a cross-platform ID differs from the ID that is main for the platform, you need to set the cross-platform ID. The cross-platform ID combines the user data for a cross-platform project.

We recommend you apply this method before the SDK initialization, otherwise, the user identifier from the previous session will be used since the SDK initialization moment till the setCrossplatformUserId method call.

If it is difficult to do, set a cross-platform ID as soon as it is available in the application after SDK initialization.

/**
* Initializes the user with the specified cross-platform identifier
* @param {string} сrossplatformUserId - unique cross-platform user ID used
* for user identification on your server.
*/

devtodev.setCrossplatformUserId(сrossplatformUserId);

Additional initialization

For the most precise data collection, we strongly recommend specifying some information about the user right after SDK is initiated.

User data initialization

In the first place, this additional initialization is required for gaming applications where the player has a game level as a characteristic.

/**
* Initializes the current user level. Required if level feature used in the app.
* @param {number} currentUserLevel- Сurrent game level of the player.
*/

devtodev.setCurrentLevel(currentUserLevel);

Application data initialization

It is not obligatory, but if you want to have the ability to build reports with regard to the version of your application, use this method before initialization.

/**
* @param {Object} appData - App data object.
* @param {string} appData.appVersion - Current app version. Required.
* @param {number} appData.codeVersion - Current code version. Optional.
*/

devtodev.setAppData(appData);

Debug mode

To enable the debug mode and make SDK notifications displayed in the console, use this method:

/**
* Activates console log
* @param {boolean} status
*/

devtodev.setDebugLog(status);

Please do the following to integrate your application with devtodev:

1. Add the application to the Space using the wizard for adding application. Attention! If your Adobe Air can be used for compilations for different platforms, you need to add the applications in devtodev for each platform. As a result, the statistics will be gained for each platform separately.

2. Download the latest version of devtodev SDK from the GitHub repository.

3. Add com.devtodev.sdk.ane library to your application

4. For Android add the following permissions to the MyApplication.xml file:

  <uses-permission android:name="android.permission.INTERNET"/>
  <!-- Necessary(Required for sending analytics data to our server) -->
  <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
  <!-- Additional (Required for devices' MAC addresses collection) -->
  <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  <!-- Additional (Required for cellular operator data collection) -->

To automatically gather the referrals data on Android, add the following strings into tag

  <receiver android:name="com.devtodev.InstallReceiver" android:enabled="true" android:exported="true">
  <intent-filter>
       <action android:name="com.android.vending.INSTALL_REFERRER" />
  </intent-filter>
  </receiver>

For other platforms no changes are needed.

5. Add the following imports to your source

  import com.devtodev.sdk.core.DevToDev;
  import com.devtodev.sdk.core.data.consts.AccrualType;
  import com.devtodev.sdk.core.data.consts.Gender;
  import com.devtodev.sdk.core.data.consts.SocialNetwork;
  import com.devtodev.sdk.core.data.consts.TutorialState;
  import com.devtodev.sdk.cheat.data.consts.VerifyStatus;
  import com.devtodev.sdk.cheat.data.consts.TimeStatus;
  import com.devtodev.sdk.core.data.metrics.aggregated.events.CustomEventParams;

6. Add following source into initialize event in MyApplication.mxml file:

  DevToDev.init(AppId:String, SecretKey:String);

The appKey and appSecret values are unique for each app on each platform and can be found in the settings of appropriate app ("Settings" → "SDK" → "Integration").

For example: file MyApplication.mxml:

<?xml version="1.0" encoding="utf-8"?>
<s:Application initialize="application1_activateHandler(event)" 
               deactivate="application1_deactivateHandler(event)" 
               xmlns:fx="http://ns.adobe.com/mxml/2009" 
               xmlns:s="library://ns.adobe.com/flex/spark" applicationDPI="160">
    <fx:Script>
        <![CDATA[
                 import com.devtodev.sdk.core.DevToDev;
                 import com.devtodev.sdk.core.data.consts.AccrualType;
                 import com.devtodev.sdk.core.data.consts.Gender;
                 import com.devtodev.sdk.core.data.consts.SocialNetwork;
                 import com.devtodev.sdk.core.data.consts.TutorialState;
                 import com.devtodev.sdk.cheat.data.consts.VerifyStatus;
                 import com.devtodev.sdk.cheat.data.consts.TimeStatus;
                 import com.devtodev.sdk.core.data.metrics.aggregated.events.CustomEventParams;

                 protected function application1_activateHandler(event:Event):void {
                      DevToDev.init(AppId, SecretKey);
                      DevToDev.startSession();
                 }

                 protected function application1_deactivateHandler(event:Event):void {
                      DevToDev.endSession();        
                 }
        ]]>
    </fx:Script>

    <fx:Declarations>
    </fx:Declarations>

    <s:VGroup>
    </s:VGroup>

</s:Application>

file MyApplication.xml:

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<application xmlns="http://ns.adobe.com/air/application/17.0">
   <id>com.my.application</id>
   <filename>myapplication</filename>
   <name>myapplication</name>
   <versionNumber>1.0.0</versionNumber>
   <initialWindow>
      <autoOrients>true</autoOrients>
      <fullScreen>false</fullScreen>
      <visible>true</visible>
      <softKeyboardBehavior>none</softKeyboardBehavior>
   </initialWindow>
   <android>
      <colorDepth>16bit</colorDepth>
      <manifestAdditions><![CDATA[
         <manifest android:installLocation="auto">
            <uses-permission android:name="android.permission.INTERNET"/>
            <uses-permission android:name="android.permission.WAKE_LOCK"/>
            <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
            <application>
                 <receiver android:name="com.devtodev.InstallReceiver" android:enabled="true"
                 android:exported="true">
                   <intent-filter>
                        <action android:name="com.android.vending.INSTALL_REFERRER" />
                   </intent-filter>
                 </receiver>
            </application>
         </manifest>
      ]]></manifestAdditions>
   </android>
   <iPhone>
      <InfoAdditions><![CDATA[
         <key>UIDeviceFamily</key>
         <array>
            <string>1</string>
            <string>2</string>
         </array>
      ]]></InfoAdditions>
      <requestedDisplayResolution>high</requestedDisplayResolution>
   </iPhone>

   <extensions>
      <extensionID>com.devtodev.SDK</extensionID>
   </extensions>
</application>

Additional initialization

If the application you integrate SDK in is a part of cross-platform project, then the user data initialization is required.

Since the analytics of cross-platform projects is based on a unique user (unlike the usual projects where it is based on device identifiers), you have to:

• Set the unique cross-platform user identifier (it will be used for cross-platform project data collection).

• Actualize the user data. Mostly it is about game applications where the player has a game level as a characteristic. For such projects, you need to set the current player level.

/**
* Method allows to initialize the user. It applies when SDK initialization or user relogin.
* @param activeUserId - unique cross-platform user identifier (max. 64 symbols)
*/
DevToDev.setUserId(activeUserId:String);

/**
* Method sets the current user level. Using this method allows to actualize the SDK user data
* in game cross-platform applications.
* @param level - number of current game level of the user
*/
DevToDev.setCurrentLevel(level:int);

/**
* devtodev App Id and Secret key can be found in the devtodev application
* settings page ("Settings" → "SDK" → "Integration")
* @param appKey - application key
* @param appSecret - application secret
*/
DevToDev.init(appKey:String, appSecret:String);

Debug mode

To enable the debug mode and make SDK notifications displayed in the console, use this method:

/**
* @param logLevel (set logLevel=1 to enable log, 0 to disable)
*/
DevToDev.setLogLevel(logLevel:int);

Integration

Please do the following to integrate your application with devtodev:

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

2. Attention! If your Unity project can be used for compilations for different platforms, you need to add the applications in devtodev for each platform. As a result, the statistics will be gained for each platform separately.

3. Download the latest version of devtodev SDK from the GitHub repository.

4. Attention! If you install SDK versions (1.*) 2.0, 2.0.1 or 2.0.2, you have to delete them before integrating the latest version.

   To do that, delete the following files and catalogues:

   For 1.*

   • Assets/DevToDev/ (the folder)

   • Assets/Plugins/Android/ (files android-suport-v4.jar, AndroidManifest.xml, devtodev.jar, devtodev_android_wrapper.jar, google-play-services.jar)

   • Assets/Plugins/iOS/ (files AccrualType.h, CustomEventParams.h, all DevToDev*.h, Gender.h, libdevtodev.a, ReceiptStatus.h, SocialNetwork.h, TimeStatus.h, TutorialState.h)

   • Assets/Plugins/Metro/devtodev.dll

   For 2.0

   • Assets/devtodev (the folder)

   • Assets/Plugins/DevToDevOSX.bundle

   After deleting, unpack devtodev.unitypackage version 2.1 and replace all the files. If you used an interface integration, you have to re-integrate SDK.

5. Unpack the devtodev.unitypackage into the project

6. There are 2 types of integration available:

   In the interface.

   • Open the main screen of the app.

   • Open Window/devtodev menu, then you'll see the following window:

• Switch on "Analytics" by pressing "On" button

• Add AppKey and SecretKey for all the using platforms (you can select the platform by clicking on it). If you need to debug, switch logging on.

  App ID and Secret key can be found in the application settings (Open "Settings" → "SDK" → "Integration").

• Script with all needed parameters if SDK initialization and tracking the user session will be automatically created and added to the scene.

Using code. Add the following strings to the GameObject which will be on the scene during the whole cycle of application work:

public class YourBehaviourScript : MonoBehaviour
{
void Start() 
{
#if UNITY_ANDROID
// <param name="androidAppId"> devtodev App ID for Google Play version of application </param>
// <param name="androidAppSecret"> devtodev Secret key for Google Play version of application </param>
   DevToDev.Analytics.Initialize(string androidAppId, string androidAppSecret);
#elif UNITY_IOS
// <param name="iosAppId"> devtodev App ID for App Store version of application </param>
// <param name="iosAppSecret"> devtodev Secret key for App Store version of application </param>
   DevToDev.Analytics.Initialize(string iosAppId, string iosAppSecret);
#elif UNITY_WEBGL
// <param name="webglAppId"> devtodev App ID for Web version of application </param>
// <param name="webglAppKey"> devtodev Secret key Web version of application </param>
   DevToDev.Analytics.Initialize(string webglAppId, string webglAppSecret);
#elif UNITY_STANDALONE_WIN
// <param name="winAppId"> devtodev App ID for Windows Store version of application </param>
// <param name="winAppSecret"> devtodev Secret key for Windows Store version of application </param>
   DevToDev.Analytics.Initialize(string winAppId, string winAppSecret);
#endif
}
};

The appId and appSecret values are unique for each app on each platform and can be found in the settings of appropriate app ("Settings" → "SDK" → "Integration").

The specificity of integration on Android platform

Add following lines at the bottom of proguard config

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

The specificity of integration on iOS platform

If you are planning to build an app for iOS, you need to add libz.tbd to the XCode project settings. This library is used by devtodev Unity SDK to compress data sent to devtodev servers. Also, you have to add UserNotifications.framework as an optional library.

Please add AdSupport.framework into the project for your SDK to function correctly with iOS and also add AppTrackingTransparency.framework for iOS 14.

Here’s how you can add them.

Option 1

1. Create Editor folder in the Assets folder.

2. In the Assets folder create DevToDevPostBuild.cs script. The script is below:

#if UNITY_IOS
using System.IO;
using UnityEditor;
using UnityEditor.Callbacks;
using UnityEditor.iOS.Xcode;
namespace DevToDev
{
   public class DevToDevPostBuild
   {
       const string APP_TARGET_NAME = "Unity-iPhone";
       [PostProcessBuildAttribute(1)]
       public static void OnPostprocessBuild(BuildTarget target, string pathToBuiltProject)
       {
           if (target != BuildTarget.iOS)
           {
               return;
           }
           iOSPostBuild(pathToBuiltProject);
       }
       private static void iOSPostBuild(string projPath)
       {
           string pbxprojPath = projPath + "/Unity-iPhone.xcodeproj/project.pbxproj";
           PBXProject proj = new PBXProject();
           proj.ReadFromString(File.ReadAllText(pbxprojPath));
           string projectGuid = proj.TargetGuidByName(APP_TARGET_NAME);
           proj.AddFrameworkToProject(projectGuid, "AdSupport.framework", true);
           // IOS 14. Xcode 12 required.
           //proj.AddFrameworkToProject(projectGuid, "AppTrackingTransparency.framework", true);
           File.WriteAllText(pbxprojPath, proj.WriteToString());
       }
   }
}
#endif

3. Uncomment proj.AddFrameworkToProject(projectGuid, "AppTrackingTransparency.framework", true); if necessary.

Option 2.

1. Add AdSupport.framework into the Frameworks section of the generated Unity xcodeproj project.

2. For iOS 14, also add AppTrackingTransparency.framework.

Additional initialization

If the application you integrate SDK in is a part of a cross-platform project, then the user data initialization is required.

Since the analytics of cross-platform projects is based on a unique user (unlike the usual projects where it is based on device identifiers), you have to:

• Set a unique cross-platform user identifier (it will be used for cross-platform project data collection).

• Actualize the user data. Mostly it is about game applications where the player has a game level as a characteristic. For such projects, you need to set the current player level.

/// <summary> Property allows to initialize the user. 
/// It applies when SDK initialization or user relogin.</summary>
/// <param name="activeUserId">unique cross-platform user identifier (max. 64 symbols)</param>
DevToDev.Analytics.UserId = activeUserID;

/// <summary> Method sets the current user level. 
/// Using this method allows to actualize the SDK user data in game cross-platform applications.</summary>
/// <param name="level">number of current game level of the user</param>
DevToDev.Analytics.CurrentLevel(level);

/// <summary>  Property allows to set current application version.
/// Attention! This property is necessary for WEB and Windows Standalone apps only.
/// It will be ignored on other platforms.</summary>
/// <param name="version"> current version of your application</param>
DevToDev.Analytics.ApplicationVersion = version;

/// <summary> devtodev App Id and Secret key can be found in the devtodev application
/// settings page ("Settings" → "SDK" → "Integration") </summary>
DevToDev.Analytics.Initialize(string appId, string appSecret);

Debug mode

To enable the debug mode and make SDK notifications displayed in the console use this method:

/// <summary> Enable/Disable log</summary>
/// <param name="isEnabled">Enabled/Disabled log</param>
DevToDev.Analytics.SetActiveLog(bool isEnabled);

Collecting data about the amount of sessions and their length

In case you want to control the beginning and the end of a session manually, use the methods below:

For the start of the session use the StartSession method:

//Call this when the session starts or is resumed
DevToDev.Analytics.StartSession();

For the end of the session use the EndSession method:

//Call this when the session is completed
DevToDev.Analytics.EndSession();

Delivering your application to the Mac App Store

1. Read an article and make sure you follow all the recommendations.

2. Delete a meta file from DevToDevOSX.bundle:

   Copy

   File.Delete (projPath + "/Contents/Plugins/DevToDevOSX.bundle/Contents.meta");

3. Rename CFBundleIdentifier in Info.plist inside the devtodev plugin, for example:

   Copy

   string plistPath = appPath + "/Contents/Plugins/DevToDevOSX.bundle/Contents/Info.plist";
   PlistDocument plist = new PlistDocument ();
   plist.ReadFromString (File.ReadAllText (plistPath));
   plist.root.SetString ("CFBundleIdentifier", PlayerSettings.applicationIdentifier + ".devtodev");
   File.WriteAllText (plistPath, plist.WriteToString ());

4. Sign the DevToDevOSX.bundle with the .entitlements you created earlier. To do this, type the following into the macOS Terminal:

   Copy

   codesign -f --deep -s 'Mac Developer: Developer Name' --entitlements "yourapp.entitlements" "path/to/your.app/Contents/Plugins/DevToDevOSX.bundle"

Please do the following to integrate your application with devtodev:

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

2. Download the latest version of the devtodev.framework from the GitHub repository and add it to 'Linked Frameworks and Libraries' list in the general settings of the project.

3. Add init method into didFinishLaunchingWithOptions method of your AppDelegate.m

   App ID and Secret key can be found in the application settings (Open "Settings" → "SDK" → "Integration").

  #import "AppDelegate.h"
  #import <devtodev/DevToDev.h>
  @interface AppDelegate ()
  @end
  @implementation AppDelegate
  - (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
          [DevToDev initWithKey:@"appKey" andSecretKey:@"secretKey"];
  }
  @end

If the application you integrate SDK in is a part of a cross-platform project, then the user data initialization is required.

Since the analytics of cross-platform projects is based on a unique user (unlike the usual projects where it is based on device identifiers), you have to:

• Set the unique cross-platform user identifier (it will be used for a cross-platform project data collection).

• Actualize the user data. Mostly it is about game applications where the player has a game level as a characteristic. For such projects, you need to set the current player level.

/**
* Method allows to initialize the user. It applies when SDK initialization or user relogin.
* @param String activeUserId - unique cross-platform user identifier (max. 64 symbols)
*/
[DevToDev setUserID:@"activeUserId"];

/**
* Method sets the current user level. Using this method allows to actualize the SDK user data
* in game cross-platform applications.
* @param NSUInteger level - number of current game level of the user
*/
[DevToDev setCurrentLevel:level];

/**
* devtodev App Id and Secret key can be found in the devtodev application
* settings page ("Settings" → "SDK" → "Integration")
*/
[DevToDev initWithKey:applicationId andSecretKey:secretKey];

Debug mode

To enable the debug mode and make SDK notifications displayed in the console, use this method:

/**
* @param BOOL isActive
*/
[DevToDev setActiveLog: (BOOL) isActive];

Please do the following to integrate your application with devtodev:

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

3. Go to your project directory and place the plugin content here: ProjectName/Plugins

4. Restart Unreal Editor and open the plugin menu (Window > Plugins). In the "Analytics" plugin group of your project select DevToDev (and "Blueprint Analytics Framework" in case if you use blueprints). You will be offered to restart Unreal Editor again.

5. Finally, add the following strings into the DefaultEngine.ini configuration file (the file is in "Config" folder of your project):

Project Settings

To get an access to the DevToDev settings, go to Project Settings > DevToDev

Get the keys (they can be found in the application settings: Settings -> SDK -> Integration) and insert the keys in this window. Then choose the Enable Push Notifications option in case if you want to send push notifications through devtodev service.

Initialization

All the events are available in the Analytics block of your Blueprint.

To initialize SDK in a blueprint, first call the "Start Session" event from the Analytics Blueprint Library.

or from the following code