SDK_UnityMoney/Assets/rd3/Adjust/Scripts/AdjustAndroid.cs

1439 lines
60 KiB
C#

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using UnityEngine;
namespace AdjustSdk
{
#if UNITY_ANDROID
public class AdjustAndroid
{
private const string sdkPrefix = "unity5.4.2";
private static bool isDeferredDeeplinkOpeningEnabled = true;
private static AndroidJavaClass ajcAdjust = new AndroidJavaClass("com.adjust.sdk.Adjust");
private static AndroidJavaObject ajoCurrentActivity = new AndroidJavaClass("com.unity3d.player.UnityPlayer").GetStatic<AndroidJavaObject>("currentActivity");
private static DeferredDeeplinkListener onDeferredDeeplinkListener;
private static AttributionChangedListener onAttributionChangedListener;
private static EventTrackingFailedListener onEventTrackingFailedListener;
private static EventTrackingSucceededListener onEventTrackingSucceededListener;
private static SessionTrackingFailedListener onSessionTrackingFailedListener;
private static SessionTrackingSucceededListener onSessionTrackingSucceededListener;
private static DeeplinkResolutionListener onDeeplinkResolvedListener;
public static void InitSdk(AdjustConfig adjustConfig)
{
// thank you, Unity 2019.2.0, for breaking this
// AndroidJavaObject ajoEnvironment = adjustConfig.environment == AdjustEnvironment.Sandbox ?
// new AndroidJavaClass("com.adjust.sdk.AdjustConfig").GetStatic<AndroidJavaObject>("ENVIRONMENT_SANDBOX") :
// new AndroidJavaClass("com.adjust.sdk.AdjustConfig").GetStatic<AndroidJavaObject>("ENVIRONMENT_PRODUCTION");
// get environment variable
string environment = adjustConfig.Environment == AdjustEnvironment.Production ? "production" : "sandbox";
using (AndroidJavaObject ajoAdjustConfig = adjustConfig.AllowSuppressLogLevel != null ?
new AndroidJavaObject("com.adjust.sdk.AdjustConfig", ajoCurrentActivity, adjustConfig.AppToken, environment, adjustConfig.AllowSuppressLogLevel) :
new AndroidJavaObject("com.adjust.sdk.AdjustConfig", ajoCurrentActivity, adjustConfig.AppToken, environment))
{
// check if deferred deeplink should be launched by the SDK
if (adjustConfig.IsDeferredDeeplinkOpeningEnabled != null)
{
isDeferredDeeplinkOpeningEnabled = (bool)adjustConfig.IsDeferredDeeplinkOpeningEnabled;
}
// check log level
if (adjustConfig.LogLevel != null)
{
AndroidJavaObject ajoLogLevel;
if (adjustConfig.LogLevel.Value.ToUppercaseString().Equals("SUPPRESS"))
{
ajoLogLevel = new AndroidJavaClass("com.adjust.sdk.LogLevel").GetStatic<AndroidJavaObject>("SUPPRESS");
}
else
{
ajoLogLevel = new AndroidJavaClass("com.adjust.sdk.LogLevel").GetStatic<AndroidJavaObject>(adjustConfig.LogLevel.Value.ToUppercaseString());
}
if (ajoLogLevel != null)
{
ajoAdjustConfig.Call("setLogLevel", ajoLogLevel);
}
}
// set Unity SDK prefix
ajoAdjustConfig.Call("setSdkPrefix", sdkPrefix);
// check read device IDs only once
if (adjustConfig.IsDeviceIdsReadingOnceEnabled != null)
{
if (adjustConfig.IsDeviceIdsReadingOnceEnabled == true)
{
ajoAdjustConfig.Call("enableDeviceIdsReadingOnce");
}
}
// check if COPPA compliance is enabled
if (adjustConfig.IsCoppaComplianceEnabled != null)
{
if (adjustConfig.IsCoppaComplianceEnabled == true)
{
ajoAdjustConfig.Call("enableCoppaCompliance");
}
}
// check if Play Store Kids compliance is enabled
if (adjustConfig.IsPlayStoreKidsComplianceEnabled != null)
{
if (adjustConfig.IsPlayStoreKidsComplianceEnabled == true)
{
ajoAdjustConfig.Call("enablePlayStoreKidsCompliance");
}
}
// check if user enabled sening in the background
if (adjustConfig.IsSendingInBackgroundEnabled != null)
{
if (adjustConfig.IsSendingInBackgroundEnabled == true)
{
ajoAdjustConfig.Call("enableSendingInBackground");
}
}
// check if user wants to get cost data in attribution callback
if (adjustConfig.IsCostDataInAttributionEnabled != null)
{
if (adjustConfig.IsCostDataInAttributionEnabled == true)
{
ajoAdjustConfig.Call("enableCostDataInAttribution");
}
}
// check if user wants to run preinstall campaigns
if (adjustConfig.IsPreinstallTrackingEnabled != null)
{
if (adjustConfig.IsPreinstallTrackingEnabled == true)
{
ajoAdjustConfig.Call("enablePreinstallTracking");
}
}
// check if first session delay has been enabled
if (adjustConfig.IsFirstSessionDelayEnabled != null)
{
if (adjustConfig.IsFirstSessionDelayEnabled == true)
{
ajoAdjustConfig.Call("enableFirstSessionDelay");
}
}
// check if user has set custom preinstall file path
if (adjustConfig.PreinstallFilePath != null)
{
ajoAdjustConfig.Call("setPreinstallFilePath", adjustConfig.PreinstallFilePath);
}
// check if FB app ID has been set
if (adjustConfig.FbAppId != null)
{
ajoAdjustConfig.Call("setFbAppId", adjustConfig.FbAppId);
}
// check if user has set default tracker token
if (adjustConfig.DefaultTracker != null)
{
ajoAdjustConfig.Call("setDefaultTracker", adjustConfig.DefaultTracker);
}
// check if user has set external device identifier
if (adjustConfig.ExternalDeviceId != null)
{
ajoAdjustConfig.Call("setExternalDeviceId", adjustConfig.ExternalDeviceId);
}
// check if user has set max number of event deduplication IDs
if (adjustConfig.EventDeduplicationIdsMaxSize != null)
{
using (AndroidJavaObject ajoEventDeduplicationIdsMaxSize = new AndroidJavaObject("java.lang.Integer", adjustConfig.EventDeduplicationIdsMaxSize))
{
ajoAdjustConfig.Call("setEventDeduplicationIdsMaxSize", ajoEventDeduplicationIdsMaxSize);
}
}
// check if user has set custom URL strategy
if (adjustConfig.UrlStrategyDomains != null &&
adjustConfig.ShouldUseSubdomains != null &&
adjustConfig.IsDataResidency != null)
{
using (var ajoUrlStrategyDomains = new AndroidJavaObject("java.util.ArrayList"))
{
foreach (string domain in adjustConfig.UrlStrategyDomains)
{
ajoUrlStrategyDomains.Call<bool>("add", domain);
}
ajoAdjustConfig.Call("setUrlStrategy",
ajoUrlStrategyDomains,
adjustConfig.ShouldUseSubdomains,
adjustConfig.IsDataResidency);
}
}
// check if custom store info has been set
if (adjustConfig.StoreInfo != null)
{
if (adjustConfig.StoreInfo.StoreName != null)
{
using (AndroidJavaObject ajoAdjustStoreInfo =
new AndroidJavaObject("com.adjust.sdk.AdjustStoreInfo", adjustConfig.StoreInfo.StoreName))
{
if (adjustConfig.StoreInfo.StoreAppId != null)
{
ajoAdjustStoreInfo.Call("setStoreAppId", adjustConfig.StoreInfo.StoreAppId);
}
ajoAdjustConfig.Call("setStoreInfo", ajoAdjustStoreInfo);
}
}
}
// check attribution changed delagate
if (adjustConfig.AttributionChangedDelegate != null)
{
onAttributionChangedListener = new AttributionChangedListener(adjustConfig.AttributionChangedDelegate);
ajoAdjustConfig.Call("setOnAttributionChangedListener", onAttributionChangedListener);
}
// check event success delegate
if (adjustConfig.EventSuccessDelegate != null)
{
onEventTrackingSucceededListener = new EventTrackingSucceededListener(adjustConfig.EventSuccessDelegate);
ajoAdjustConfig.Call("setOnEventTrackingSucceededListener", onEventTrackingSucceededListener);
}
// check event failure delagate
if (adjustConfig.EventFailureDelegate != null)
{
onEventTrackingFailedListener = new EventTrackingFailedListener(adjustConfig.EventFailureDelegate);
ajoAdjustConfig.Call("setOnEventTrackingFailedListener", onEventTrackingFailedListener);
}
// check session success delegate
if (adjustConfig.SessionSuccessDelegate != null)
{
onSessionTrackingSucceededListener = new SessionTrackingSucceededListener(adjustConfig.SessionSuccessDelegate);
ajoAdjustConfig.Call("setOnSessionTrackingSucceededListener", onSessionTrackingSucceededListener);
}
// check session failure delegate
if (adjustConfig.SessionFailureDelegate != null)
{
onSessionTrackingFailedListener = new SessionTrackingFailedListener(adjustConfig.SessionFailureDelegate);
ajoAdjustConfig.Call("setOnSessionTrackingFailedListener", onSessionTrackingFailedListener);
}
// check deferred deeplink delegate
if (adjustConfig.DeferredDeeplinkDelegate != null)
{
onDeferredDeeplinkListener = new DeferredDeeplinkListener(adjustConfig.DeferredDeeplinkDelegate);
ajoAdjustConfig.Call("setOnDeferredDeeplinkResponseListener", onDeferredDeeplinkListener);
}
// initialise and start the SDK
ajcAdjust.CallStatic("initSdk", ajoAdjustConfig);
}
}
public static void TrackEvent(AdjustEvent adjustEvent)
{
using (AndroidJavaObject ajoAdjustEvent =
new AndroidJavaObject("com.adjust.sdk.AdjustEvent", adjustEvent.EventToken))
{
// check if user has set revenue for the event
if (adjustEvent.Revenue != null)
{
ajoAdjustEvent.Call("setRevenue", (double)adjustEvent.Revenue, adjustEvent.Currency);
}
// check if user has added any callback parameters to the event
if (adjustEvent.CallbackParameters != null)
{
for (int i = 0; i < adjustEvent.CallbackParameters.Count; i += 2)
{
string key = adjustEvent.CallbackParameters[i];
string value = adjustEvent.CallbackParameters[i + 1];
ajoAdjustEvent.Call("addCallbackParameter", key, value);
}
}
// check if user has added any partner parameters to the event
if (adjustEvent.PartnerParameters != null)
{
for (int i = 0; i < adjustEvent.PartnerParameters.Count; i += 2)
{
string key = adjustEvent.PartnerParameters[i];
string value = adjustEvent.PartnerParameters[i + 1];
ajoAdjustEvent.Call("addPartnerParameter", key, value);
}
}
// check if user has set deduplication ID for the event
if (adjustEvent.DeduplicationId != null)
{
ajoAdjustEvent.Call("setDeduplicationId", adjustEvent.DeduplicationId);
}
// check if user has added callback ID to the event
if (adjustEvent.CallbackId != null)
{
ajoAdjustEvent.Call("setCallbackId", adjustEvent.CallbackId);
}
// check if user has added product ID to the event
if (adjustEvent.ProductId != null)
{
ajoAdjustEvent.Call("setProductId", adjustEvent.ProductId);
}
// check if user has added purchase token to the event
if (adjustEvent.PurchaseToken != null)
{
ajoAdjustEvent.Call("setPurchaseToken", adjustEvent.PurchaseToken);
}
// track the event
ajcAdjust.CallStatic("trackEvent", ajoAdjustEvent);
}
}
public static void Enable()
{
ajcAdjust.CallStatic("enable");
}
public static void Disable()
{
ajcAdjust.CallStatic("disable");
}
public static void SwitchToOfflineMode()
{
ajcAdjust.CallStatic("switchToOfflineMode");
}
public static void SwitchBackToOnlineMode()
{
ajcAdjust.CallStatic("switchBackToOnlineMode");
}
public static void EnableCoppaCompliance()
{
ajcAdjust.CallStatic("enableCoppaCompliance", ajoCurrentActivity);
}
public static void DisableCoppaCompliance()
{
ajcAdjust.CallStatic("disableCoppaCompliance", ajoCurrentActivity);
}
public static void EnablePlayStoreKidsApp()
{
ajcAdjust.CallStatic("enablePlayStoreKidsApp", ajoCurrentActivity);
}
public static void DisablePlayStoreKidsApp()
{
ajcAdjust.CallStatic("disablePlayStoreKidsApp", ajoCurrentActivity);
}
public static void SetPushToken(string pushToken)
{
ajcAdjust.CallStatic("setPushToken", pushToken, ajoCurrentActivity);
}
public static void GdprForgetMe()
{
ajcAdjust.CallStatic("gdprForgetMe", ajoCurrentActivity);
}
public static void AddGlobalPartnerParameter(string key, string value)
{
if (ajcAdjust == null)
{
ajcAdjust = new AndroidJavaClass("com.adjust.sdk.Adjust");
}
ajcAdjust.CallStatic("addGlobalPartnerParameter", key, value);
}
public static void AddGlobalCallbackParameter(string key, string value)
{
if (ajcAdjust == null)
{
ajcAdjust = new AndroidJavaClass("com.adjust.sdk.Adjust");
}
ajcAdjust.CallStatic("addGlobalCallbackParameter", key, value);
}
public static void RemoveGlobalPartnerParameter(string key)
{
if (ajcAdjust == null)
{
ajcAdjust = new AndroidJavaClass("com.adjust.sdk.Adjust");
}
ajcAdjust.CallStatic("removeGlobalPartnerParameter", key);
}
public static void RemoveGlobalCallbackParameter(string key)
{
if (ajcAdjust == null)
{
ajcAdjust = new AndroidJavaClass("com.adjust.sdk.Adjust");
}
ajcAdjust.CallStatic("removeGlobalCallbackParameter", key);
}
public static void RemoveGlobalPartnerParameters()
{
if (ajcAdjust == null)
{
ajcAdjust = new AndroidJavaClass("com.adjust.sdk.Adjust");
}
ajcAdjust.CallStatic("removeGlobalPartnerParameters");
}
public static void RemoveGlobalCallbackParameters()
{
if (ajcAdjust == null)
{
ajcAdjust = new AndroidJavaClass("com.adjust.sdk.Adjust");
}
ajcAdjust.CallStatic("removeGlobalCallbackParameters");
}
public static void ProcessDeeplink(AdjustDeeplink deeplink)
{
using (AndroidJavaClass ajcUri = new AndroidJavaClass("android.net.Uri"))
using (AndroidJavaObject ajoUri = ajcUri.CallStatic<AndroidJavaObject>("parse", deeplink.Deeplink))
using (AndroidJavaObject ajoAdjustDeeplink = new AndroidJavaObject("com.adjust.sdk.AdjustDeeplink", ajoUri))
{
if (deeplink.Referrer != null)
{
using (AndroidJavaObject ajoReferrer = ajcUri.CallStatic<AndroidJavaObject>("parse", deeplink.Referrer))
{
ajoAdjustDeeplink.Call("setReferrer", ajoReferrer);
}
}
ajcAdjust.CallStatic("processDeeplink", ajoAdjustDeeplink, ajoCurrentActivity);
}
}
public static void TrackAdRevenue(AdjustAdRevenue adRevenue)
{
using (AndroidJavaObject ajoAdjustAdRevenue =
new AndroidJavaObject("com.adjust.sdk.AdjustAdRevenue", adRevenue.Source))
{
// check if user has set revenue
if (adRevenue.Revenue != null)
{
using (AndroidJavaObject ajoRevenue = new AndroidJavaObject("java.lang.Double", adRevenue.Revenue))
{
ajoAdjustAdRevenue.Call("setRevenue", ajoRevenue, adRevenue.Currency);
}
}
// check if user has set ad impressions count
if (adRevenue.AdImpressionsCount != null)
{
using (AndroidJavaObject ajoAdImpressionsCount =
new AndroidJavaObject("java.lang.Integer", adRevenue.AdImpressionsCount))
{
ajoAdjustAdRevenue.Call("setAdImpressionsCount", ajoAdImpressionsCount);
}
}
// check if user has set ad revenue network
if (adRevenue.AdRevenueNetwork != null)
{
ajoAdjustAdRevenue.Call("setAdRevenueNetwork", adRevenue.AdRevenueNetwork);
}
// check if user has set ad revenue unit
if (adRevenue.AdRevenueUnit != null)
{
ajoAdjustAdRevenue.Call("setAdRevenueUnit", adRevenue.AdRevenueUnit);
}
// check if user has set ad revenue placement
if (adRevenue.AdRevenuePlacement != null)
{
ajoAdjustAdRevenue.Call("setAdRevenuePlacement", adRevenue.AdRevenuePlacement);
}
// check if user has added any callback parameters
if (adRevenue.CallbackParameters != null)
{
for (int i = 0; i < adRevenue.CallbackParameters.Count; i += 2)
{
string key = adRevenue.CallbackParameters[i];
string value = adRevenue.CallbackParameters[i + 1];
ajoAdjustAdRevenue.Call("addCallbackParameter", key, value);
}
}
// check if user has added any partner parameters
if (adRevenue.PartnerParameters != null)
{
for (int i = 0; i < adRevenue.PartnerParameters.Count; i += 2)
{
string key = adRevenue.PartnerParameters[i];
string value = adRevenue.PartnerParameters[i + 1];
ajoAdjustAdRevenue.Call("addPartnerParameter", key, value);
}
}
// track ad revenue
ajcAdjust.CallStatic("trackAdRevenue", ajoAdjustAdRevenue);
}
}
public static void TrackPlayStoreSubscription(AdjustPlayStoreSubscription subscription)
{
using (AndroidJavaObject ajoSubscription = new AndroidJavaObject(
"com.adjust.sdk.AdjustPlayStoreSubscription",
Convert.ToInt64(subscription.Price),
subscription.Currency,
subscription.ProductId,
subscription.OrderId,
subscription.Signature,
subscription.PurchaseToken))
{
// check if user has set purchase time for subscription
if (subscription.PurchaseTime != null)
{
ajoSubscription.Call("setPurchaseTime", Convert.ToInt64(subscription.PurchaseTime));
}
// check if user has added any callback parameters to the subscription
if (subscription.CallbackParameters != null)
{
for (int i = 0; i < subscription.CallbackParameters.Count; i += 2)
{
string key = subscription.CallbackParameters[i];
string value = subscription.CallbackParameters[i + 1];
ajoSubscription.Call("addCallbackParameter", key, value);
}
}
// check if user has added any partner parameters to the subscription
if (subscription.PartnerParameters != null)
{
for (int i = 0; i < subscription.PartnerParameters.Count; i += 2)
{
string key = subscription.PartnerParameters[i];
string value = subscription.PartnerParameters[i + 1];
ajoSubscription.Call("addPartnerParameter", key, value);
}
}
// track the subscription
ajcAdjust.CallStatic("trackPlayStoreSubscription", ajoSubscription);
}
}
public static void TrackThirdPartySharing(AdjustThirdPartySharing thirdPartySharing)
{
using (var ajoAdjustThirdPartySharing =
thirdPartySharing.IsEnabled != null
? new AndroidJavaObject("com.adjust.sdk.AdjustThirdPartySharing",
new AndroidJavaObject("java.lang.Boolean", thirdPartySharing.IsEnabled.Value))
: new AndroidJavaObject("com.adjust.sdk.AdjustThirdPartySharing", (object)null))
{
if (thirdPartySharing.GranularOptions != null)
{
for (int i = 0; i < thirdPartySharing.GranularOptions.Count;)
{
string partnerName = thirdPartySharing.GranularOptions[i++];
string key = thirdPartySharing.GranularOptions[i++];
string value = thirdPartySharing.GranularOptions[i++];
ajoAdjustThirdPartySharing.Call("addGranularOption", partnerName, key, value);
}
}
if (thirdPartySharing.PartnerSharingSettings != null)
{
for (int i = 0; i < thirdPartySharing.PartnerSharingSettings.Count;)
{
string partnerName = thirdPartySharing.PartnerSharingSettings[i++];
string key = thirdPartySharing.PartnerSharingSettings[i++];
string value = thirdPartySharing.PartnerSharingSettings[i++];
ajoAdjustThirdPartySharing.Call("addPartnerSharingSetting", partnerName, key, bool.Parse(value));
}
}
ajcAdjust.CallStatic("trackThirdPartySharing", ajoAdjustThirdPartySharing);
}
}
public static void TrackMeasurementConsent(bool measurementConsent)
{
ajcAdjust.CallStatic("trackMeasurementConsent", measurementConsent);
}
public static void IsEnabled(Action<bool> onIsEnabled)
{
IsEnabledListener isEnabledProxy = new IsEnabledListener(onIsEnabled);
ajcAdjust.CallStatic("isEnabled", ajoCurrentActivity, isEnabledProxy);
}
public static void GetAdid(Action<string> onAdidRead)
{
AdidReadListener onAdidReadProxy = new AdidReadListener(onAdidRead);
ajcAdjust.CallStatic("getAdid", onAdidReadProxy);
}
public static void GetAttribution(Action<AdjustAttribution> onAttributionRead)
{
AttributionReadListener onAttributionReadProxy = new AttributionReadListener(onAttributionRead);
ajcAdjust.CallStatic("getAttribution", onAttributionReadProxy);
}
public static void GetSdkVersion(Action<string> onSdkVersionRead)
{
SdkVersionReadListener onSdkVersionReadProxy = new SdkVersionReadListener(onSdkVersionRead, sdkPrefix);
ajcAdjust.CallStatic("getSdkVersion", onSdkVersionReadProxy);
}
public static void GetLastDeeplink(Action<string> onLastDeeplinkRead)
{
LastDeeplinkListener onLastDeeplinkReadProxy = new LastDeeplinkListener(onLastDeeplinkRead);
ajcAdjust.CallStatic("getLastDeeplink", ajoCurrentActivity, onLastDeeplinkReadProxy);
}
public static void EndFirstSessionDelay()
{
ajcAdjust.CallStatic("endFirstSessionDelay");
}
public static void EnableCoppaComplianceInDelay()
{
ajcAdjust.CallStatic("enableCoppaComplianceInDelay");
}
public static void DisableCoppaComplianceInDelay()
{
ajcAdjust.CallStatic("disableCoppaComplianceInDelay");
}
public static void SetExternalDeviceIdInDelay(string externalDeviceId)
{
ajcAdjust.CallStatic("setExternalDeviceIdInDelay", externalDeviceId);
}
// android specific methods
public static void GetGoogleAdId(Action<string> onDeviceIdsRead)
{
GoogleAdIdReadListener onDeviceIdsReadProxy = new GoogleAdIdReadListener(onDeviceIdsRead);
ajcAdjust.CallStatic("getGoogleAdId", ajoCurrentActivity, onDeviceIdsReadProxy);
}
public static void GetAmazonAdId(Action<string> onAmazonAdIdRead)
{
AmazonAdIdReadListener onAmazonAdIdReadProxy = new AmazonAdIdReadListener(onAmazonAdIdRead);
ajcAdjust.CallStatic("getAmazonAdId", ajoCurrentActivity, onAmazonAdIdReadProxy);
}
public static void VerifyPlayStorePurchase(
AdjustPlayStorePurchase purchase,
Action<AdjustPurchaseVerificationResult> verificationInfoCallback)
{
VerificationResultListener verificationResultListener = new VerificationResultListener(verificationInfoCallback);
using (AndroidJavaObject ajoPurchase = new AndroidJavaObject("com.adjust.sdk.AdjustPlayStorePurchase",
purchase.ProductId,
purchase.PurchaseToken))
{
ajcAdjust.CallStatic("verifyPlayStorePurchase", ajoPurchase, verificationResultListener);
}
}
public static void ProcessAndResolveDeeplink(AdjustDeeplink deeplink, Action<string> resolvedLinkCallback)
{
onDeeplinkResolvedListener = new DeeplinkResolutionListener(resolvedLinkCallback);
using (AndroidJavaClass ajcUri = new AndroidJavaClass("android.net.Uri"))
using (AndroidJavaObject ajoUri = ajcUri.CallStatic<AndroidJavaObject>("parse", deeplink.Deeplink))
using (AndroidJavaObject ajoAdjustDeeplink = new AndroidJavaObject("com.adjust.sdk.AdjustDeeplink", ajoUri))
{
if (deeplink.Referrer != null)
{
using (AndroidJavaObject ajoReferrer = ajcUri.CallStatic<AndroidJavaObject>("parse", deeplink.Referrer))
{
ajoAdjustDeeplink.Call("setReferrer", ajoReferrer);
}
}
ajcAdjust.CallStatic(
"processAndResolveDeeplink",
ajoAdjustDeeplink,
ajoCurrentActivity,
onDeeplinkResolvedListener);
}
}
public static void VerifyAndTrackPlayStorePurchase(
AdjustEvent adjustEvent,
Action<AdjustPurchaseVerificationResult> verificationInfoCallback)
{
VerificationResultListener verifyAndTrackListener = new VerificationResultListener(verificationInfoCallback);
using (AndroidJavaObject ajoAdjustEvent =
new AndroidJavaObject("com.adjust.sdk.AdjustEvent", adjustEvent.EventToken))
{
// check if user has set revenue for the event
if (adjustEvent.Revenue != null)
{
ajoAdjustEvent.Call("setRevenue", (double)adjustEvent.Revenue, adjustEvent.Currency);
}
// check if user has added any callback parameters to the event
if (adjustEvent.CallbackParameters != null)
{
for (int i = 0; i < adjustEvent.CallbackParameters.Count; i += 2)
{
string key = adjustEvent.CallbackParameters[i];
string value = adjustEvent.CallbackParameters[i + 1];
ajoAdjustEvent.Call("addCallbackParameter", key, value);
}
}
// check if user has added any partner parameters to the event
if (adjustEvent.PartnerParameters != null)
{
for (int i = 0; i < adjustEvent.PartnerParameters.Count; i += 2)
{
string key = adjustEvent.PartnerParameters[i];
string value = adjustEvent.PartnerParameters[i + 1];
ajoAdjustEvent.Call("addPartnerParameter", key, value);
}
}
// check if user has set deduplication ID for the event
if (adjustEvent.DeduplicationId != null)
{
ajoAdjustEvent.Call("setDeduplicationId", adjustEvent.DeduplicationId);
}
// check if user has added callback ID to the event
if (adjustEvent.CallbackId != null)
{
ajoAdjustEvent.Call("setCallbackId", adjustEvent.CallbackId);
}
// check if user has added product ID to the event
if (adjustEvent.ProductId != null)
{
ajoAdjustEvent.Call("setProductId", adjustEvent.ProductId);
}
// check if user has added purchase token to the event
if (adjustEvent.PurchaseToken != null)
{
ajoAdjustEvent.Call("setPurchaseToken", adjustEvent.PurchaseToken);
}
ajcAdjust.CallStatic("verifyAndTrackPlayStorePurchase", ajoAdjustEvent, verifyAndTrackListener);
}
}
public static void EnablePlayStoreKidsComplianceInDelay()
{
ajcAdjust.CallStatic("enablePlayStoreKidsComplianceInDelay");
}
public static void DisablePlayStoreKidsComplianceInDelay()
{
ajcAdjust.CallStatic("disablePlayStoreKidsComplianceInDelay");
}
// used for testing only
public static void SetTestOptions(Dictionary<string, string> testOptions)
{
using (AndroidJavaObject ajoTestOptions = AdjustUtils.TestOptionsMap2AndroidJavaObject(testOptions, ajoCurrentActivity))
{
ajcAdjust.CallStatic("setTestOptions", ajoTestOptions);
}
}
public static void OnResume(string testingArgument = null)
{
if (testingArgument == "test")
{
ajcAdjust.CallStatic("onResume");
}
}
public static void OnPause(string testingArgument = null)
{
if (testingArgument == "test")
{
ajcAdjust.CallStatic("onPause");
}
}
// private & helper classes
private class AttributionChangedListener : AndroidJavaProxy
{
private Action<AdjustAttribution> callback;
public AttributionChangedListener(Action<AdjustAttribution> pCallback)
: base("com.adjust.sdk.OnAttributionChangedListener")
{
this.callback = pCallback;
}
// native method:
// void onAttributionChanged(AdjustAttribution attribution);
public void onAttributionChanged(AndroidJavaObject ajoAttribution)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
try
{
if (ajoAttribution == null)
{
if (callback != null)
{
callback.Invoke(null);
}
return;
}
AdjustAttribution adjustAttribution = new AdjustAttribution
{
TrackerName = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyTrackerName)),
TrackerToken = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyTrackerToken)),
Network = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyNetwork)),
Campaign = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyCampaign)),
Adgroup = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyAdgroup)),
Creative = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyCreative)),
ClickLabel = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyClickLabel)),
CostType = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyCostType)),
CostCurrency = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyCostCurrency)),
FbInstallReferrer = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyFbInstallReferrer))
};
using (AndroidJavaObject ajoCostAmount = ajoAttribution.Get<AndroidJavaObject>(AdjustUtils.KeyCostAmount))
{
adjustAttribution.CostAmount = ajoCostAmount != null ? ajoCostAmount.Call<double>("doubleValue") : (double?)null;
}
string jsonResponse = ajoAttribution.Get<string>(AdjustUtils.KeyJsonResponse);
if (jsonResponse != null) {
var jsonResponseNode = JSON.Parse(jsonResponse);
if (jsonResponseNode != null && jsonResponseNode.AsObject != null)
{
adjustAttribution.JsonResponse = new Dictionary<string, object>();
AdjustUtils.WriteJsonResponseDictionary(jsonResponseNode.AsObject, adjustAttribution.JsonResponse);
}
}
if (callback != null)
{
callback.Invoke(adjustAttribution);
}
}
catch (Exception)
{
// JSON response reading failed.
}
});
}
}
private class DeferredDeeplinkListener : AndroidJavaProxy
{
private Action<string> callback;
public DeferredDeeplinkListener(Action<string> pCallback)
: base("com.adjust.sdk.OnDeferredDeeplinkResponseListener")
{
this.callback = pCallback;
}
// native method:
// boolean launchReceivedDeeplink(Uri deeplink);
public bool launchReceivedDeeplink(AndroidJavaObject deeplink)
{
if (this.callback == null)
{
return isDeferredDeeplinkOpeningEnabled;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
string strDeeplink = deeplink != null ? deeplink.Call<string>("toString") : null;
if (callback != null)
{
callback.Invoke(strDeeplink);
}
});
return isDeferredDeeplinkOpeningEnabled;
}
}
private class EventTrackingSucceededListener : AndroidJavaProxy
{
private Action<AdjustEventSuccess> callback;
public EventTrackingSucceededListener(Action<AdjustEventSuccess> pCallback) : base("com.adjust.sdk.OnEventTrackingSucceededListener")
{
this.callback = pCallback;
}
// native method:
// void onEventTrackingSucceeded(AdjustEventSuccess eventSuccessResponseData);
public void onEventTrackingSucceeded(AndroidJavaObject eventSuccessData)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
try
{
AdjustEventSuccess adjustEventSuccess = new AdjustEventSuccess
{
Adid = AdjustUtils.GetValueOrEmptyToNull(eventSuccessData.Get<string>(AdjustUtils.KeyAdid)),
Message = AdjustUtils.GetValueOrEmptyToNull(eventSuccessData.Get<string>(AdjustUtils.KeyMessage)),
Timestamp = AdjustUtils.GetValueOrEmptyToNull(eventSuccessData.Get<string>(AdjustUtils.KeyTimestamp)),
EventToken = AdjustUtils.GetValueOrEmptyToNull(eventSuccessData.Get<string>(AdjustUtils.KeyEventToken)),
CallbackId = AdjustUtils.GetValueOrEmptyToNull(eventSuccessData.Get<string>(AdjustUtils.KeyCallbackId))
};
using (AndroidJavaObject ajoJsonResponse = eventSuccessData.Get<AndroidJavaObject>(AdjustUtils.KeyJsonResponse))
{
if (ajoJsonResponse != null)
{
string jsonResponseString = ajoJsonResponse.Call<string>("toString");
adjustEventSuccess.BuildJsonResponseFromString(jsonResponseString);
}
}
if (callback != null)
{
callback.Invoke(adjustEventSuccess);
}
}
catch (Exception)
{
// JSON response reading failed.
// Native Android SDK should send empty JSON object if none available as of v4.12.5.
// Native Android SDK added special logic to send Unity friendly values as of v4.15.0.
}
});
}
}
private class EventTrackingFailedListener : AndroidJavaProxy
{
private Action<AdjustEventFailure> callback;
public EventTrackingFailedListener(Action<AdjustEventFailure> pCallback) : base("com.adjust.sdk.OnEventTrackingFailedListener")
{
this.callback = pCallback;
}
// native method:
// void onEventTrackingFailed(AdjustEventFailure eventFailureResponseData);
public void onEventTrackingFailed(AndroidJavaObject eventFailureData)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
try
{
AdjustEventFailure adjustEventFailure = new AdjustEventFailure
{
Adid = AdjustUtils.GetValueOrEmptyToNull(eventFailureData.Get<string>(AdjustUtils.KeyAdid)),
Message = AdjustUtils.GetValueOrEmptyToNull(eventFailureData.Get<string>(AdjustUtils.KeyMessage)),
Timestamp = AdjustUtils.GetValueOrEmptyToNull(eventFailureData.Get<string>(AdjustUtils.KeyTimestamp)),
EventToken = AdjustUtils.GetValueOrEmptyToNull(eventFailureData.Get<string>(AdjustUtils.KeyEventToken)),
CallbackId = AdjustUtils.GetValueOrEmptyToNull(eventFailureData.Get<string>(AdjustUtils.KeyCallbackId)),
WillRetry = eventFailureData.Get<bool>(AdjustUtils.KeyWillRetry)
};
using (AndroidJavaObject ajoJsonResponse = eventFailureData.Get<AndroidJavaObject>(AdjustUtils.KeyJsonResponse))
{
if (ajoJsonResponse != null)
{
string jsonResponseString = ajoJsonResponse.Call<string>("toString");
adjustEventFailure.BuildJsonResponseFromString(jsonResponseString);
}
}
if (callback != null)
{
callback.Invoke(adjustEventFailure);
}
}
catch (Exception)
{
// JSON response reading failed.
// Native Android SDK should send empty JSON object if none available as of v4.12.5.
// Native Android SDK added special logic to send Unity friendly values as of v4.15.0.
}
});
}
}
private class SessionTrackingSucceededListener : AndroidJavaProxy
{
private Action<AdjustSessionSuccess> callback;
public SessionTrackingSucceededListener(Action<AdjustSessionSuccess> pCallback)
: base("com.adjust.sdk.OnSessionTrackingSucceededListener")
{
this.callback = pCallback;
}
// native method:
// void onSessionTrackingSucceeded(AdjustSessionSuccess sessionSuccessResponseData);
public void onSessionTrackingSucceeded(AndroidJavaObject sessionSuccessData)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
try
{
AdjustSessionSuccess adjustSessionSuccess = new AdjustSessionSuccess
{
Adid = AdjustUtils.GetValueOrEmptyToNull(sessionSuccessData.Get<string>(AdjustUtils.KeyAdid)),
Message = AdjustUtils.GetValueOrEmptyToNull(sessionSuccessData.Get<string>(AdjustUtils.KeyMessage)),
Timestamp = AdjustUtils.GetValueOrEmptyToNull(sessionSuccessData.Get<string>(AdjustUtils.KeyTimestamp))
};
using (AndroidJavaObject ajoJsonResponse = sessionSuccessData.Get<AndroidJavaObject>(AdjustUtils.KeyJsonResponse))
{
if (ajoJsonResponse != null)
{
string jsonResponseString = ajoJsonResponse.Call<string>("toString");
adjustSessionSuccess.BuildJsonResponseFromString(jsonResponseString);
}
}
if (callback != null)
{
callback.Invoke(adjustSessionSuccess);
}
}
catch (Exception)
{
// JSON response reading failed.
// Native Android SDK should send empty JSON object if none available as of v4.12.5.
// Native Android SDK added special logic to send Unity friendly values as of v4.15.0.
}
});
}
}
private class SessionTrackingFailedListener : AndroidJavaProxy
{
private Action<AdjustSessionFailure> callback;
public SessionTrackingFailedListener(Action<AdjustSessionFailure> pCallback)
: base("com.adjust.sdk.OnSessionTrackingFailedListener")
{
this.callback = pCallback;
}
// native method:
// void onSessionTrackingFailed(AdjustSessionFailure failureResponseData);
public void onSessionTrackingFailed(AndroidJavaObject sessionFailureData)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
try
{
AdjustSessionFailure adjustSessionFailure = new AdjustSessionFailure
{
Adid = AdjustUtils.GetValueOrEmptyToNull(sessionFailureData.Get<string>(AdjustUtils.KeyAdid)),
Message = AdjustUtils.GetValueOrEmptyToNull(sessionFailureData.Get<string>(AdjustUtils.KeyMessage)),
Timestamp = AdjustUtils.GetValueOrEmptyToNull(sessionFailureData.Get<string>(AdjustUtils.KeyTimestamp)),
WillRetry = sessionFailureData.Get<bool>(AdjustUtils.KeyWillRetry)
};
using (AndroidJavaObject ajoJsonResponse = sessionFailureData.Get<AndroidJavaObject>(AdjustUtils.KeyJsonResponse))
{
if (ajoJsonResponse != null)
{
string jsonResponseString = ajoJsonResponse.Call<string>("toString");
adjustSessionFailure.BuildJsonResponseFromString(jsonResponseString);
}
}
if (callback != null)
{
callback.Invoke(adjustSessionFailure);
}
}
catch (Exception)
{
// JSON response reading failed.
// Native Android SDK should send empty JSON object if none available as of v4.12.5.
// Native Android SDK added special logic to send Unity friendly values as of v4.15.0.
}
});
}
}
private class GoogleAdIdReadListener : AndroidJavaProxy
{
private Action<string> callback;
public GoogleAdIdReadListener(Action<string> pCallback)
: base("com.adjust.sdk.OnGoogleAdIdReadListener")
{
this.callback = pCallback;
}
// native method:
// void onGoogleAdIdRead(String googleAdId);
public void onGoogleAdIdRead(string adid)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
if (callback != null)
{
callback.Invoke(adid);
}
});
}
}
private class VerificationResultListener : AndroidJavaProxy
{
private Action<AdjustPurchaseVerificationResult> callback;
public VerificationResultListener(Action<AdjustPurchaseVerificationResult> pCallback)
: base("com.adjust.sdk.OnPurchaseVerificationFinishedListener")
{
this.callback = pCallback;
}
// native method:
// void onVerificationFinished(AdjustPurchaseVerificationResult result);
public void onVerificationFinished(AndroidJavaObject ajoVerificationInfo)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
try
{
if (ajoVerificationInfo == null)
{
if (callback != null)
{
callback.Invoke(null);
}
return;
}
AdjustPurchaseVerificationResult purchaseVerificationResult = new AdjustPurchaseVerificationResult
{
VerificationStatus = ajoVerificationInfo.Get<string>(AdjustUtils.KeyVerificationStatus),
Code = ajoVerificationInfo.Get<int>(AdjustUtils.KeyCode),
Message = AdjustUtils.GetValueOrEmptyToNull(ajoVerificationInfo.Get<string>(AdjustUtils.KeyMessage))
};
if (callback != null)
{
callback.Invoke(purchaseVerificationResult);
}
}
catch (Exception)
{
// Handle potential errors during the verification process
}
});
}
}
private class DeeplinkResolutionListener : AndroidJavaProxy
{
private Action<string> callback;
public DeeplinkResolutionListener(Action<string> pCallback)
: base("com.adjust.sdk.OnDeeplinkResolvedListener")
{
this.callback = pCallback;
}
// native method:
// void onDeeplinkResolved(String resolvedLink);
public void onDeeplinkResolved(string resolvedLink)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
if (callback != null)
{
callback.Invoke(resolvedLink);
}
});
}
}
private class AdidReadListener : AndroidJavaProxy
{
private Action<string> callback;
public AdidReadListener(Action<string> pCallback)
: base("com.adjust.sdk.OnAdidReadListener")
{
this.callback = pCallback;
}
// native method:
// void onAdidRead(String adid);
public void onAdidRead(string adid)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
if (callback != null)
{
callback.Invoke(adid);
}
});
}
}
private class AttributionReadListener : AndroidJavaProxy
{
private Action<AdjustAttribution> callback;
public AttributionReadListener(Action<AdjustAttribution> pCallback)
: base("com.adjust.sdk.OnAttributionReadListener")
{
this.callback = pCallback;
}
// native method:
// void onAttributionRead(AdjustAttribution attribution);
public void onAttributionRead(AndroidJavaObject ajoAttribution)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
try
{
if (ajoAttribution == null)
{
if (callback != null)
{
callback.Invoke(null);
}
return;
}
AdjustAttribution adjustAttribution = new AdjustAttribution
{
TrackerName = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyTrackerName)),
TrackerToken = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyTrackerToken)),
Network = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyNetwork)),
Campaign = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyCampaign)),
Adgroup = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyAdgroup)),
Creative = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyCreative)),
ClickLabel = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyClickLabel)),
CostType = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyCostType)),
CostCurrency = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyCostCurrency)),
FbInstallReferrer = AdjustUtils.GetValueOrEmptyToNull(ajoAttribution.Get<string>(AdjustUtils.KeyFbInstallReferrer))
};
using (AndroidJavaObject ajoCostAmount = ajoAttribution.Get<AndroidJavaObject>(AdjustUtils.KeyCostAmount))
{
adjustAttribution.CostAmount = ajoCostAmount != null ? ajoCostAmount.Call<double>("doubleValue") : (double?)null;
}
string jsonResponse = ajoAttribution.Get<string>(AdjustUtils.KeyJsonResponse);
if (jsonResponse != null) {
var jsonResponseNode = JSON.Parse(jsonResponse);
if (jsonResponseNode != null && jsonResponseNode.AsObject != null)
{
adjustAttribution.JsonResponse = new Dictionary<string, object>();
AdjustUtils.WriteJsonResponseDictionary(jsonResponseNode.AsObject, adjustAttribution.JsonResponse);
}
}
if (callback != null)
{
callback.Invoke(adjustAttribution);
}
}
catch (Exception)
{
// JSON response reading failed.
}
});
}
}
private class AmazonAdIdReadListener : AndroidJavaProxy
{
private Action<string> callback;
public AmazonAdIdReadListener(Action<string> pCallback)
: base("com.adjust.sdk.OnAmazonAdIdReadListener")
{
this.callback = pCallback;
}
// native method:
// void onAmazonAdIdRead(String amazonAdId);
public void onAmazonAdIdRead(string amazonAdId)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
if (callback != null)
{
callback.Invoke(amazonAdId);
}
});
}
}
private class SdkVersionReadListener : AndroidJavaProxy
{
private Action<string> callback;
private string sdkPrefix;
public SdkVersionReadListener(Action<string> pCallback, string sdkPrefix)
: base("com.adjust.sdk.OnSdkVersionReadListener")
{
this.callback = pCallback;
this.sdkPrefix = sdkPrefix;
}
// native method:
// void onSdkVersionRead(String sdkVersion);
public void onSdkVersionRead(string sdkVersion)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
if (callback != null)
{
callback.Invoke(this.sdkPrefix + "@" + sdkVersion);
}
});
}
}
private class IsEnabledListener : AndroidJavaProxy
{
private Action<bool> callback;
public IsEnabledListener(Action<bool> pCallback)
: base("com.adjust.sdk.OnIsEnabledListener")
{
this.callback = pCallback;
}
// native method:
// void onIsEnabledRead(boolean isEnabled);
public void onIsEnabledRead(bool isEnabled)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
if (callback != null)
{
callback.Invoke(isEnabled);
}
});
}
}
private class LastDeeplinkListener : AndroidJavaProxy
{
private Action<string> callback;
public LastDeeplinkListener(Action<string> pCallback)
: base("com.adjust.sdk.OnLastDeeplinkReadListener")
{
this.callback = pCallback;
}
// native method:
// void onLastDeeplinkRead(Uri deeplink);
public void onLastDeeplinkRead(AndroidJavaObject ajoLastDeeplink)
{
if (this.callback == null)
{
return;
}
AdjustThreadDispatcher.RunOnMainThread(() =>
{
string deeplink = ajoLastDeeplink != null ? ajoLastDeeplink.Call<string>("toString") : null;
if (callback != null)
{
callback.Invoke(deeplink);
}
});
}
}
}
#endif
}