1 of 5

Setting up events

Secondary methods

Ad impression

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

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

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

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

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

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

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

Use the following constants to specify a social network:

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

Or create an object with the desired social media name.

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

Use the following constants to specify a social network:

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

Or create an object with the desired social media name.

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

Use the following constants to specify a social network:

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

Or create an object with the desired social media name.

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

Use the following constants to specify a social network:

Or create an object with the desired social media name:

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

Use the following constants to specify a social network:

Or create an object with the desired social media name:

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

window.devtodev.socialNetworkConnect('NetworkName')

UDTDAnalyticsBPLibrary::SocialNetworkConnect(EDTDSocialNetwork::Linkedin);

Or use special method for custom social network:

UDTDAnalyticsBPLibrary::SocialNetworkConnectCustom("SocialNetworkName");

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

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

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

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

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

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

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

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

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

Referrer

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

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

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

enum class DTDReferralProperty {
    Source,
    Campaign,
    Content,
    Medium,
    Term;
}
val referrer = mutableMapOf(
                DTDReferralProperty.Medium to "some value",
                DTDReferralProperty.Campaign to "some value"
               )
                    
DTDAnalytics.referrer(utmData: referrer)

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

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

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

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

Force dispatch of accumulated events

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

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

DTDAnalytics.sendBufferedEvents()

[DTDAnalytics sendBufferedEvents];

DTDAnalytics.sendBufferedEvents()

DTDAnalytics.SendBufferedEvents();

DTDAnalytics.SendBufferedEvents();

window.devtodev.sendBufferedEvents()

UDTDAnalyticsBPLibrary::SendBufferedEvents();

Setters & Getters

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

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

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

For example:

DispatchQueue.main.async{}

dispatch_async(dispatch_get_main_queue(), ^{ });

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

var result = await DTDAnalytics.GetUserId();

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

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

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

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

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

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

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

DTDAnalytics.setTrackingAvailability(value: true)

[DTDAnalytics trackingAvailability:true];

DTDAnalytics.setTrackingAvailability(value: true)

DTDAnalytics.SetTrackingAvailability(trackingValue: true);

DTDAnalytics.SetTrackingAvailability(trackingValue: true);

window.devtodev.setTrackingAvailability(true)

UDTDAnalyticsBPLibrary::SetTrackingAvailability(true);

Getting device ID

Get device ID. String type.

DTDAnalytics.getDeviceId { deviceId in
  // your code
}

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

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

var devideId = await DTDAnalytics.GetDeviceId();

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

var devideId = window.devtodev.getDeviceId()

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

Getting the devtodev SDK version

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

DTDAnalytics.getSDKVersion { sdkVersion in
  // your code
}

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

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

var sdkVersion = DTDAnalytics.GetSdkVersion();

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

var sdkVersion = window.devtodev.getSDKVersion()

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

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

DTDAnalytics.getTrackingAvailability { trackingAvailability in
  // your code
}

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

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

var trackingAvailability = await DTDAnalytics.GetTrackingAvailability();

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

var trackingAvailability = window.devtodev.getTrackingAvailability()

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

Getting devtodev ID

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

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

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

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

DTDAnalytics.setIdentifiersListener(listener: self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Anti-cheat methods

Payment Validation

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

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

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

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

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

                default:
                    break
            }
        }
    }
}

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

`DTDVerifyResponse`

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

`DTDReceiptStatus`

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

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

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

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

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

                            break;
                        }
                        case ReceiptStatusReceiptValid: {

                            break;
                        }
                        case ReceiptStatusReceiptSandbox: {

                            break;
                        }
                        case ReceiptStatusReceiptServerError: {

                            break;
                        }
                        case ReceiptStatusReceiptNotValid: {

                            break;
                        }
                    }
                }];
                break;
            }

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

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

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

`DTDVerifyResponse`

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

`DTDReceiptStatus`

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

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

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

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

`DTDVerifyResponse`

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

`DTDReceiptStatus`

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

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

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

Example of verification:

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

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

`DTDVerifyResponse`

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

`DTDReceiptStatus`

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

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

Google Play

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

Example:

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

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

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

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

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

App Store

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

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

Windows Store (UWP)

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

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

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

`DTDVerifyResponse`

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

`DTDReceiptStatus`

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

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

Secondary methods

Ad impression

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

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

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

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

Use the following constants to specify a social network:

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

Or create an object with the desired social media name.

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

Use the following constants to specify a social network:

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

Or create an object with the desired social media name.

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

Use the following constants to specify a social network:

Or create an object with the desired social media name.

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

Use the following constants to specify a social network:

Or create an object with the desired social media name:

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

Use the following constants to specify a social network:

Or create an object with the desired social media name:

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

window.devtodev.socialNetworkConnect('NetworkName')

UDTDAnalyticsBPLibrary::SocialNetworkConnect(EDTDSocialNetwork::Linkedin);

Or use special method for custom social network:

UDTDAnalyticsBPLibrary::SocialNetworkConnectCustom("SocialNetworkName");

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

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

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

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

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

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

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

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

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

Referrer

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

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

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

enum class DTDReferralProperty {
    Source,
    Campaign,
    Content,
    Medium,
    Term;
}
val referrer = mutableMapOf(
                DTDReferralProperty.Medium to "some value",
                DTDReferralProperty.Campaign to "some value"
               )
                    
DTDAnalytics.referrer(utmData: referrer)

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

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

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

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

Force dispatch of accumulated events

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

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

DTDAnalytics.sendBufferedEvents()

[DTDAnalytics sendBufferedEvents];

DTDAnalytics.sendBufferedEvents()

DTDAnalytics.SendBufferedEvents();

DTDAnalytics.SendBufferedEvents();

window.devtodev.sendBufferedEvents()

UDTDAnalyticsBPLibrary::SendBufferedEvents();

Setters & Getters

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

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

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

For example:

DispatchQueue.main.async{}

dispatch_async(dispatch_get_main_queue(), ^{ });

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

var result = await DTDAnalytics.GetUserId();

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

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

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

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

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

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

DTDAnalytics.setTrackingAvailability(value: true)

[DTDAnalytics trackingAvailability:true];

DTDAnalytics.setTrackingAvailability(value: true)

DTDAnalytics.SetTrackingAvailability(trackingValue: true);

DTDAnalytics.SetTrackingAvailability(trackingValue: true);

window.devtodev.setTrackingAvailability(true)

UDTDAnalyticsBPLibrary::SetTrackingAvailability(true);

Getting device ID

Get device ID. String type.

DTDAnalytics.getDeviceId { deviceId in
  // your code
}

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

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

var devideId = await DTDAnalytics.GetDeviceId();

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

var devideId = window.devtodev.getDeviceId()

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

Getting the devtodev SDK version

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

DTDAnalytics.getSDKVersion { sdkVersion in
  // your code
}

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

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

var sdkVersion = DTDAnalytics.GetSdkVersion();

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

var sdkVersion = window.devtodev.getSDKVersion()

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

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

DTDAnalytics.getTrackingAvailability { trackingAvailability in
  // your code
}

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

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

var trackingAvailability = await DTDAnalytics.GetTrackingAvailability();

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

var trackingAvailability = window.devtodev.getTrackingAvailability()

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

Getting devtodev ID

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

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

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

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

DTDAnalytics.setIdentifiersListener(listener: self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Basic methods

Tutorial

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

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

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

DTDAnalytics.tutorial(step: 1)

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

Value

Meaning

[DTDAnalytics tutorialStep:1];

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

Value

Meaning

DTDAnalytics.tutorial(1)

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

Value

Meaning

DTDAnalytics.Tutorial(1);

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

Value

Meaning

DTDAnalytics.Tutorial(1);

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

Value

Meaning

window.devtodev.tutorial(1)

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

Value

Meaning

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::Tutorial(1);

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

Value

Meaning

Level up

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

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

DTDAnalytics.levelUp(level: 2)

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

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

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

Parameter

Type

Restrictions

Description

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

[DTDAnalytics levelUp:2];

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

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

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

Parameter

Type

Restrictions

Description

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

DTDAnalytics.levelUp(2)

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

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

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

Parameter

Type

Restrictions

Description

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

DTDAnalytics.LevelUp(2);

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

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

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

Parameter

Type

Restrictions

Description

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

DTDAnalytics.LevelUp(level: 2)

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

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

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

Parameter

Type

Restrictions

Description

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

devtodev.levelUp(2)

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

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

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::LevelUp(2);

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

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

Parameter

Type

Restrictions

Description

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

Current Balance

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

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

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

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

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

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

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

Parameter

Type

Restrictions

Description

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

Currency Accrual

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

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

Parameter

Type

Restrictions

Description

acrualType can receive one of the following values:

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

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

Parameter

Type

Restrictions

Description

acrualType can receive one of the following values:

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

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

Parameter

Type

Restrictions

Description

accrualType can receive one of the following values:

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

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

Parameter

Type

Restrictions

Description

AccrualType can receive one of the following values:

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

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

Parameter

Type

Restrictions

Description

AccrualType can receive one of the following values:

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

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

Parameter

Type

Restrictions

Description

Example:

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

Parameter

Type

Restrictions

Description

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

Virtual Currency Payment

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

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

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

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

Parameter

Type

Restrictions

Description

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

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

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

Parameter

Type

Restrictions

Description

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

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

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

Parameter

Type

Restrictions

Description

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

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

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

Parameter

Type

Restrictions

Description

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

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

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

Parameter

Type

Restrictions

Description

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

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

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

Parameter

Type

Restrictions

Description

Parameter

Type

Restrictions

Description

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

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

Parameter

Type

Restrictions

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

Real Payment

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

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

How to find the transaction ID in GooglePlay transaction?

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

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

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

Parameter

Type

Restrictions

Description

Parameter

Type

Restrictions

Description

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

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

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

Subscriptions

The described method is available beginning with version 2.1.0!

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

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

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

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

For example:

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

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

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

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

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

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

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

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

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

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

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

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

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

For example:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Example:

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

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

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

How to find the transaction ID in GooglePlay transaction?

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

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

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

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

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

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

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

Example:

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

Download and import the DTDSubscriptions package to your app.

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

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

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

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

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

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

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

Example:

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

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

Example:

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

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

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

Below you can see an example of the entire script:

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

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

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

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

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

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

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

Custom Events

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

DTDAnalytics.customEvent(eventName: "Event name")

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

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

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

Parameter

Type

Restrictions

Description

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

Type

Restrictions

[DTDAnalytics customEvent:@"Event name"];

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

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

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

Parameter

Type

Restrictions

Description

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

Type

Restrictions

DTDAnalytics.customEvent(eventName: "Event name")

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

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

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

Parameter

Type

Restrictions

Description

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

Type

Restrictions

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

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

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

Parameter

Type

Restrictions

Description

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

Type

Restrictions

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

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

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

Parameter

Type

Restrictions

Description

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

Type

Restrictions

window.devtodev.customEvent(eventName, parameters)

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

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

Parameter

Type

Restrictions

Description

The following data types can be passed using parameters object:

Type

Restrictions

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::CustomEvent("EventName");

If you want to pass custom parameters, use:

Parameter

Type

Restrictions

Description

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

Type

Restrictions

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

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

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

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

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

Progression event

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

There are two methods in working with progression event:

startProgressionEvent
finishProgressionEvent

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

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

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

Parameter

Type

Restrictions

Description

DTDStartProgressionEventParameters:

Parameter

Type

Restrictions

Description

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

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

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

Parameter

Type

Restrictions

Description

DTDFinishProgressionEventParameters:

Parameter

Type

Restrictions

Description

There are two methods in working with progression event:

startProgressionEvent
finishProgressionEvent

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

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

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

Parameter

Type

Restrictions

Description

DTDStartProgressionEventParameters:

Parameter

Type

Restrictions

Description

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

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

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

Parameter

Type

Restrictions

Description

DTDFinishProgressionEventParameters:

Parameter

Type

Restrictions

Description

There are two methods in working with progression event:

startProgressionEvent
finishProgressionEvent

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

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

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

Parameter

Type

Restrictions

Description

DTDStartProgressionEventParameters:

Parameter

Type

Restrictions

Description

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

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

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

Parameter

Type

Restrictions

Description

DTDFinishProgressionEventParameters:

Parameter

Type

Restrictions

Description

There are two methods in working with progression event:

StartProgressionEvent
FinishProgressionEvent

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

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

Parameter

Type

Restrictions

Description

DTDStartProgressionEventParameters:

Parameter

Type

Restrictions

Description

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

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

Parameter

Type

Restrictions

Description

DTDFinishProgressionEventParameters:

Parameter

Type

Restrictions

Description

There are two methods in working with progression event:

StartProgressionEvent
FinishProgressionEvent

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

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

Parameter

Type

Restrictions

Description

DTDStartProgressionEventParameters:

Parameter

Type

Restrictions

Description

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

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

Parameter

Type

Restrictions

Description

DTDFinishProgressionEventParameters:

Parameter

Type

Restrictions

Description

There are two methods in working with progression event:

startProgressionEvent
finishProgressionEvent

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

window.devtodev.startProgressionEvent(eventName, parameters)

Parameter

Type

Restrictions

Description

startProgressionEvent event parameters:

Parameter

Type

Restrictions

Description

Example:

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

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

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

Parameter

Type

Restrictions

Description

startProgressionEvent event parameters:

Parameter

Type

Restrictions

Description

Example:

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

There are two methods in working with progression event:

startProgressionEvent
finishProgressionEvent

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

Parameter

Type

Restrictions

Description

UDTDAnalyticsBPLibrary::StartProgressionEvent("EventName");

Start progression event with parameters:

Parameter

Type

Restrictions

Description

FDTDStartProgressionEventParams:

Parameter

Type

Restrictions

Description

Example:

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

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

Parameter

Type

Restrictions

Description

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

Finish progression event with parameters:

Parameter

Type

Restrictions

Description

FDTDFinishProgressionEventParameters:TMap<FString, int64>

Parameter

Type

Restrictions

Description

Example:

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

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

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

User profile

User ID

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

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

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

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

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

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

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

DTDAnalytics.getUserId { userId in
  // your code
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var userId = await DTDAnalytics.GetUserId();

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

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

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

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

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

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

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

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

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

var userId = window.devtodev.getUserId()

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

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

Arguments

Type

Description

UDTDAnalyticsBPLibrary::SetUserId("Name");

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

Arguments

Type

Description

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

Replace

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

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

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

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

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

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

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

Arguments

Type

Description

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

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

Current user level

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

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

DTDAnalytics.setCurrentLevel(value: 2)

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

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

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

DTDAnalytics.getCurrentLevel { level in
  // your code
}

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

[DTDAnalytics currentLevel:2];

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

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

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

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

DTDAnalytics.setCurrentLevel(value: 2)

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

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

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

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

DTDAnalytics.SetCurrentLevel(level: 3);

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

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

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

var currentLevel = await DTDAnalytics.GetCurrentLevel();

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

DTDAnalytics.SetCurrentLevel(level: 3);

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

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

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

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

window.devtodev.setCurrentLevel(2)

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

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

var currentLevel = window.devtodev.getCurrentLevel()

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

Arguments

Type

Description

UDTDAnalyticsBPLibrary::SetCurrentLevel(7);

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

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

Arguments

Type

Description

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

Cheater

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

DTDUserCard.setCheater(cheater: true)

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

DTDUserCard.getCheater { isCheater in
  // your code
}

[DTDUserCard setCheater:true];

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

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

DTDUserCard.setCheater(cheater: true)

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

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

DTDUserCard.SetCheater(cheater: true);

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

var isCheater = await DTDUserCard.GetCheater();

DTDUserCard.SetCheater(cheater: true);

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

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

window.devtodev.user.setCheater(true)

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

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

Arguments

Type

Description

UDTDUserCardBPLibrary::SetCheater(true);

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

Arguments

Type

Description

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

Reserved user properties

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

Property

Setter

Getter

Example:

UDTDUserCardBPLibrary::SetEmail("Email");

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

Custom user property

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Arguments

Type

Description

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

Arguments

Type

Description

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

Arguments

Type

Description

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

Arguments

Type

Description

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

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

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

Arguments

Type

Description

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

Arguments

Type

Description

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

Arguments

Type

Description

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

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

Unset user property

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

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

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

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

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

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

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

UDTDUserCardBPLibrary::Unset("Key");

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

Unset all user properties

To remove all properties from the user card, use:

DTDUserCard.clearUser()

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

[DTDUserCard clearUser];

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

DTDUserCard.clearUser()

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

DTDUserCard.ClearUser();

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

DTDUserCard.ClearUser();

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

window.devtodev.user.clearUser()

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

UDTDUserCardBPLibrary::ClearUser();

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

Setting up events

Secondary methods

Ad impression

Connecting to social networks

Posting to social networks

Referrer

Force dispatch of accumulated events

Setters & Getters

Setting User Tracking Status (GDPR)

Getting device ID

Getting the devtodev SDK version

Obtaining user tracking status (GDPR)

Getting devtodev ID

Anti-cheat methods

Payment Validation

DTDVerifyResponse

DTDReceiptStatus

DTDVerifyResponse

DTDReceiptStatus

DTDVerifyResponse

DTDReceiptStatus

DTDVerifyResponse

DTDReceiptStatus

Google Play

App Store

Windows Store (UWP)

DTDVerifyResponse

DTDReceiptStatus

Anti-cheat methods

Payment Validation

DTDVerifyResponse

DTDReceiptStatus

DTDVerifyResponse

DTDReceiptStatus

DTDVerifyResponse

DTDReceiptStatus

DTDVerifyResponse

DTDReceiptStatus

Google Play

App Store

Windows Store (UWP)

DTDVerifyResponse

DTDReceiptStatus

Secondary methods

Ad impression

Connecting to social networks

Posting to social networks

Referrer

Force dispatch of accumulated events

Setters & Getters

Setting User Tracking Status (GDPR)

Getting device ID

Getting the devtodev SDK version

Obtaining user tracking status (GDPR)

Getting devtodev ID

Basic methods

Tutorial

Level up

Current Balance

Currency Accrual

Virtual Currency Payment

Real Payment

Subscriptions

Custom Events

Progression event

User profile

User ID

Replace

Current user level

Cheater

Reserved user properties

Custom user property

Unset user property

Unset all user properties

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`

`DTDVerifyResponse`

`DTDReceiptStatus`