Once you've created the space, you'll see the Add Application button in the devtodev interface. Click on it to add an application to the space.

First, you need to select a platform.

The next step is optional. You can test the integration in test mode. It assumes that up to 100 different users can use the app, and their data will be excluded from statistics.

When you switch test mode off, all the users who sent the data will be marked as testers in your real account.

During the next step, you can add an account to collect data from the market or skip this step and add this information later.

The final step is to fill in the name of your app and select its genre and type. Select app type: game or app. If you choose “app” as the type, gaming events will not be tracked and displayed in the interface, even if they are integrated. Also, game-related elements will be hidden in the interface.

Please note that you can select more than one genre.

Congratulations, you have added the application to the space!

Next steps

Now you can see the standard devtodev interface and all the reports. Of course, the reports are empty until you start sending data to devtodev.

If you have added an account to collect data from the market, it will take 1 day to build the report.

If your integration uses SDK (in most cases), the next step is to integrate SDK into your app. Please read our expert tips on integration, select the necessary SDK, integrate it, and start using devtodev's full functionality!

And please don't hesitate to ask us questions. You can find the 'Support' button on the top right of the devtodev interface.

Thanks for choosing devtodev analytics!

devtodev provides SDKs that give you the ability to measure users’ behavior and player journeys using basic and custom events. We have SDKs for the most popular OS and engines:

We have SDKs for the most popular OS and engines:

Here are some simple steps to start using our service:

Add Conversion to payments report to custom dashboards

Released: 21/06/2024

You can now save Conversion to N payment, Period until payments, Top converting goods charts to a custom dashboard as widgets. This information will help you analyse the payments in a more convenient way.

Like operator in Custom Events, Funnels and User Flow

Released: 21/06/2024

The Like opertor allows you to create a mask for the string parameter values.

For example, you have a parameter called Item and it has values: offer1, offer2, offer3, offer4. Use the Like operator and type offer, this will select all four of these values in the resulting report.

Add Locations report to custom dashboards

Released: 21/06/2024

The Locations report contains ready-made metrics that allow you to see how users pass the different locations. You can now save this report to a dashboard with other metrics to see the whole picture.

Change metrics' names in Custom events report

Released: 14/05/2024

This update gives you an ability to change the name of any metric in Custom events. You can use more convenient titles and adjust the values with a Round setting. There is also an option to change the Units for a single number widget. The applied metrics' settings will also be saved when you share the report or add it to a dashboard.

Add Cumulative ARPU report to custom dashboards

Released: 14/05/2024

Results from Devtodev’s Cumulative ARPU report can now be saved to a custom dashboard as a widget. This information helps you track crucial Cumulative ARPU metric values for your project.

Acquisition: trafic source filter

Released: 30/04/2024

Previously data from Custom Postback API or SDK Install referrer was not available in the Acquisition section. Now, we have added a Source filter in the Detailed stats report, where you can select the needed trafic sources.

Table widget settings

Released: 30/04/2024

Extended period of segment expiration

Released: 10/04/2024

With this update, we have extended the expiration date for unused segments to 60 days. If you do not apply the segment to any report, it will expire. However, you will have 30 days to recover this segment before it’s completely deleted.

Axis scale settings

Released: 21/03/2024

Users now are able to customize axis boundaries on their charts to more accurately represent data trends. In cases where the charts are not optimally positioned (or you are not happy with their placement, or want to change the position of the chart), simply clicking on the Axis Scale option allows you to define the minimum and maximum values for the axis.

Managing content created by deleted users

Released: 20/03/2024

When a user deletes their account, or in case the user is removed from the space, their content remains in devtodev. Now, the team can manage the ownership of such content. For example, you can take ownership of the report made by the deleted user, or you can delete it from the space.

Transfer space ownership to another user

Released: 20/03/2024

When the space owner is changing, they need to transfer their ownership. With this update, the owner of the space can select a new owner in User settings and delegate their owner access.

Cohort Timespent in Basic Metrics

Released: 12/03/2024

We’ve added a new metric to our Basic Metrics report – the Cohort Timespent. Previously, you may have known this metric as “Cohort Playtime,” which was created specifically to evaluate user engagement in the Sessions report. And now this metric is also available in Basic Metrics for both game projects and applications.

devtodev SDK for Godot Engine

Released: 27/02/2024

Now you can create games and apps from scratch on all popular engines, including Godot, all while utilizing detailed data analytics tools. Devtodev platform will support you in understanding player behavior, optimization, and increasing user engagement throughout the entire lifetime of the product.

The new Godot SDK is now available for iOS, macOS, and Android platforms, providing you with the tools you need to take your games and apps to the next level.

Learn how to integrate Godot SDK:

Copy dynamic segments

Released: 28/01/2024

An existing dynamic segment can be duplicated with just one click. Simply copy the segment and adjust its settings to save time when creating a segment with similar conditions.

More Alert options

Released: 09/01/2024

You can receive notifications if the number of basic or custom events suddenly changes or differs from a specific day. These alerts will inform you about any positive or negative fluctuations.

Also, two new conditions have become available: a comparison with the previous day and a comparison with the same day last week. This allows the alert to activate when yesterday's event count is different from the count on the chosen day.

Space is an information field where you will work. Later on, you will add your application to the space.

Click on the Create space button in the devtodev interface.

To create a space, you need to fill in:

• Name

• Time zone

• Logo (optional)

The time zone is important because it defines the time when one day ends and another one begins.

We offer a 30-day free trial for all new users (only for the first space created using this email). Note that the trial period begins at the moment you create a Space.

That's it! You've created your space, and now you can add apps to it.

Add Retention report to custom dashboards

Released: 20/12/2023

Results from Devtodev’s Retention report can now be added to a custom dashboard as a widget. This information helps you track crucial retention metric values for your project. The update eliminates the need for SQL in building the report and adding it to the dashboard.

Here are some examples of how you can use this functionality:

• Add a widget with data on the retention of users who signed up for a specific subscription plan.

• Display the retention of users who signed up for your project and then performed a desired action (e.g., created a project, started a workout, or invited a friend).

• Compare the retention of users who engaged with your new features with those who did not (e.g., completed/skipped onboarding).

• Add several widgets to compare the retention of users who used different methods of doing something (e.g., project creation, battle modes, price plans, payment methods, etc.).

IS NOT operator and new parameter options in reports

Released: 05/12/2023

Devtodev’s Custom event, Custom funnels, and User flow reports got a new operator and parameter value that will increase their flexibility. Use the 'IS NOT' operator and 'null' parameter value to exclude certain parameters and to work with events that do not return any value.

Manage User properties in one click

Released: 21/11/2023

You can disable any property that you have previously added and now consider unnecessary or faulty. For example, if you initially collected the 'user type' property (such as beginner or pro), but have since decided to focus on the 'user status' property (guest/registered), you can disable the 'user type' property to maintain a cleaner and more organized report-building process.

1x1 widget in Custom events

Released: 20/11/2023

With this update a familiar 1x1 widget from SQL and Basic Metrics becomes available in the Custom events report. Select Report type -> Number and a single number for your most important KPI is ready for your dashboard.

Here are some examples of what you can check: number of in-app shop openings, average battle time in a game, conversion from workout start to finish.

App type selection

Released: 30/10/2023

When creating a new devtodev project, you can now select the type of project: a game or an application. This choice will affect the customization of the devtodev interface. Depending on the type, specialized reports will be available.

You can always change the type of the project later in Settings -> General settings.

Convenient 1x1 widget from Basic Metrics report

Released: 19/09/2023

Devtodev users are familiar with the 1x1 widget — a small module on your dashboard containing a single number designed to keep you informed about important metrics. With the latest update from Devtodev, you no longer need to use SQL to create widgets with basic metrics. You can simply open the Basic Metrics report, select a metric, click View -> Number, and then add this number as a widget to your dashboard. This will not only save you valuable time but also enable you to use a limited number of SQL widgets to display other metrics.

1x1 Widget upgrade

Released: 29/08/2023

When it comes to data visualization, Devtodev offers plenty of powerful tools, and SQL widgets is one of them. To give you access to even more data points on your dashboards, we’ve introduced an update that offers you the ability to display two metrics on a single 1x1 widget. Simply write a single query and get two numbers: it is easy, convenient and requires less time than creating separate queries for two individual widgets.

Simplified Funnel views

Released: 16/08/2023

Devtodev’s clients frequently create funnels to analyze various aspects of their apps and games. However, these funnels are often longer than a single screen, and the users find themselves having to scroll excessively, which can be quite inconvenient.

Space Overview update

Released: 25/07/2023

The overview provides essential metrics for all projects in Space, allowing users to conventionally track the metrics of the projects. Additionally, it offers the option to access the prepared reports in the selected project to analyze metric rises or falls. The overview aims to briefly introduce each project's key metrics and keep users informed about devtodev's news.

Customize Tutorial steps

Released: 18/07/2023

By tapping on the step in the report, you can assign a name that describes the action and facilitate seamless collaboration among all team members working on the app.

Basic metrics report: percentage share

Released: 27/06/2023

In our latest update we added distribution by parameter (Show % of total) across all the Basic metrics report tables. This feature proves particularly valuable when you need to determine the percentage of users with a specific attribute in relation to the total number of users in a particular group. It’s extremely convenient because you don’t need to waste time on creating separate SQL queries anymore!

Enhanced Retention report

Released: 20/06/2023

With this update, we’ve introduced two additional options for two calculation methods (by calendar days and by 24-hour interval):

• Flexible calculation start: you can now choose a specific event or several events that define a cohort for retention calculation, allowing for more tailored analysis..

• Custom calculation end: you have the freedom to select a particular event that signifies a user’s return to the product, enabling more precise measurement.

Updated Funnels: more events and Churned users segment

Released: 25/05/2023

This update got you two new features in the Funnel report (Reports -> Conversion funnel): an alternative event that you can use when building a funnel, and an option for creating a segment of users who failed to complete all the funnel steps.

Updated Virtual Goods & Purchases report

Released: 02/05/2023

What we did:

• Added display of item groups. The groups may come in handy in case you have too many items.

• Added breakdown by levels.

• Introduced a number of purchases divided by the DAU metric value (“% of active”, as in the Custom events report).

• Improved mean value. After the update, we calculate it as the number of items purchased at a level divided by the number of users.

Data labels in reports

Released: 17/04/2023

You can now activate Data labels on charts in Basic Metrics, Custom events or SQL reports. Use them to evaluate the dynamics and values in one glimpse.

Export Dashboards to PDF

Released: 04/04/2023

Sharing dashboards has never been so easy and convenient! devtodev already has a wide range of tools that make your work more smooth and unhindered, however, the export to pdf tool takes the process to the next level.

It’s an extremely convenient option for both senders and recipients. The senders can make sure that the recipients get only the data that they want to share with them in the exact form that they intended to show them. The recipients can get access to data without going through the whole process of signing up to the devtodev platform.

Funnels: limit by session, rename steps

Released: 07/03/2023

If you are curious about the number of users who achieve the ultimate goal during the first or the Nth session (first two, three, etc.), you can easily calculate them, build a segment and then analyze thoroughly. Simply click on ‘Conversion time limit’, set a sequential number of the session and build a funnel.

Now you can also rename funnel steps!

SDK Update: full complience with COPPA

Released: 16/02/2023

If you have a child-directed app or game, you may worry that the data you send to devtodev is anonymised and protected enough. It’s not a problem anymore with our updated SDK because it operates in full compliance with COPPA — the Children's Online Privacy Protection Act.

This updated version of devtodev SDK does not collect, process or store ad IDs of children. It simply creates anonymised user identification numbers that can be used by the platform for tracking underaged users without influencing the decisions they make.

If you already use devtodev SDK, all you need to do is to enable the COPPA-compliance opinion before SDK initialization and delete the dependencies necessary for processing ad and vendor IDs. This will not interfere with your working process because almost all devtodev reports will stay available and you will be able to use them as you did before.

New metric in A/B tests: CARPU

Released: 14/02/2023

We’ve added 1, 7, 14 and 30-day Cumulative ARPU to the A/B tests. You can use these metrics to improve the quality of the analysis and prove that the implemented changes did not influence other key metrics of the app.

User Flow: more session analysis options

Released: 17/01/2023

Drill down into your user flow data by setting a limit on the number of user sessions! This option comes in handy in case you want to take a closer look at what your users managed to achieve during, let’s say, their first session, and compare it with your expectations.

There are three options in this report - “No”, “Limit by first session”, and “Limit by number of sessions”. If you want to see events that users completed during their first session, choose the second option. If you want to see data for several sessions, choose the third option. In this case, the calculation is as follows: we take the specified number of sessions performed during the selected period, then we take the dates of the first and the last sessions, and after that we analyze the events performed during this period.

To begin working with analytics, you need to start sending events (information about user activity in the project) to the analytics system.

devtodev provides basic events that drive the majority of the reports.

Sessions

Users start with opening the app, and this process we call "starting a session". For your convenience, in the majority of devtodev SDKs this event is integrated automatically.

We use two events that we can use to examine the duration of the sessions. The first event captures the start date of a new session and the second captures the duration of each application activity (time when application is in focus). In our experience, this is the most reliable solution at the moment.

At the moment when application receives focus (this may be the moment the SDK is initialized / the application is opened / the device wakes up from the sleep mode with the focus on the application), we begin to assume that the application becomes active and begin to count the duration of the activity.

If the application loses focus (minimizing the application / device is going into the sleep mode / switching to another application / exiting the application), we consider that the activity is completed and we send its duration to the devtodev server. This is an application activity event.

Reports based on a Session event :

Real Payment

If users can use real money to make purchases in your project, you need to integrate the Payment event. When devtodev receives data about sessions and payments in your app, we can calculate all financial metrics (gross, revenue, average check) and metrics of the project’s financial efficiency (ARPU, ARPPU, paying share, LTV).

Reports based on a Payment event :

Subscriptions

If your application has subscriptions, you can integrate this event to analyze the financial data as well as the structure of your subscribers. Devtodev integrations allow you to receive information about subscription purchases even if the user doesn’t open the app (auto-renewable subscriptions).

Reports based on Subscription events:

Onboarding (tutorial)

Using this event you can evaluate the effectiveness of the tutorial steps system, analyze how users complete the tutorial, find bottlenecks, and measure the time it takes for users to complete the tutorial. The event should be sent at the end of each tutorial step indicating the number of completed steps as a parameter.

Here are some predefined values for the Tutorial Step event parameter:

• 0 - the user skipped the tutorial

• -1 - the user started the tutorial

• -2 - the user finished the tutorial

Reports based on a Tutorial Step event:

Custom Events

devtodev is a universal analytics system, and our structure of basic events is designed for game projects specifically. However, there may be situations when your project requires events that are not provided by the devtodev basic events. Such events can still be sent and analyzed in our system - as custom events.

Here are some examples of users' actions that can be sent as custom events: when users open an in-game store, click on items, buy items. Based on these events, you can build a funnel and see the conversion on each step.

Some limits for custom events:

1. The number of different event types sent from one project shouldn't exceed 300.

2. The event name must not exceed 72 characters.

3. One event can contain up to 20 parameters, which must have unique names of up to 32 symbols.

4. Parameters can be string and numeric: - the maximum length of parameter values is 255 characters; - the number of string parameter values cannot exceed 50 000; when it exceeds 50 000, the further sending of information about the parameter and possibilities to work with it will be blocked.

Here is some expert advice to avoid problems with limits in custom events:

• There is no need to send user IDs in parameters (they are collected by default).

• Do not send time in the timestamp format (it is also collected by default).

Reports based on Custom events:

LevelUp

You can analyze the distribution of the players over the levels. Many game projects have levels, which means that as users become more experienced, they gradually increase their level. In this case levels have a linear structure: the level N is followed by the level N+1. If your project has in-game currency, using the LevelUp event you can send information about the current amount of in-game currency players have. This data allows evaluating the average amount of in-game currency that players have on a particular level.

The event should be sent right after the player reaches the next level.

Reports based on a LevelUp event:

CurrencyAccrual

This specific event is a part of the LevelUp event and does not require a separate dispatch. Send this event to track the average amount of in-game currency earned or purchased during a level after each time an in-game account is replenished.

Reports based on a Currency Accrual event:

Progression Event

There are many projects (for example, Match-3 games), where players make an attempt to complete a level. Their attempts may be either successful or unsuccessful. In addition, during a certain attempt different numerical indicators can be changed: the number of stars, resources, in-game currency.

To analyze such attempts, devtodev provides a basic Progression event. In the Progression event you send information about how players pass a particular game location, whether their attempt is successful, and how numerical indicators change.

Report based on a Progression event:

Virtual Currency Payment

Many games, especially f2p, have in-game currency. Players can spend it on virtual goods. To work with virtual currency purchases, devtodev has developed the Virtual Currency Payment event.

Reports based on an In-App Purchase event:

Where to start

A tutorial is a very important part of any project because the first session lays the foundation for future retention and monetization indicators.

devtodev allows to analyze how users complete the tutorial, find bottlenecks, and measure the time it takes for users to complete the tutorial. These questions can be answered with the help of the Tutorial analysis report.

If users in your project become more experienced and raise their level

devtodev is an analytics system designed specifically for game projects. Many game projects have levels, which means that as users become more experienced, they gradually increase their level. In this case levels have a linear structure: the level N is followed by the level N+1.

When players move to the next level, you need to use the LevelUp event. All our reports, that are built by levels, are based on this event, e.g. Currency balances by level, Player levels, etc. Also, if your project has in-game currency, using the LevelUp event you can send information about the current amount of in-game currency players have. This data allows to evaluate the average amount of in-game currency that players have on a particular level.

For example, this is how the Player levels report looks like (see the pic below). It shows how users are distributed among levels, the percentage of users who remain on a particular level, the revenue of a particular level, etc.

If it is possible to pass / fail a level in your game

There are many projects (for example, Match-3 games), where players attempt to pass a level. Their attempts may be either successful or unsuccessful. In addition, during a certain attempt some numerical indicators can change: the number of stars, resources, in-game currency.

To analyze these attempts, we've created a basic Progression event. In the ProgressionEvent you send information about how players pass a particular game location, whether their attempt was successful, and how numerical indicators change.

Based on the ProgressionEvent, we build the Locations report, where all indicators are calculated by game locations, for successful and unsuccessful attempts.

If there is a virtual currency in your project

Many games, especially f2p, have in-game currency. Players can accumulate currency, or buy it for real money. They can then spend it on virtual goods. To work with virtual currency, devtodev has developed the following events:

• inAppPurchase – to send information about purchases made by players (please note that these are only purchases made with virtual currency, while information about purchases for real money is sent with the Payment event);

• currencyAccrual – to show information about movements of virtual currency (for example, if a player earns currency or receives it for some actions, you can use currencyAccrual to see this information).

All the game economy reports are based on these events.

With the help of the Currency Balances by Level tab in the Economy Balance report (this one also requires a LevelUp event), you can see how users spend, earn and accumulate currency on each game level.

The Top Purchases tab in the Economy Balance report allows you to analyze the structure of the consumer basket and identify items, which are the most popular among different categories of players.

devtodev is a universal analytics system with basic events structure designed specifically for game projects. However, there may be situations when your project requires events that are not provided by devtodev as basic. That's alright, such events can still be sent and analyzed in our system as custom events. It is possible to specify parameter values of custom events. Here are some examples of user actions that can be sent as custom events: when users open an in-game store, click on items, buy items. Based on these events, you can then build a funnel and see the conversion on each step.

Some limits for custom events:

1. The number of different event types sent from one project shouldn't exceed 300.

2. The event name must not exceed 72 characters.

3. One event can contain up to 20 parameters, each of them with unique names of up to 32 symbols.

4. Parameters can be string and numeric:

• the maximum length of parameter values is 255 characters;

• the number of string parameter values cannot exceed 50 000; when it exceeds 50 000, the further sending of information about the parameter and possibilities to work with it will be blocked;

Here is some expert advice to avoid problems with limits on custom events:

• there is no need to send user IDs in parameters (they are collected by default);

• do not send time in the timestamp format (it is also collected by default).

If you want to check transactions for validity

To exclude from statistics transactions made by cheaters, you can use devtodev Anti-cheat service. By using this method, you will be able to check payments for validity before sending them to devtodev. The verification process is the following:

1. When a user makes a transaction, the anti-cheat method must be called. The integration of this method is described in the documentation for a specific platform (the Anti-cheat methods section).

2. After this, the transaction will be checked for validity by devtodev.

3. If the transaction is not valid, the Payment event shouldn't be sent. If the transaction is valid, the Payment event should be sent and it will later get into statistics.

Manual installation

3. Add frameworks:

• AppTrackingTransparency.framework

• AdSupport.framework

4. Add initialization todidFinishLaunchingWithOptions method:

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

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:

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. 1. Remove AppTrackingTransparency.framework and all the links pointing to it.

   2. Remove AdSupport.framework all the links pointing to it.

Here you'll find the principles of processing data about real payments, tips for the integration of the Payment event and anti-cheat methods used in devtodev.

Payment event integration

Gross metrics are one of the key indicators of the app’s performance. Therefore, it is important to approach the integration of the Payment event very seriously.

There are four parameters that are sent in the Payment event:

1. Transaction identifier

2. Item name

3. Item price in payment currency

4. Payment currency identifier.

Let’s look at each of the parameters and things to keep in mind when specifying their values while integrating devtodev SDK.

Transaction identifier

This is one of the transaction parameters where invalid values occur most often.

Here are the requirements for this parameter:

1. The transaction identifier is a string value of max 64 symbols. In case this limit is exceeded the value will be shortened to 64 symbols.

2. The transaction identifier must be unique. Data about the transaction with already registered identifier will be discarded by the system and not included in statistics.

3. We recommend using the identifier that has been assigned to the transaction by the payment system as the transaction identifier.

4. In case your app is designed for Apple (iPhone, iPad, iPhone+iPad, or Mac) or Android (Google Play) platforms, the use of the transaction identifier assigned by the app store is mandatory! Transaction identifiers that come from apps on these platforms are checked by devtodev for their compliance with the format used by these markets. This allows us to discard the most obvious cheat transactions. It is also important to know that users who made these transactions are marked as cheaters and all their subsequent transactions are not included in statistics (you can disable this verification process by contacting our managers).

Item name

The item name is a string value that shouldn’t exceed 255 symbols. One of the most common mistakes when specifying the value of this parameter is specifying the localized name of the item in multi-language apps, which leads to the appearance of many records that describe the same item in different reports (for example, Purchases by level). One way to avoid this situation is to specify the name of the item bundle as its name.

Item price and currency identifier

The item price and currency identifier are related parameters, so it makes sense to describe them in one section. The item price parameter contains the sum that a user paid for the item in a payment currency. The price is specified as a floating-point number. The currency identifier parameter must specify the currency as a three-letter code according to ISO 4217 standard (examples: USD, EUR, JPY, CNY, RUB).

When the Payment event reaches devtodev servers, before transaction data is saved, the sum is automatically converted to USD at the actual currency rate at that moment.

If after converting to USD the sum exceeds $1500, the transaction is considered invalid and is not counted in statistics as well (this verification can be disabled by contacting our managers). When the transaction is made with an in-game currency of social network, you first need to convert this currency to any real-world currency.

It is also important to remember that the sum of the purchase sent in the Payment event shows the actual sum that the user paid (this data is used to built Gross metrics). In order to see your net income (Revenue metrics), on the page with app settings in devtodev, you need to specify the coefficient of the part that you get after subtracting the percentage that goes to the platform or publisher. The coefficient can be specified as single or individual for each country (this increases the accuracy in case the part of the sum is spent on taxes and fees that are individual for each country).

Payment validation

Unfortunately, in some situations filling in the parameters of the Payment event is not enough for getting valid data in reports, since there can be cheat transactions. There are several ways to deal with this problem, but all of them are based either on preliminary verification of the transaction or detection of suspicious user actions.

To prevent cheat transactions from getting into the report, you need to either check the transaction in advance and, if the transaction turns out to be invalid, omit sending the Payment event, or mark the user/device as a cheater and exclude their further data from all reports. It is possible to combine both methods for greater reliability.

One of the conditions for increasing the reliability of transaction verification is implementing it outside of the client app. You can create the system of verification and place it on your own servers or use our out-of-the-box solution - devtodev anti-cheat system.

devtodev anti-cheat allows to check the validity of transactions from the following app stores:

• iTunes

• Google Play Store

• Microsoft Store.

Validating App Store transactions

At the moment of transaction completion (for example, in the method - (void)paymentQueue:(SKPaymentQueue *) queue updatedTransactions:(NSArray *)

transactions at SKPaymentTransactionObserver class) call the method from the library devtodev.framework [DevToDevCheat verifyPaymentWithCompletion: (void (^)(ReceiptStatus status)) completion];

For example:

- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)transactions{
    for(SKPaymentTransaction *transaction in transactions){
        switch(transaction.transactionState){
            case SKPaymentTransactionStatePurchasing: 
                NSLog(@"Transaction state -> Purchasing");
                break;
            case SKPaymentTransactionStatePurchased:
                [DevToDevCheat verifyPaymentWithCompletion:^(ReceiptStatus status) {
                    switch (status) {
                        case ReceiptValid: 
                            NSLog(@"ReceiptValid"); 
                            break;
                        case ReceiptSandbox: 
                            NSLog(@"ReceiptSandbox"); 
                            break;
                        case ReceiptNotValid: 
                            NSLog(@"ReceiptNotValid"); 
                            break;
                        case ReceiptServerError: 
                            NSLog(@"ReceiptServerError"); 
                            break;
                        case ReceiptInternalError: 
                            NSLog(@"ReceiptInternalError"); 
                            break;
                    }
                }];
                [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
                NSLog(@"Transaction state -> Purchased");
                break;
            case SKPaymentTransactionStateRestored:
                NSLog(@"Transaction state -> Restored");
                [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
                break;
            case SKPaymentTransactionStateFailed:
                if(transaction.error.code == SKErrorPaymentCancelled){
                    NSLog(@"Transaction state -> Cancelled");
                }
                [[SKPaymentQueue defaultQueue] finishTransaction:transaction];
                break;
            case SKPaymentTransactionStateDeferred:
                break;
        }
    }
}

Validating Google Play transactions

To verify the transaction made in Google Play you need:

2. Application's public key for licensing

Here's how to find your application's public key for licensing:

2. In the application details page, locate the Services & APIs link and click on it.

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

The example of implementing transaction validation:

@Override
 protected void onActivityResult(int requestCode, int resultCode, Intent data) {
     if (requestCode == IN_APP_REQUEST_CODE) {
         String purchaseData = data.getStringExtra("INAPP_PURCHASE_DATA");
         String dataSignature = data.getStringExtra("INAPP_DATA_SIGNATURE");

         if (resultCode == RESULT_OK) {
            DevToDevCheat.verifyPayment(purchaseData, dataSignature, "APP_LICENSE_KEY", new OnVerifyListener() {
                @Override
                 public void onVerify(VerifyStatus verifyStatus) {
                     if (verifyStatus == VerifyStatus.Valid) {
                         //DevToDev.realPayment...
                     }
                 }
             });
         }
     }
 }```

Validating Microsoft Store transactions

PurchaseResults purchaseResult = await CurrentAppSimulator.RequestProductPurchaseAsync("some_product");

Cheat.VerifyReceipt(purchaseResult.ReceiptXml,
     (ReceiptVerificationStatus status) =>
     {
         if (status == ReceiptVerificationStatus.ReceiptValid)
         {
             // SDK.RealPayment ...
         }
     });

Recommended sequence of actions when working with transactions

1. Get response about a completed transaction from the payment system.

2. Either send data about the received transaction for verification by calling devtodev anti-cheat methods or use your own tools for transaction verification.

3. If the transaction has successfully passed verification, perform the Payment event.

4. If the transaction hasn’t passed verification, do not perform the Payment event and mark the user as a cheater.

CocoaPods

1. Firstly, install CocoaPods using:

2. In the project directory execute the command:

3. In the created Podfile add the dependency:

4. Finally, run the command 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

2. Add DTDAnalytics.xcframework to the project

3. Add frameworks:

• AppTrackingTransparency.framework

• AdSupport.framework

4. Add initialization todidFinishLaunchingWithOptions method:

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

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:

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. 1. Remove AppTrackingTransparency.framework and all the links pointing to it.

   2. Remove AdSupport.framework all the links pointing to it.

Privacy Manifest

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.

Then fill out the registration form.

You will receive an email to confirm your registration.

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:

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.

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

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.

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

Integration by importing unitypackage

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

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

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

Huawei

2. If you imported the DTDGoogle package, delete the imported files Assets\Plugins\DevToDev\Android\DTDGoogleAndroid.dll and Assets\DevToDev\Analytics\Editor\GoogleDependencies.xml
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. 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

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

Session measurement is an important metric for product analysis as it allows us to determine how frequently and for how long users interact with our website or application. However, it is important to note that session tracking methods on mobile and web applications have their own peculiarities. When a user starts a session in the application, the SDK recognizes that the application is active, indicating that it has gained focus (when the app is brought into the foreground). If the last recorded activity was more than 10 minutes ago, a Session Start event is sent.

Application activity refers to the period of time when the application is in focus, meaning the application or web page is open and the device screen is active. The focus is lost if the application goes into the background or if another website is opened in the current tab.

We measure the duration of application activity using a technical event called User Engagement (UE). It starts counting the time as soon as the application receives focus and sends the activity counter data to the server.

If, for any reason, the information about the duration of the activity couldn't be sent, it will be sent the next time the application is initialized and has internet access. However, the activity will only be included in devtodev reports if it has been less than 7 days since the session, as events from a previous period more than 7 days ago are ignored.

Thus, we have information about "Session start" and the duration of activity, but there is no specific "Session end" event. All events performed by the user are marked with the session start date in which they occurred (sessionid field in SQL tables)

For mobile applications, it is difficult to determine the beginning and end of a session because users often switch between screens of different applications. If an application on a mobile device receives focus and the last active time (in focus) was more than 10 minutes ago, a new session will be started and an event will be sent to devtodev.

For example, the user opens the application, spends a minute in it, and then puts the application in the background, a Session Start event will be sent to devtodev in the first second. After a minute, when the application goes into the background or is closed, an event with information about the duration of activity (UE) will be sent to the server as the focus is lost.

For web projects, it is not possible to detect when the user closes the page. Therefore, the UE event (duration of activity) is sent to the server every 2 minutes. To minimize the loss of information about the session duration to no more than two minutes in case of session termination, the SDK additionally saves the duration every 5 seconds and will send the information about the last duration upon the next activity. If there is no next session, the information about the last two minutes may be lost.

Let's consider an example where a user opens a webpage, spends 1.5 minutes on it, then opens another page on the site and spends another 1.5 minutes there. In devtodev, a Session Start event will be sent in the first second, and every 5 seconds, information about the activity will be saved. After 2 minutes from the start of the session, a UE event with 2 minutes of activity will be sent to the server, and after the third minute, the activity of 1 minute will be recorded in the Local Storage. Information about this activity will be sent during the next user session. The metric Average session length is calculated from the data obtained from session starts and user activity time during those sessions. It is defined as the sum of the length of all sessions divided by the number of sessions within a given period

In Basic Metrics, Engagement-> Sessions, and other reports, we encounter the following metrics:

Session duration: Shows the average session time of one user. It is calculated as (Total Sessions Length / Number of sessions) averaged by users Number of sessions: Shows the average number of sessions per user. It is calculated as the Number of sessions divided by the Number of users Total daily time spent: Represents the average total time per day spent in the user application. It is calculated as Total Sessions Length divided by the number of Active Users Sessions: Sessions by user shows the average number of sessions made by one user during the period Sessions by user: It shows the average number of sessions made by one user during the period

For the calculation of the necessary metrics:

• In the SQL wizard, there is a parameter called session.Duration, which is tracked by the UE event. The session.Duration parameter represents the duration of the activity, i.e., the time the application is in focus, and it is not equal to the session duration.

• sessions.Count is the number of Session Start received from the user

• Table .sessions has two types of eventtype field in SQL: ss: represents the Session Start event received from the user ue: represents the time that the application was in focus (active), providing information about time parameters and activity duration.

From this data, you can calculate the average session length by dividing the sum of activity lengths from all rows for the desired period by the sum of all session starts for the same period. We recommend using extended time periods to obtain a more reliable result.

Plugin installation

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

Example:

PublicDependencyModuleNames.Add("DTDAnalytics");

Data types

class UDTDAnalyticsLibrary

A class that implements analytic methods.

Header file:

#include "DTDAnalytics/Public/DTDAnalyticsBPLibrary.h"

class UDTDUserCardLibrary

A class that implements user card methods.

The class header:

#include "DTDAnalytics/Public/DTDUserCardBPLibrary.h"

enum class EDTDTrackingStatus : uint8

SDK tracking status.

Header file:

#include "DTDAnalytics/Public/DTDTrackingStatus.h"

Values:

• Unknown = 0 - leave tracking unchanged

• Enable = 1 - tracking enabled

• Disable = 2 - tracking disabled

Example:

EDTDTrackingStatus TrackingStatus = EDTDTrackingStatus::Enable;

enum class EDTDLogLevel : uint8

SDK logging level.

Header file:

#include "DTDAnalytics/Public/DTDLogLevel.h"

Values:

• Unknown = 0 - leave logging level unchanged

• No = 1 - logging disabled

• Error = 2 - logging of errors

• Warning = 3 - logging of warnings and errors

• Info = 4 - logging of information messages, warnings and errors

• Debug = 5 - logging of debugging messages, informational messages, warnings and errors

Example:

EDTDLogLevel LogLevel = EDTDLogLevel::Info;

enum class EDTDAccrualType : uint8

Types of resource accumulation.

Header file:

#include "DTDAnalytics/Public/DTDAccrualType.h"

Values:

• Earned = 0 - earned resources

• Bought = 1 - purchased resources

Example:

EDTDAccrualType AccrualType = EDTDAccrualType::Earned;

enum class EDTDSocialNetwork : uint8

Predefined social media.

Header file:

#include "DTDAnalytics/Public/DTDSocialNetwork.h"

Values:

• Facebook = 0

• Vkontakte = 1

• Twitter = 2

• Googleplus = 3

• Whatsapp = 4

• Viber = 5

• Evernote = 6

• Googlemail = 7

• Linkedin = 8

• Pinterest = 9

• Reddit = 10

• Renren = 11

• Tumblr = 12

• Qzone = 13

Example:

EDTDSocialNetwork SocialNetwork = EDTDSocialNetwork::Facebook;

enum class EDTDGender: uint8

User gender.

Header file:

#include "DTDAnalytics/Public/DTDGender.h"

Values:

• Unknown = 0

• Male = 1

• Female = 2

Example:

EDTDGender Gender = EDTDGender::Female;

enum class EDTDReferralProperty : uint8

Referral properties.

Header file:

#include "DTDAnalytics/Public/DTDReferralProperty.h"

Values:

• Source = 0

• Medium = 1

• Content = 2

• Campaign = 3

• Term = 4

Example:

EDTDReferralProperty ReferralProperty = EDTDReferralProperty::Source;

struct FDTDOptionalInt32

An optional parameter of int32 type

Header file:

#include "DTDAnalytics/Public/DTDOptionalInt32.h"

For your convenience, we implemented the conversion constructor:

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

Example:

FDTDOptionalInt32 OptionalParameter = 1;

struct FDTDOptionalString

An optional parameter of FString type.

Header file:

#include "DTDAnalytics/Public/DTDOptionalString.h

For your convenience, we implemented the conversion constructor:

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

Example:

FDTDOptionalString OptionalParameter = FString("StringValue");

struct FDTDAnalyticsConfiguration

Configuration of the analytics plugin.

Header file:

#include "DTDAnalytics/Public/DTDAnalyticsConfiguration.h"

Example:

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

FDTDCustomEventParams

Custom parameters of a custom event.

Header file:

#include "DTDAnalytics/Public/DTDCustomEventParams.h"

Example:

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

struct FDTDStartProgressionEventParams

Parameters of the progression start event.

Header file:

#include "DTDAnalytics/Public/DTDStartProgressionEventParams.h"

Example:

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

struct FDTDFinishProgressionEventParams

Parameters of the progression completion event.

Header file:

#include "DTDAnalytics/Public/DTDFinishProgressionEventParams.h"

Example:

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

Delegates

Header file:

#include "DTDAnalytics/Public/DTDDelegates.h"

Definitions:

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

SDK initialization

SDK initialization without parameters:

UDTDAnalyticsBPLibrary::Initialize("AppKey");

SDK initialization with parameters:

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

Integration Godot SDK

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

Requirements

The SDK module installation

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

SDK Initialization

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

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:

Project export

Export for MacOS

Open the Export Template Manager to download and install templates:

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

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:

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

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

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

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

After successful compilation execute the following commands:

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.

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

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

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

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