public void BuildNativeConfig()
{
this.nativeConfig = new AdjustConfig(this.appToken, this.environment);
this.nativeConfig.SdkPrefix = this.sdkPrefix;
if (this.defaultTracker != null)
{
this.nativeConfig.DefaultTracker = this.defaultTracker;
}
if (this.isEventBufferingEnabled != null)
{
this.nativeConfig.EventBufferingEnabled = (bool)this.isEventBufferingEnabled;
}
if (this.rtAttributionCallback != null)
{
this.nativeConfig.AttributionChanged = this.rtAttributionCallback;
}
if (this.rtFileReadCallback != null)
{
this.nativeConfig.FileReader = this.rtFileReadCallback;
}
if (this.rtFileWriteCallback != null)
{
this.nativeConfig.FileWriter = this.rtFileWriteCallback;
}
}
public static void Start()
{
AdjustConfig config = new AdjustConfig(ADJUST_APP_TOKEN, AdjustEnvironment.Production);
config.setLogLevel(AdjustLogLevel.Info);
Adjust.start(config);
}
private static string BuildAuthorizationHeader(IReadOnlyDictionary <string, string> parameters,
string appSecret, string secretId, string activityKind)
{
// check if the secret exists and it's not empty
if (string.IsNullOrEmpty(appSecret) || parameters == null)
{
return(null);
}
var signatureDetails = GetSignature(parameters, activityKind, appSecret);
string algorithm = ALG_SHA256;
string signature = AdjustConfig.String2Sha256Func(signatureDetails[CLEAR_SIGNATURE]);
signature = signature.ToLower();
string fields = signatureDetails[FIELDS];
string secretIdHeader = $"{SECRET_ID}=\"{secretId}\"";
string signatureHeader = $"{SIGNATURE}=\"{signature}\"";
string algorithmHeader = $"{ALGORITHM}=\"{algorithm}\"";
string fieldsHeader = $"{HEADERS}=\"{fields}\"";
string authorizationHeader = $"Signature {secretIdHeader},{signatureHeader},{algorithmHeader},{fieldsHeader}";
Logger.Verbose($"authorizationHeader: {authorizationHeader}");
return(authorizationHeader);
}
internal PackageBuilder(AdjustConfig adjustConfig, DeviceInfo deviceInfo,
DateTime createdAt)
{
AdjustConfig = adjustConfig;
DeviceInfo = deviceInfo;
CreatedAt = createdAt;
}
public void start(AdjustConfig adjustConfig)
{
if (this.adjust != null)
{
global::Debug.Log("adjust: Error, SDK already started.");
return;
}
if (adjustConfig == null)
{
global::Debug.Log("adjust: Missing config to start.");
return;
}
this.adjust = new AdjustAndroid();
if (this.adjust == null)
{
global::Debug.Log("adjust: SDK can only be used in Android, iOS, Windows Phone 8 or Windows Store apps.");
return;
}
this.eventSuccessDelegate = adjustConfig.getEventSuccessDelegate();
this.eventFailureDelegate = adjustConfig.getEventFailureDelegate();
this.sessionSuccessDelegate = adjustConfig.getSessionSuccessDelegate();
this.sessionFailureDelegate = adjustConfig.getSessionFailureDelegate();
this.deferredDeeplinkDelegate = adjustConfig.getDeferredDeeplinkDelegate();
this.attributionChangedDelegate = adjustConfig.getAttributionChangedDelegate();
this.adjust.start(adjustConfig);
}
internal PackageBuilder(AdjustConfig adjustConfig, DeviceInfo deviceInfo,
DateTime createdAt)
{
AdjustConfig = adjustConfig;
DeviceInfo = deviceInfo;
CreatedAt = createdAt;
}
public static void ApplicationLaunching(string appToken, string environment, string logLevelString, string defaultTracker, bool?eventBufferingEnabled, string sdkPrefix, Action <Dictionary <string, string> > attributionChangedDic, Action <String> logDelegate)
{
LogLevel logLevel;
if (Enum.TryParse(logLevelString, out logLevel))
{
Adjust.SetupLogging(logDelegate: logDelegate,
logLevel: logLevel);
}
else
{
Adjust.SetupLogging(logDelegate: logDelegate);
}
var config = new AdjustConfig(appToken, environment);
config.DefaultTracker = defaultTracker;
if (eventBufferingEnabled.HasValue)
{
config.EventBufferingEnabled = eventBufferingEnabled.Value;
}
config.SdkPrefix = sdkPrefix;
if (attributionChangedDic != null)
{
config.AttributionChanged = (attribution) => attributionChangedDic(attribution.ToDictionary());
}
Adjust.ApplicationLaunching(config);
}
protected override bool AdapterInit(SDKAdapterConfig adapterConfig)
{
AdjustAdapterConfig config = (AdjustAdapterConfig)adapterConfig;
AdjustConfig adjustConfig = new AdjustConfig(config.m_AppToken, config.m_AdjustEnvironment);
adjustConfig.setLogLevel(config.m_AdjustLogLevel);
adjustConfig.setLogDelegate(msg => Log.I(msg));
adjustConfig.setEventBufferingEnabled(config.m_EventBuffering);
adjustConfig.setSendInBackground(config.m_SendInBackground);
// adjustConfig.setDeferredDeeplinkDelegate(DeferredDeeplinkCallback); //深度链接
// adjustConfig.setEventSuccessDelegate(EventSuccessCallback);
// adjustConfig.setEventFailureDelegate(EventFailureCallback);
// adjustConfig.setSessionSuccessDelegate(SessionSuccessCallback);
// adjustConfig.setSessionFailureDelegate(SessionFailureCallback);
// adjustConfig.setAttributionChangedDelegate(AttributionChangedCallback);
Adjust.start(adjustConfig);
InitSuccess = true;
m_AdjustDefine = new AdjustDefine();
m_AdjustDefine.Init();
Log.I("AdjustAnalysisAdapter init success");
return(true);
}
public void StartAdjust()
{
if (this.adjust != null)
{
return;
}
if (!this.startManually)
{
AdjustConfig adjustConfig = new AdjustConfig(this.appToken, this.environment, this.logLevel == AdjustLogLevel.Suppress);
adjustConfig.setLogLevel(this.logLevel);
adjustConfig.setSendInBackground(this.sendInBackground);
adjustConfig.setEventBufferingEnabled(this.eventBuffering);
adjustConfig.setLaunchDeferredDeeplink(this.launchDeferredDeeplink);
if (this.printAttribution)
{
adjustConfig.setEventSuccessDelegate(new Action <AdjustEventSuccess>(this.EventSuccessCallback), "Adjust");
adjustConfig.setEventFailureDelegate(new Action <AdjustEventFailure>(this.EventFailureCallback), "Adjust");
adjustConfig.setSessionSuccessDelegate(new Action <AdjustSessionSuccess>(this.SessionSuccessCallback), "Adjust");
adjustConfig.setSessionFailureDelegate(new Action <AdjustSessionFailure>(this.SessionFailureCallback), "Adjust");
adjustConfig.setDeferredDeeplinkDelegate(new Action <string>(this.DeferredDeeplinkCallback), "Adjust");
adjustConfig.setAttributionChangedDelegate(new Action <AdjustAttribution>(this.AttributionChangedCallback), "Adjust");
}
this.start(adjustConfig);
this.getGoogleAdId(delegate(string googleAdId)
{
global::Debug.Log("googleAdId:" + googleAdId);
});
string adid = this.getAdid();
if (adid != null)
{
global::Debug.Log("adid:" + adid);
}
}
}
/// <summary>
/// Constructor for the Application object.
/// </summary>
public App()
{
// setup logging
Adjust.SetupLogging(logDelegate: msg => System.Diagnostics.Debug.WriteLine(msg),
logLevel: LogLevel.Verbose);
// configure Adjust
var config = new AdjustConfig("{yourAppToken}", AdjustConfig.EnvironmentSandbox);
// enable event buffering
//config.EventBufferingEnabled = true;
// set default tracker
//config.DefaultTracker = "{YourDefaultTracker}";
// set attribution delegate
config.AttributionChanged = (attribution) =>
System.Diagnostics.Debug.WriteLine("attribution: " + attribution);
Adjust.ApplicationLaunching(config);
// put the SDK in offline mode
//Adjust.SetOfflineMode(offlineMode: true);
// disable the SDK
//Adjust.SetEnabled(enabled: false);
// Global handler for uncaught exceptions.
UnhandledException += Application_UnhandledException;
// Standard XAML initialization
InitializeComponent();
// Phone-specific initialization
InitializePhoneApplication();
// Language display initialization
InitializeLanguage();
// Show graphics profiling information while debugging.
if (Debugger.IsAttached)
{
// Display the current frame rate counters.
Application.Current.Host.Settings.EnableFrameRateCounter = true;
// Show the areas of the app that are being redrawn in each frame.
//Application.Current.Host.Settings.EnableRedrawRegions = true;
// Enable non-production analysis visualization mode,
// which shows areas of a page that are handed off to GPU with a colored overlay.
//Application.Current.Host.Settings.EnableCacheVisualization = true;
// Prevent the screen from turning off while under the debugger by disabling
// the application's idle detection.
// Caution:- Use this under debug mode only. Application that disables user idle detection will continue to run
// and consume battery power when the user is not using the phone.
PhoneApplicationService.Current.UserIdleDetectionMode = IdleDetectionMode.Disabled;
}
}
internal PackageBuilder(AdjustConfig adjustConfig, DeviceInfo deviceInfo,
ActivityState activityState, DateTime createdAt)
{
_config = adjustConfig;
_deviceInfo = deviceInfo;
_activityStateCopy = new ActivityStateCopy(activityState);
_createdAt = createdAt;
}
public static IActivityHandler GetActivityHandler(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
if (IActivityHandler == null)
return ActivityHandler.GetInstance(adjustConfig, deviceUtil);
IActivityHandler.Init(adjustConfig, deviceUtil);
return IActivityHandler;
}
private void Initialize()
{
AdjustEnvironment environment = AdjustEnvironment.Production;
AdjustConfig config = new AdjustConfig(HCConstants.ADJUST_APP_TOKEN, environment, false);
config.setLogLevel(AdjustLogLevel.Debug);
Adjust.start(config);
}
public void OnStart()
{
MyLog.I("MyAdManager OnStart");
// Adjust
AdjustConfig adjustConfig = new AdjustConfig(MyConfig.ADJUST_TOKEN, AdjustEnvironment.Sandbox);
adjustConfig.setLogLevel(AdjustLogLevel.Verbose);
Adjust.start(adjustConfig);
}
public void ApplicationLaunching(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
if (ActivityHandler != null)
{
Logger.Error("Adjust already initialized");
return;
}
ActivityHandler = AdjustSdk.Pcl.ActivityHandler.GetInstance(adjustConfig, deviceUtil);
}
private ActivityHandler(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
// default values
Enabled = true;
Logger = AdjustFactory.Logger;
InternalQueue = new ActionQueue("adjust.ActivityQueue");
InternalQueue.Enqueue(() => InitInternal(adjustConfig, deviceUtil));
}
private ActivityHandler(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
// default values
Enabled = true;
Logger = AdjustFactory.Logger;
InternalQueue = new ActionQueue("adjust.ActivityQueue");
InternalQueue.Enqueue(() => InitInternal(adjustConfig, deviceUtil));
}
public static IActivityHandler GetActivityHandler(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
if (IActivityHandler == null)
{
return(ActivityHandler.GetInstance(adjustConfig, deviceUtil));
}
IActivityHandler.Init(adjustConfig, deviceUtil);
return(IActivityHandler);
}
public void ApplicationLaunching(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
if (ActivityHandler != null)
{
Logger.Error("Adjust already initialized");
return;
}
ActivityHandler = AdjustSdk.Pcl.ActivityHandler.GetInstance(adjustConfig, deviceUtil);
}
private void Awake()
{
Instance = this;
#if UNITY_EDITOR
AdjustConfig adjustConfig = new AdjustConfig(APP_TOKEN, AdjustEnvironment.Sandbox);
#else
AdjustConfig adjustConfig = new AdjustConfig(APP_TOKEN, AdjustEnvironment.Production);
#endif
adjustConfig.sendInBackground = true;
adjustConfig.setAttributionChangedDelegate(OnAttributionChangedCallback);
Adjust.start(adjustConfig);
}
public void ApplicationLaunching(AdjustConfig adjustConfig, IDeviceUtil deviceUtil)
{
adjustConfig.PreLaunchActions = _preLaunchActions;
adjustConfig.StartEnabled = _startEnabled;
adjustConfig.StartOffline = _startOffline;
AdjustConfig.String2Sha256Func = deviceUtil.HashStringUsingSha256;
AdjustConfig.String2Sha512Func = deviceUtil.HashStringUsingSha512;
AdjustConfig.String2Md5Func = deviceUtil.HashStringUsingShaMd5;
_activityHandler = ActivityHandler.GetInstance(adjustConfig, deviceUtil);
}
public override void Init()
{
if (this.ycManager.ycConfig.MmpAdjustAppToken != "")
{
AdjustConfig config = new AdjustConfig(this.ycManager.ycConfig.MmpAdjustAppToken, AdjustEnvironment.Production, true);
config.setLogLevel(AdjustLogLevel.Suppress);
Adjust.start(config);
}
else
{
Debug.LogWarning("[ADJUST] you active adjust but you forget the AppToken");
}
}
internal PackageBuilder(AdjustConfig adjustConfig,
DeviceInfo deviceInfo,
ActivityState activityState,
SessionParameters sessionParameters,
DateTime createdAt)
: this(adjustConfig, deviceInfo, activityState, createdAt)
{
// no need to copy because all access is made synchronously
// in Activity Handler inside internal functions.
// only exceptions are ´Enable´ and ´AskingAttribution´
// and they are not read here
//_ActivityState = activityState;
_sessionParameters = sessionParameters;
}
private void ExampleOfVariousCallbacksSetup(AdjustConfig config)
{
// set event success tracking delegate
config.EventTrackingSucceeded = adjustEventSuccess =>
{
// ...
//Debug.WriteLine("adjustEventSuccess: " + adjustEventSuccess);
};
// set event failure tracking delegate
config.EventTrackingFailed = adjustEventFailure =>
{
// ...
//Debug.WriteLine("adjustEventFailure: " + adjustEventFailure);
};
// set session success tracking delegate
config.SesssionTrackingSucceeded = adjustSessionSuccess =>
{
// ...
//Debug.WriteLine("adjustSessionSuccess: " + adjustSessionSuccess);
};
// set session failure tracking delegate
config.SesssionTrackingFailed = adjustSessionFailure =>
{
// ...
//Debug.WriteLine("adjustSessionFailure: " + adjustSessionFailure);
};
// set attribution delegate
config.AttributionChanged = attribution =>
{
// ...
Debug.WriteLine("attribution: " + attribution);
};
// deferred deep linking scenario
config.DeeplinkResponse = deepLinkUri =>
{
//Debug.WriteLine("deeplink response: " + deepLinkUri);
if (ShouldAdjustSdkLaunchTheDeeplink(deepLinkUri))
{
return(true);
}
return(false);
};
}
private void Awake()
{
Instance = this;
#if UNITY_EDITOR
AdjustConfig adjustConfig = new AdjustConfig(APP_TOKEN, AdjustEnvironment.Sandbox);
#else
AdjustConfig adjustConfig = new AdjustConfig(APP_TOKEN, AdjustEnvironment.Production);
#endif
adjustConfig.sendInBackground = true;
adjustConfig.launchDeferredDeeplink = true;
adjustConfig.eventBufferingEnabled = true;
adjustConfig.logLevel = AdjustLogLevel.Info;
adjustConfig.setAttributionChangedDelegate(OnAttributionChangedCallback);
Adjust.start(adjustConfig);
}
public static ActivityHandler GetInstance(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
if (adjustConfig == null)
{
AdjustFactory.Logger.Error("AdjustConfig missing");
return(null);
}
if (!adjustConfig.IsValid())
{
AdjustFactory.Logger.Error("AdjustConfig not initialized correctly");
return(null);
}
ActivityHandler activityHandler = new ActivityHandler(adjustConfig, deviceUtil);
return(activityHandler);
}
public static ActivityHandler GetActivityHandler(MockLogger mocklogger, DeviceUtil deviceUtil)
{
MockAttributionHandler mockAttributionHandler = new MockAttributionHandler(mocklogger);
MockPackageHandler mockPackageHandler = new MockPackageHandler(mocklogger);
AdjustFactory.SetAttributionHandler(mockAttributionHandler);
AdjustFactory.SetPackageHandler(mockPackageHandler);
// create the config to start the session
AdjustConfig config = new AdjustConfig(appToken: "123456789012", environment: AdjustConfig.EnvironmentSandbox);
// start activity handler with config
ActivityHandler activityHandler = ActivityHandler.GetInstance(config, deviceUtil);
deviceUtil.Sleep(3000);
return(activityHandler);
}
private void InitInternal(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
Init(adjustConfig, deviceUtil);
DeviceInfo = DeviceUtil.GetDeviceInfo();
DeviceInfo.SdkPrefix = adjustConfig.SdkPrefix;
TimerInterval = AdjustFactory.GetTimerInterval();
TimerStart = AdjustFactory.GetTimerStart();
SessionInterval = AdjustFactory.GetSessionInterval();
SubsessionInterval = AdjustFactory.GetSubsessionInterval();
if (AdjustConfig.Environment.Equals(AdjustConfig.EnvironmentProduction))
{
// suppress all logs in production
Logger.LogLevel = LogLevel.Suppress;
}
if (AdjustConfig.EventBufferingEnabled)
{
Logger.Info("Event buffering is enabled");
}
if (AdjustConfig.DefaultTracker != null)
{
Logger.Info("Default tracker: '{0}'", AdjustConfig.DefaultTracker);
}
ReadAttribution();
ReadActivityState();
PackageHandler = AdjustFactory.GetPackageHandler(this, Paused());
var attributionPackage = GetAttributionPackage();
AttributionHandler = AdjustFactory.GetAttributionHandler(this,
attributionPackage,
Paused(),
AdjustConfig.HasDelegate);
Timer = new TimerCycle(InternalQueue, TimerFiredInternal, timeInterval: TimerInterval, timeStart: TimerStart);
StartInternal();
}
private void Start()
{
string adjustAppToken = Constants.ADJUST_TOKEN_IOS;
if (Application.platform == RuntimePlatform.Android)
{
adjustAppToken = Constants.ADJUST_TOKEN_ANDROID;
}
else if (Application.platform == RuntimePlatform.IPhonePlayer)
{
adjustAppToken = Constants.ADJUST_TOKEN_IOS;
}
AdjustEnvironment environment = AdjustEnvironment.Production;
if (Debug.isDebugBuild)
{
environment = AdjustEnvironment.Sandbox;
}
else
{
environment = AdjustEnvironment.Production;
}
AdjustConfig config = new AdjustConfig(adjustAppToken, environment, true);
config.setDeferredDeeplinkDelegate(DeferredDeeplinkCallback);
if (Debug.isDebugBuild)
{
config.setLogLevel(AdjustLogLevel.Verbose);
}
else
{
config.setLogLevel(AdjustLogLevel.Info);
}
config.setSendInBackground(true);
new GameObject("Adjust").AddComponent <Adjust>();
config.setAttributionChangedDelegate(this.attributionChangedDelegate);
Adjust.start(config);
}
public void SetConfig(string json)
{
Debug.Log($"---- AdjustHelper SetConfig // Json {json}");
if (!string.IsNullOrEmpty(json) && !json.Equals("{}"))
{
_adjustData = JsonUtility.FromJson <AdjustData>(json);
if (string.IsNullOrEmpty(_adjustData.token))
{
Debug.Log("!!!!!!!!!!!!!!!! Error: Adjust Token is Empty ");
return;
}
else
{
Debug.Log($"AdjustHelper Init // Token {_adjustData.token}");
}
var config = new AdjustConfig(_adjustData.token, AdjustEnvironment.Production, false);
config.setLogLevel(AdjustLogLevel.Verbose);
config.setSendInBackground(true);
config.setAttributionChangedDelegate(AttributionChangedCallback);
config.setDefaultTracker(_adjustData.token);
config.setAllowIdfaReading(true);
config.setPreinstallTrackingEnabled(true);
config.setAllowiAdInfoReading(true);
config.setAllowAdServicesInfoReading(true);
config.setEventBufferingEnabled(true);
//config.setProcessName();
Adjust.setEnabled(true);
Adjust.start(config);
Debug.Log($"Adjust started");
}
else
{
Debug.Log($"!!!!!!!!!!!!!!!! AdjustHelper isn`t inited");
}
}
private void InitAdjust(string adjustAppToken)
{
var adjustConfig = new AdjustConfig(
adjustAppToken,
AdjustEnvironment.Production, // AdjustEnvironment.Sandbox to test in dashboard
true
);
adjustConfig.setLogLevel(AdjustLogLevel.Info); // AdjustLogLevel.Suppress to disable logs
adjustConfig.setSendInBackground(true);
new GameObject("Adjust").AddComponent <Adjust>(); // do not remove or rename
// Adjust.addSessionCallbackParameter("foo", "bar"); // if requested to set session-level parameters
//adjustConfig.setAttributionChangedDelegate((adjustAttribution) => {
// Debug.LogFormat("Adjust Attribution Callback: ", adjustAttribution.trackerName);
//});
Adjust.start(adjustConfig);
}
public void Init(string token)
{
if (string.IsNullOrEmpty(token))
{
AdId = "organic";
return;
}
#if UNITY_ANDROID && !UNITY_EDITOR
AdjustConfig config = new AdjustConfig(token, AdjustEnvironment.Production, false);
config.setLogLevel(AdjustLogLevel.Verbose);
config.setLogDelegate(msg => Debug.Log(msg));
//config.setAttributionChangedDelegate(AttributionChangedCallback);
Adjust.start(config);
#else
Debug.Log("ADID IS ORGANIC");
AdId = "organic";
#endif
}
private void InitAdjust(string token)
{
if (UnityEngine.Object.FindObjectOfType(typeof(Adjust)) == null)
{
GameObject ga = new GameObject();
ga.name = "Adjust";
//ga.transform.parent = transform;
ga.AddComponent <Adjust>();
}
else
{
Debug.LogWarning("A GameAnalytics object already exists in this scene - you should never have more than one per scene!");
}
AdjustConfig config = new AdjustConfig(token, AdjustEnvironment.Production, true);
config.setLogLevel(AdjustLogLevel.Suppress);
config.setLogDelegate(msg => Debug.Log(msg));
Adjust.start(config);
}
private void InitInternal(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
Init(adjustConfig, deviceUtil);
DeviceInfo = DeviceUtil.GetDeviceInfo();
DeviceInfo.SdkPrefix = adjustConfig.SdkPrefix;
TimerInterval = AdjustFactory.GetTimerInterval();
TimerStart = AdjustFactory.GetTimerStart();
SessionInterval = AdjustFactory.GetSessionInterval();
SubsessionInterval = AdjustFactory.GetSubsessionInterval();
if (AdjustConfig.Environment.Equals(AdjustConfig.EnvironmentProduction))
{
Logger.LogLevel = LogLevel.Assert;
}
if (AdjustConfig.EventBufferingEnabled)
{
Logger.Info("Event buffering is enabled");
}
if (AdjustConfig.DefaultTracker != null)
{
Logger.Info("Default tracker: '{0}'", AdjustConfig.DefaultTracker);
}
ReadAttribution();
ReadActivityState();
PackageHandler = AdjustFactory.GetPackageHandler(this, Paused());
var attributionPackage = GetAttributionPackage();
AttributionHandler = AdjustFactory.GetAttributionHandler(this,
attributionPackage,
Paused(),
AdjustConfig.HasDelegate);
Timer = new TimerCycle(InternalQueue, TimerFiredInternal, timeInterval: TimerInterval, timeStart: TimerStart);
StartInternal();
}
public void Init(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
MockLogger.Test("{0} Init", prefix);
}
internal PackageBuilder(AdjustConfig adjustConfig, DeviceInfo deviceInfo, ActivityState activityState, DateTime createdAt)
: this(adjustConfig, deviceInfo, createdAt)
{
ActivityState = activityState.Clone();
}
public static ActivityHandler GetInstance(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
if (adjustConfig == null)
{
AdjustFactory.Logger.Error("AdjustConfig missing");
return null;
}
if (!adjustConfig.IsValid())
{
AdjustFactory.Logger.Error("AdjustConfig not initialized correctly");
return null;
}
ActivityHandler activityHandler = new ActivityHandler(adjustConfig, deviceUtil);
return activityHandler;
}
public void Init(AdjustConfig adjustConfig, DeviceUtil deviceUtil)
{
AdjustConfig = adjustConfig;
DeviceUtil = deviceUtil;
}