package com.adjust.sdk;
import android.app.ActivityManager;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Handler;
import android.os.Process;
import com.adjust.sdk.scheduler.SingleThreadCachedScheduler;
import com.adjust.sdk.scheduler.ThreadExecutor;
import com.adjust.sdk.scheduler.TimerCycle;
import com.adjust.sdk.scheduler.TimerOnce;
import com.huawei.hms.support.api.entity.common.CommonConstant;
import com.tencent.wcdb.database.SQLiteDatabase;
import com.unbotify.mobile.sdk.Unbotify;
import java.io.InputStream;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import n02.e;
import org.json.JSONObject;
public class ActivityHandler implements IActivityHandler {
private static final String ACTIVITY_STATE_NAME = "Activity state";
private static final String ATTRIBUTION_NAME = "Attribution";
private static long BACKGROUND_TIMER_INTERVAL = 0;
private static final String BACKGROUND_TIMER_NAME = "Background timer";
private static final String DELAY_START_TIMER_NAME = "Delay Start timer";
private static long FOREGROUND_TIMER_INTERVAL = 0;
private static final String FOREGROUND_TIMER_NAME = "Foreground timer";
private static long FOREGROUND_TIMER_START = 0;
private static final String SESSION_CALLBACK_PARAMETERS_NAME = "Session Callback parameters";
private static long SESSION_INTERVAL = 0;
private static final String SESSION_PARAMETERS_NAME = "Session parameters";
private static final String SESSION_PARTNER_PARAMETERS_NAME = "Session Partner parameters";
private static long SUBSESSION_INTERVAL = 0;
private static final String TIME_TRAVEL = "Time travel!";
private ActivityState activityState;
private AdjustConfig adjustConfig;
private AdjustAttribution attribution;
private IAttributionHandler attributionHandler;
private TimerOnce backgroundTimer;
private String basePath;
private TimerOnce delayStartTimer;
private DeviceInfo deviceInfo;
private String disableThirdPartySharingPath;
private ThreadExecutor executor = new SingleThreadCachedScheduler("ActivityHandler");
private TimerCycle foregroundTimer;
private String gdprPath;
private InstallReferrer installReferrer;
private InstallReferrerHuawei installReferrerHuawei;
private InternalState internalState;
private ILogger logger;
private IPackageHandler packageHandler;
private ISdkClickHandler sdkClickHandler;
private SessionParameters sessionParameters;
private String subscriptionPath;
private IUnbotifyHandler unbotifyHandler;
private String unbotifyPath;
public class InternalState {
public boolean background;
public boolean delayStart;
public boolean enabled;
public boolean firstLaunch;
public boolean firstSdkStart;
public boolean offline;
public boolean preinstallHasBeenRead;
public boolean sessionResponseProcessed;
public boolean updatePackages;
public InternalState() {
}
public boolean hasFirstSdkStartNotOcurred() {
return !this.firstSdkStart;
}
public boolean hasFirstSdkStartOcurred() {
return this.firstSdkStart;
}
public boolean hasPreinstallBeenRead() {
return this.preinstallHasBeenRead;
}
public boolean hasSessionResponseNotBeenProcessed() {
return !this.sessionResponseProcessed;
}
public boolean isDisabled() {
return !this.enabled;
}
public boolean isEnabled() {
return this.enabled;
}
public boolean isFirstLaunch() {
return this.firstLaunch;
}
public boolean isInBackground() {
return this.background;
}
public boolean isInDelayedStart() {
return this.delayStart;
}
public boolean isInForeground() {
return !this.background;
}
public boolean isNotFirstLaunch() {
return !this.firstLaunch;
}
public boolean isNotInDelayedStart() {
return !this.delayStart;
}
public boolean isOffline() {
return this.offline;
}
public boolean isOnline() {
return !this.offline;
}
public boolean itHasToUpdatePackages() {
return this.updatePackages;
}
}
private ActivityHandler(AdjustConfig adjustConfig2) {
init(adjustConfig2);
ILogger logger2 = AdjustFactory.getLogger();
this.logger = logger2;
logger2.lockLogLevel();
InternalState internalState2 = new InternalState();
this.internalState = internalState2;
Boolean bool = adjustConfig2.startEnabled;
internalState2.enabled = bool != null ? bool.booleanValue() : true;
InternalState internalState3 = this.internalState;
internalState3.offline = adjustConfig2.startOffline;
internalState3.background = true;
internalState3.delayStart = false;
internalState3.updatePackages = false;
internalState3.sessionResponseProcessed = false;
internalState3.firstSdkStart = false;
internalState3.preinstallHasBeenRead = false;
initUnbotify();
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass1 */
public void run() {
ActivityHandler.this.initI();
}
});
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void backgroundTimerFiredI() {
if (toSendI()) {
this.packageHandler.sendFirstPackage();
}
}
private boolean canProcessEvent() {
return checkActivityStateI(this.activityState) && isEnabledI() && !this.activityState.isGdprForgotten;
}
private boolean checkActivityStateI(ActivityState activityState2) {
if (!this.internalState.hasFirstSdkStartNotOcurred()) {
return true;
}
this.logger.error("Sdk did not yet start", new Object[0]);
return false;
}
private void checkAfterNewStartI() {
checkAfterNewStartI(new SharedPreferencesManager(getContext()));
}
private void checkAfterNewStartI(SharedPreferencesManager sharedPreferencesManager) {
String pushToken = sharedPreferencesManager.getPushToken();
if (pushToken != null && !pushToken.equals(this.activityState.pushToken)) {
setPushToken(pushToken, true);
}
if (sharedPreferencesManager.getRawReferrerArray() != null) {
sendReftagReferrer();
}
checkForPreinstallI();
this.installReferrer.startConnection();
this.installReferrerHuawei.readReferrer();
}
private void checkAttributionStateI() {
if (checkActivityStateI(this.activityState)) {
if (this.internalState.isFirstLaunch() && this.internalState.hasSessionResponseNotBeenProcessed()) {
return;
}
if (this.attribution == null || this.activityState.askingAttribution) {
this.attributionHandler.getAttribution();
}
}
}
private boolean checkEventI(AdjustEvent adjustEvent) {
if (adjustEvent == null) {
this.logger.error("Event missing", new Object[0]);
return false;
} else if (adjustEvent.isValid()) {
return true;
} else {
this.logger.error("Event not initialized correctly", new Object[0]);
return false;
}
}
private void checkForInstallReferrerInfo(SdkClickResponseData sdkClickResponseData) {
if (sdkClickResponseData.isInstallReferrer) {
String str = sdkClickResponseData.referrerApi;
if (!(str != null && str.equalsIgnoreCase("huawei"))) {
ActivityState activityState2 = this.activityState;
activityState2.clickTime = sdkClickResponseData.clickTime;
activityState2.installBegin = sdkClickResponseData.installBegin;
activityState2.installReferrer = sdkClickResponseData.installReferrer;
activityState2.clickTimeServer = sdkClickResponseData.clickTimeServer;
activityState2.installBeginServer = sdkClickResponseData.installBeginServer;
activityState2.installVersion = sdkClickResponseData.installVersion;
activityState2.googlePlayInstant = sdkClickResponseData.googlePlayInstant;
} else {
ActivityState activityState3 = this.activityState;
activityState3.clickTimeHuawei = sdkClickResponseData.clickTime;
activityState3.installBeginHuawei = sdkClickResponseData.installBegin;
activityState3.installReferrerHuawei = sdkClickResponseData.installReferrer;
}
writeActivityStateI();
}
}
private void checkForPreinstallI() {
ActivityState activityState2 = this.activityState;
if (activityState2 != null && activityState2.enabled && !activityState2.isGdprForgotten && this.adjustConfig.preinstallTrackingEnabled && !this.internalState.hasPreinstallBeenRead()) {
String str = this.deviceInfo.packageName;
if (str == null || str.isEmpty()) {
this.logger.debug("Can't read preinstall payload, invalid package name", new Object[0]);
return;
}
SharedPreferencesManager sharedPreferencesManager = new SharedPreferencesManager(getContext());
long preinstallPayloadReadStatus = sharedPreferencesManager.getPreinstallPayloadReadStatus();
if (PreinstallUtil.hasAllLocationsBeenRead(preinstallPayloadReadStatus)) {
this.internalState.preinstallHasBeenRead = true;
return;
}
if (PreinstallUtil.hasNotBeenRead(Constants.SYSTEM_PROPERTIES, preinstallPayloadReadStatus)) {
String payloadFromSystemProperty = PreinstallUtil.getPayloadFromSystemProperty(this.deviceInfo.packageName, this.logger);
if (payloadFromSystemProperty == null || payloadFromSystemProperty.isEmpty()) {
preinstallPayloadReadStatus = PreinstallUtil.markAsRead(Constants.SYSTEM_PROPERTIES, preinstallPayloadReadStatus);
} else {
this.sdkClickHandler.sendPreinstallPayload(payloadFromSystemProperty, Constants.SYSTEM_PROPERTIES);
}
}
if (PreinstallUtil.hasNotBeenRead(Constants.SYSTEM_PROPERTIES_REFLECTION, preinstallPayloadReadStatus)) {
String payloadFromSystemPropertyReflection = PreinstallUtil.getPayloadFromSystemPropertyReflection(this.deviceInfo.packageName, this.logger);
if (payloadFromSystemPropertyReflection == null || payloadFromSystemPropertyReflection.isEmpty()) {
preinstallPayloadReadStatus = PreinstallUtil.markAsRead(Constants.SYSTEM_PROPERTIES_REFLECTION, preinstallPayloadReadStatus);
} else {
this.sdkClickHandler.sendPreinstallPayload(payloadFromSystemPropertyReflection, Constants.SYSTEM_PROPERTIES_REFLECTION);
}
}
if (PreinstallUtil.hasNotBeenRead(Constants.SYSTEM_PROPERTIES_PATH, preinstallPayloadReadStatus)) {
String payloadFromSystemPropertyFilePath = PreinstallUtil.getPayloadFromSystemPropertyFilePath(this.deviceInfo.packageName, this.logger);
if (payloadFromSystemPropertyFilePath == null || payloadFromSystemPropertyFilePath.isEmpty()) {
preinstallPayloadReadStatus = PreinstallUtil.markAsRead(Constants.SYSTEM_PROPERTIES_PATH, preinstallPayloadReadStatus);
} else {
this.sdkClickHandler.sendPreinstallPayload(payloadFromSystemPropertyFilePath, Constants.SYSTEM_PROPERTIES_PATH);
}
}
if (PreinstallUtil.hasNotBeenRead(Constants.SYSTEM_PROPERTIES_PATH_REFLECTION, preinstallPayloadReadStatus)) {
String payloadFromSystemPropertyFilePathReflection = PreinstallUtil.getPayloadFromSystemPropertyFilePathReflection(this.deviceInfo.packageName, this.logger);
if (payloadFromSystemPropertyFilePathReflection == null || payloadFromSystemPropertyFilePathReflection.isEmpty()) {
preinstallPayloadReadStatus = PreinstallUtil.markAsRead(Constants.SYSTEM_PROPERTIES_PATH_REFLECTION, preinstallPayloadReadStatus);
} else {
this.sdkClickHandler.sendPreinstallPayload(payloadFromSystemPropertyFilePathReflection, Constants.SYSTEM_PROPERTIES_PATH_REFLECTION);
}
}
if (PreinstallUtil.hasNotBeenRead(Constants.CONTENT_PROVIDER, preinstallPayloadReadStatus)) {
String payloadFromContentProviderDefault = PreinstallUtil.getPayloadFromContentProviderDefault(this.adjustConfig.context, this.deviceInfo.packageName, this.logger);
if (payloadFromContentProviderDefault == null || payloadFromContentProviderDefault.isEmpty()) {
preinstallPayloadReadStatus = PreinstallUtil.markAsRead(Constants.CONTENT_PROVIDER, preinstallPayloadReadStatus);
} else {
this.sdkClickHandler.sendPreinstallPayload(payloadFromContentProviderDefault, Constants.CONTENT_PROVIDER);
}
}
if (PreinstallUtil.hasNotBeenRead(Constants.CONTENT_PROVIDER_INTENT_ACTION, preinstallPayloadReadStatus)) {
List<String> payloadsFromContentProviderIntentAction = PreinstallUtil.getPayloadsFromContentProviderIntentAction(this.adjustConfig.context, this.deviceInfo.packageName, this.logger);
if (payloadsFromContentProviderIntentAction == null || payloadsFromContentProviderIntentAction.isEmpty()) {
preinstallPayloadReadStatus = PreinstallUtil.markAsRead(Constants.CONTENT_PROVIDER_INTENT_ACTION, preinstallPayloadReadStatus);
} else {
for (String str2 : payloadsFromContentProviderIntentAction) {
this.sdkClickHandler.sendPreinstallPayload(str2, Constants.CONTENT_PROVIDER_INTENT_ACTION);
}
}
}
if (PreinstallUtil.hasNotBeenRead(Constants.FILE_SYSTEM, preinstallPayloadReadStatus)) {
String payloadFromFileSystem = PreinstallUtil.getPayloadFromFileSystem(this.deviceInfo.packageName, this.logger);
if (payloadFromFileSystem == null || payloadFromFileSystem.isEmpty()) {
preinstallPayloadReadStatus = PreinstallUtil.markAsRead(Constants.FILE_SYSTEM, preinstallPayloadReadStatus);
} else {
this.sdkClickHandler.sendPreinstallPayload(payloadFromFileSystem, Constants.FILE_SYSTEM);
}
}
sharedPreferencesManager.setPreinstallPayloadReadStatus(preinstallPayloadReadStatus);
this.internalState.preinstallHasBeenRead = true;
}
}
private boolean checkOrderIdI(String str) {
if (str != null && !str.isEmpty()) {
if (this.activityState.findOrderId(str)) {
this.logger.info("Skipping duplicated order ID '%s'", str);
return false;
}
this.activityState.addOrderId(str);
this.logger.verbose("Added order ID '%s'", str);
}
return true;
}
private Intent createDeeplinkIntentI(Uri uri) {
Intent intent;
if (this.adjustConfig.deepLinkComponent == null) {
intent = new Intent(CommonConstant.ACTION.HWID_SCHEME_URL, uri);
} else {
AdjustConfig adjustConfig2 = this.adjustConfig;
intent = new Intent(CommonConstant.ACTION.HWID_SCHEME_URL, uri, adjustConfig2.context, adjustConfig2.deepLinkComponent);
}
intent.setFlags(SQLiteDatabase.CREATE_IF_NECESSARY);
intent.setPackage(this.adjustConfig.context.getPackageName());
return intent;
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void delayStartI() {
if (!this.internalState.isNotInDelayedStart() && !isToUpdatePackagesI()) {
Double d14 = this.adjustConfig.delayStart;
double doubleValue = d14 != null ? d14.doubleValue() : 0.0d;
long maxDelayStart = AdjustFactory.getMaxDelayStart();
long j14 = (long) (1000.0d * doubleValue);
if (j14 > maxDelayStart) {
double d15 = (double) (maxDelayStart / 1000);
DecimalFormat decimalFormat = Util.SecondsDisplayFormat;
this.logger.warn("Delay start of %s seconds bigger than max allowed value of %s seconds", decimalFormat.format(doubleValue), decimalFormat.format(d15));
doubleValue = d15;
} else {
maxDelayStart = j14;
}
this.logger.info("Waiting %s seconds before starting first session", Util.SecondsDisplayFormat.format(doubleValue));
this.delayStartTimer.startIn(maxDelayStart);
this.internalState.updatePackages = true;
ActivityState activityState2 = this.activityState;
if (activityState2 != null) {
activityState2.updatePackages = true;
writeActivityStateI();
}
}
}
public static boolean deleteActivityState(Context context) {
return context.deleteFile(Constants.ACTIVITY_STATE_FILENAME);
}
public static boolean deleteAttribution(Context context) {
return context.deleteFile(Constants.ATTRIBUTION_FILENAME);
}
public static boolean deleteSessionCallbackParameters(Context context) {
return context.deleteFile(Constants.SESSION_CALLBACK_PARAMETERS_FILENAME);
}
public static boolean deleteSessionPartnerParameters(Context context) {
return context.deleteFile(Constants.SESSION_PARTNER_PARAMETERS_FILENAME);
}
public static void deleteState(Context context) {
deleteActivityState(context);
deleteAttribution(context);
deleteSessionCallbackParameters(context);
deleteSessionPartnerParameters(context);
new SharedPreferencesManager(context).clear();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void disableThirdPartySharingI() {
SharedPreferencesManager sharedPreferencesManager = new SharedPreferencesManager(getContext());
sharedPreferencesManager.setDisableThirdPartySharing();
if (checkActivityStateI(this.activityState) && isEnabledI()) {
ActivityState activityState2 = this.activityState;
if (!activityState2.isGdprForgotten && !activityState2.isThirdPartySharingDisabled) {
activityState2.isThirdPartySharingDisabled = true;
writeActivityStateI();
ActivityPackage buildDisableThirdPartySharingPackage = new PackageBuilder(this.adjustConfig, this.deviceInfo, this.activityState, this.sessionParameters, System.currentTimeMillis()).buildDisableThirdPartySharingPackage();
this.packageHandler.addPackage(buildDisableThirdPartySharingPackage);
sharedPreferencesManager.removeDisableThirdPartySharing();
if (this.adjustConfig.eventBufferingEnabled) {
this.logger.info("Buffered event %s", buildDisableThirdPartySharingPackage.getSuffix());
return;
}
this.packageHandler.sendFirstPackage();
}
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void endI() {
if (!toSendI()) {
pauseSendingI();
}
if (updateActivityStateI(System.currentTimeMillis())) {
writeActivityStateI();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void foregroundTimerFiredI() {
if (!isEnabledI()) {
stopForegroundTimerI();
return;
}
if (toSendI()) {
this.packageHandler.sendFirstPackage();
}
if (updateActivityStateI(System.currentTimeMillis())) {
writeActivityStateI();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void gdprForgetMeI() {
if (checkActivityStateI(this.activityState) && isEnabledI()) {
ActivityState activityState2 = this.activityState;
if (!activityState2.isGdprForgotten) {
activityState2.isGdprForgotten = true;
writeActivityStateI();
ActivityPackage buildGdprPackage = new PackageBuilder(this.adjustConfig, this.deviceInfo, this.activityState, this.sessionParameters, System.currentTimeMillis()).buildGdprPackage();
this.packageHandler.addPackage(buildGdprPackage);
new SharedPreferencesManager(getContext()).removeGdprForgetMe();
if (this.adjustConfig.eventBufferingEnabled) {
this.logger.info("Buffered event %s", buildGdprPackage.getSuffix());
return;
}
this.packageHandler.sendFirstPackage();
}
}
}
private String getAppVersion(Context context) {
try {
return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
} catch (Exception unused) {
return null;
}
}
public static ActivityHandler getInstance(AdjustConfig adjustConfig2) {
if (adjustConfig2 == null) {
AdjustFactory.getLogger().error("AdjustConfig missing", new Object[0]);
return null;
} else if (!adjustConfig2.isValid()) {
AdjustFactory.getLogger().error("AdjustConfig not initialized correctly", new Object[0]);
return null;
} else {
if (adjustConfig2.processName != null) {
int myPid = Process.myPid();
ActivityManager activityManager = (ActivityManager) adjustConfig2.context.getSystemService("activity");
if (activityManager != null) {
Iterator<ActivityManager.RunningAppProcessInfo> it3 = activityManager.getRunningAppProcesses().iterator();
while (true) {
if (!it3.hasNext()) {
break;
}
ActivityManager.RunningAppProcessInfo next = it3.next();
if (next.pid == myPid) {
if (!next.processName.equalsIgnoreCase(adjustConfig2.processName)) {
AdjustFactory.getLogger().info("Skipping initialization in background process (%s)", next.processName);
return null;
}
}
}
} else {
return null;
}
}
return new ActivityHandler(adjustConfig2);
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void gotOptOutResponseI() {
this.activityState.isGdprForgotten = true;
writeActivityStateI();
this.packageHandler.flush();
setEnabledI(false);
}
private boolean hasChangedStateI(boolean z14, boolean z15, String str, String str2) {
if (z14 != z15) {
return true;
}
if (z14) {
this.logger.debug(str, new Object[0]);
} else {
this.logger.debug(str2, new Object[0]);
}
return false;
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void initI() {
Double d14;
SESSION_INTERVAL = AdjustFactory.getSessionInterval();
SUBSESSION_INTERVAL = AdjustFactory.getSubsessionInterval();
FOREGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
FOREGROUND_TIMER_START = AdjustFactory.getTimerStart();
BACKGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
readAttributionI(this.adjustConfig.context);
readActivityStateI(this.adjustConfig.context);
this.sessionParameters = new SessionParameters();
readSessionCallbackParametersI(this.adjustConfig.context);
readSessionPartnerParametersI(this.adjustConfig.context);
AdjustConfig adjustConfig2 = this.adjustConfig;
if (adjustConfig2.startEnabled != null) {
if (adjustConfig2.preLaunchActionsArray == null) {
adjustConfig2.preLaunchActionsArray = new ArrayList();
}
this.adjustConfig.preLaunchActionsArray.add(new IRunActivityHandler() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass30 */
@Override // com.adjust.sdk.IRunActivityHandler
public void run(ActivityHandler activityHandler) {
activityHandler.setEnabledI(ActivityHandler.this.adjustConfig.startEnabled.booleanValue());
}
});
}
if (this.internalState.hasFirstSdkStartOcurred()) {
InternalState internalState2 = this.internalState;
ActivityState activityState2 = this.activityState;
internalState2.enabled = activityState2.enabled;
internalState2.updatePackages = activityState2.updatePackages;
internalState2.firstLaunch = false;
} else {
this.internalState.firstLaunch = true;
}
readConfigFile(this.adjustConfig.context);
AdjustConfig adjustConfig3 = this.adjustConfig;
this.deviceInfo = new DeviceInfo(adjustConfig3.context, adjustConfig3.sdkPrefix);
if (this.adjustConfig.eventBufferingEnabled) {
this.logger.info("Event buffering is enabled", new Object[0]);
}
this.deviceInfo.reloadPlayIds(this.adjustConfig.context);
if (this.deviceInfo.playAdId == null) {
this.logger.warn("Unable to get Google Play Services Advertising ID at start time", new Object[0]);
DeviceInfo deviceInfo2 = this.deviceInfo;
if (deviceInfo2.macSha1 == null && deviceInfo2.macShortMd5 == null && deviceInfo2.androidId == null) {
this.logger.error("Unable to get any device id's. Please check if Proguard is correctly set with Adjust SDK", new Object[0]);
}
} else {
this.logger.info("Google Play Services Advertising ID read correctly at start time", new Object[0]);
}
String str = this.adjustConfig.defaultTracker;
if (str != null) {
this.logger.info("Default tracker: '%s'", str);
}
String str2 = this.adjustConfig.pushToken;
if (str2 != null) {
this.logger.info("Push token: '%s'", str2);
if (this.internalState.hasFirstSdkStartOcurred()) {
setPushToken(this.adjustConfig.pushToken, false);
} else {
new SharedPreferencesManager(getContext()).savePushToken(this.adjustConfig.pushToken);
}
} else if (this.internalState.hasFirstSdkStartOcurred()) {
setPushToken(new SharedPreferencesManager(getContext()).getPushToken(), true);
}
if (this.internalState.hasFirstSdkStartOcurred()) {
SharedPreferencesManager sharedPreferencesManager = new SharedPreferencesManager(getContext());
if (sharedPreferencesManager.getGdprForgetMe()) {
gdprForgetMe();
} else if (sharedPreferencesManager.getDisableThirdPartySharing()) {
disableThirdPartySharing();
}
}
this.foregroundTimer = new TimerCycle(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass31 */
public void run() {
ActivityHandler.this.foregroundTimerFired();
}
}, FOREGROUND_TIMER_START, FOREGROUND_TIMER_INTERVAL, FOREGROUND_TIMER_NAME);
if (this.adjustConfig.sendInBackground) {
this.logger.info("Send in background configured", new Object[0]);
this.backgroundTimer = new TimerOnce(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass32 */
public void run() {
ActivityHandler.this.backgroundTimerFired();
}
}, BACKGROUND_TIMER_NAME);
}
if (this.internalState.hasFirstSdkStartNotOcurred() && (d14 = this.adjustConfig.delayStart) != null && d14.doubleValue() > 0.0d) {
this.logger.info("Delay start configured", new Object[0]);
this.internalState.delayStart = true;
this.delayStartTimer = new TimerOnce(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass33 */
public void run() {
ActivityHandler.this.sendFirstPackages();
}
}, DELAY_START_TIMER_NAME);
}
UtilNetworking.setUserAgent(this.adjustConfig.userAgent);
AdjustConfig adjustConfig4 = this.adjustConfig;
this.basePath = adjustConfig4.basePath;
this.gdprPath = adjustConfig4.gdprPath;
this.unbotifyPath = adjustConfig4.unbotifyPath;
this.subscriptionPath = adjustConfig4.subscriptionPath;
this.packageHandler = AdjustFactory.getPackageHandler(this, adjustConfig4.context, toSendI(false));
this.attributionHandler = AdjustFactory.getAttributionHandler(this, toSendI(false));
this.sdkClickHandler = AdjustFactory.getSdkClickHandler(this, toSendI(true));
if (isToUpdatePackagesI()) {
updatePackagesI();
}
this.installReferrer = new InstallReferrer(this.adjustConfig.context, new InstallReferrerReadListener() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass34 */
@Override // com.adjust.sdk.InstallReferrerReadListener
public void onInstallReferrerRead(ReferrerDetails referrerDetails) {
ActivityHandler.this.sendInstallReferrer(referrerDetails, Constants.REFERRER_API_GOOGLE);
}
});
this.installReferrerHuawei = new InstallReferrerHuawei(this.adjustConfig.context, new InstallReferrerReadListener() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass35 */
@Override // com.adjust.sdk.InstallReferrerReadListener
public void onInstallReferrerRead(ReferrerDetails referrerDetails) {
ActivityHandler.this.sendInstallReferrer(referrerDetails, "huawei");
}
});
preLaunchActionsI(this.adjustConfig.preLaunchActionsArray);
sendReftagReferrerI();
}
private void initUnbotify() {
IUnbotifyHandler unbotifyHandler2 = AdjustFactory.getUnbotifyHandler(this);
this.unbotifyHandler = unbotifyHandler2;
AdjustConfig adjustConfig2 = this.adjustConfig;
Context context = adjustConfig2.context;
Unbotify.init(context, unbotifyHandler2, adjustConfig2.appToken, UnbotifyUtil.buildConfig(adjustConfig2, getAppVersion(context)));
this.adjustConfig.setSessionId(Unbotify.getSessionId());
}
private boolean isEnabledI() {
ActivityState activityState2 = this.activityState;
return activityState2 != null ? activityState2.enabled : this.internalState.isEnabled();
}
private boolean isToUpdatePackagesI() {
ActivityState activityState2 = this.activityState;
return activityState2 != null ? activityState2.updatePackages : this.internalState.itHasToUpdatePackages();
}
private boolean isValidReferrerDetails(ReferrerDetails referrerDetails) {
String str;
return (referrerDetails == null || (str = referrerDetails.installReferrer) == null || str.length() == 0) ? false : true;
}
private void launchAttributionListenerI(Handler handler) {
if (this.adjustConfig.onAttributionChangedListener != null) {
handler.post(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass40 */
public void run() {
if (ActivityHandler.this.adjustConfig != null && ActivityHandler.this.adjustConfig.onAttributionChangedListener != null) {
ActivityHandler.this.adjustConfig.onAttributionChangedListener.onAttributionChanged(ActivityHandler.this.attribution);
}
}
});
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void launchAttributionResponseTasksI(AttributionResponseData attributionResponseData) {
updateAdidI(attributionResponseData.adid);
Handler handler = new Handler(this.adjustConfig.context.getMainLooper());
if (updateAttributionI(attributionResponseData.attribution)) {
launchAttributionListenerI(handler);
}
prepareDeeplinkI(attributionResponseData.deeplink, handler);
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void launchDeeplinkMain(Intent intent, Uri uri) {
if (!(e.f(this.adjustConfig.context.getPackageManager(), intent, 0).size() > 0)) {
this.logger.error("Unable to open deferred deep link (%s)", uri);
return;
}
this.logger.info("Open deferred deep link (%s)", uri);
this.adjustConfig.context.startActivity(intent);
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void launchEventResponseTasksI(final EventResponseData eventResponseData) {
Runnable r14;
updateAdidI(eventResponseData.adid);
Handler handler = new Handler(this.adjustConfig.context.getMainLooper());
boolean z14 = eventResponseData.success;
if (z14 && this.adjustConfig.onEventTrackingSucceededListener != null) {
this.logger.debug("Launching success event tracking listener", new Object[0]);
r14 = new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass36 */
public void run() {
if (ActivityHandler.this.adjustConfig != null && ActivityHandler.this.adjustConfig.onEventTrackingSucceededListener != null) {
ActivityHandler.this.adjustConfig.onEventTrackingSucceededListener.onFinishedEventTrackingSucceeded(eventResponseData.getSuccessResponseData());
}
}
};
} else if (!z14 && this.adjustConfig.onEventTrackingFailedListener != null) {
this.logger.debug("Launching failed event tracking listener", new Object[0]);
r14 = new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass37 */
public void run() {
if (ActivityHandler.this.adjustConfig != null && ActivityHandler.this.adjustConfig.onEventTrackingFailedListener != null) {
ActivityHandler.this.adjustConfig.onEventTrackingFailedListener.onFinishedEventTrackingFailed(eventResponseData.getFailureResponseData());
}
}
};
} else {
return;
}
handler.post(r14);
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void launchSdkClickResponseTasksI(SdkClickResponseData sdkClickResponseData) {
updateAdidI(sdkClickResponseData.adid);
Handler handler = new Handler(this.adjustConfig.context.getMainLooper());
if (updateAttributionI(sdkClickResponseData.attribution)) {
launchAttributionListenerI(handler);
}
}
private void launchSessionResponseListenerI(final SessionResponseData sessionResponseData, Handler handler) {
Runnable r04;
boolean z14 = sessionResponseData.success;
if (z14 && this.adjustConfig.onSessionTrackingSucceededListener != null) {
this.logger.debug("Launching success session tracking listener", new Object[0]);
r04 = new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass38 */
public void run() {
if (ActivityHandler.this.adjustConfig != null && ActivityHandler.this.adjustConfig.onSessionTrackingSucceededListener != null) {
ActivityHandler.this.adjustConfig.onSessionTrackingSucceededListener.onFinishedSessionTrackingSucceeded(sessionResponseData.getSuccessResponseData());
}
}
};
} else if (!z14 && this.adjustConfig.onSessionTrackingFailedListener != null) {
this.logger.debug("Launching failed session tracking listener", new Object[0]);
r04 = new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass39 */
public void run() {
if (ActivityHandler.this.adjustConfig != null && ActivityHandler.this.adjustConfig.onSessionTrackingFailedListener != null) {
ActivityHandler.this.adjustConfig.onSessionTrackingFailedListener.onFinishedSessionTrackingFailed(sessionResponseData.getFailureResponseData());
}
}
};
} else {
return;
}
handler.post(r04);
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void launchSessionResponseTasksI(SessionResponseData sessionResponseData) {
updateAdidI(sessionResponseData.adid);
Handler handler = new Handler(this.adjustConfig.context.getMainLooper());
if (updateAttributionI(sessionResponseData.attribution)) {
launchAttributionListenerI(handler);
}
if (this.attribution == null && !this.activityState.askingAttribution) {
this.attributionHandler.getAttribution();
}
if (sessionResponseData.success) {
new SharedPreferencesManager(getContext()).setInstallTracked();
}
launchSessionResponseListenerI(sessionResponseData, handler);
this.internalState.sessionResponseProcessed = true;
}
private void pauseSendingI() {
this.attributionHandler.pauseSending();
this.packageHandler.pauseSending();
if (!toSendI(true)) {
this.sdkClickHandler.pauseSending();
this.unbotifyHandler.pauseSending();
return;
}
this.sdkClickHandler.resumeSending();
this.unbotifyHandler.resumeSending();
}
private boolean pausedI() {
return pausedI(false);
}
private boolean pausedI(boolean z14) {
return z14 ? this.internalState.isOffline() || !isEnabledI() : this.internalState.isOffline() || !isEnabledI() || this.internalState.isInDelayedStart();
}
private void preLaunchActionsI(List<IRunActivityHandler> list) {
if (list != null) {
for (IRunActivityHandler iRunActivityHandler : list) {
iRunActivityHandler.run(this);
}
}
}
private void prepareDeeplinkI(final Uri uri, Handler handler) {
if (uri != null) {
this.logger.info("Deferred deeplink received (%s)", uri);
final Intent createDeeplinkIntentI = createDeeplinkIntentI(uri);
handler.post(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass41 */
public void run() {
if (ActivityHandler.this.adjustConfig != null) {
boolean z14 = true;
if (ActivityHandler.this.adjustConfig.onDeeplinkResponseListener != null) {
z14 = ActivityHandler.this.adjustConfig.onDeeplinkResponseListener.launchReceivedDeeplink(uri);
}
if (z14) {
ActivityHandler.this.launchDeeplinkMain(createDeeplinkIntentI, uri);
}
}
}
});
}
}
private void processCachedDeeplinkI() {
if (checkActivityStateI(this.activityState)) {
SharedPreferencesManager sharedPreferencesManager = new SharedPreferencesManager(getContext());
String deeplinkUrl = sharedPreferencesManager.getDeeplinkUrl();
long deeplinkClickTime = sharedPreferencesManager.getDeeplinkClickTime();
if (deeplinkUrl != null && deeplinkClickTime != -1) {
readOpenUrl(Uri.parse(deeplinkUrl), deeplinkClickTime);
sharedPreferencesManager.removeDeeplink();
}
}
}
private void processSessionI() {
if (!this.activityState.isGdprForgotten) {
long currentTimeMillis = System.currentTimeMillis();
ActivityState activityState2 = this.activityState;
long j14 = currentTimeMillis - activityState2.lastActivity;
if (j14 < 0) {
this.logger.error(TIME_TRAVEL, new Object[0]);
this.activityState.lastActivity = currentTimeMillis;
writeActivityStateI();
} else if (j14 > SESSION_INTERVAL) {
trackNewSessionI(currentTimeMillis);
checkAfterNewStartI();
} else if (j14 > SUBSESSION_INTERVAL) {
int i10 = activityState2.subsessionCount + 1;
activityState2.subsessionCount = i10;
activityState2.sessionLength += j14;
activityState2.lastActivity = currentTimeMillis;
this.logger.verbose("Started subsession %d of session %d", Integer.valueOf(i10), Integer.valueOf(this.activityState.sessionCount));
writeActivityStateI();
this.installReferrer.startConnection();
this.installReferrerHuawei.readReferrer();
} else {
this.logger.verbose("Time span since last activity too short for a new subsession", new Object[0]);
}
}
}
private void readActivityStateI(Context context) {
try {
this.activityState = (ActivityState) Util.readObject(context, Constants.ACTIVITY_STATE_FILENAME, ACTIVITY_STATE_NAME, ActivityState.class);
} catch (Exception e14) {
this.logger.error("Failed to read %s file (%s)", ACTIVITY_STATE_NAME, e14.getMessage());
this.activityState = null;
}
if (this.activityState != null) {
this.internalState.firstSdkStart = true;
}
}
private void readAttributionI(Context context) {
try {
this.attribution = (AdjustAttribution) Util.readObject(context, Constants.ATTRIBUTION_FILENAME, ATTRIBUTION_NAME, AdjustAttribution.class);
} catch (Exception e14) {
this.logger.error("Failed to read %s file (%s)", ATTRIBUTION_NAME, e14.getMessage());
this.attribution = null;
}
}
private void readConfigFile(Context context) {
try {
InputStream open = context.getAssets().open("adjust_config.properties");
Properties properties = new Properties();
properties.load(open);
this.logger.verbose("adjust_config.properties file read and loaded", new Object[0]);
String property = properties.getProperty("defaultTracker");
if (property != null) {
this.adjustConfig.defaultTracker = property;
}
} catch (Exception e14) {
this.logger.debug("%s file not found in this app", e14.getMessage());
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void readOpenUrlI(Uri uri, long j14) {
if (isEnabledI()) {
if (Util.isUrlFilteredOut(uri)) {
ILogger iLogger = this.logger;
iLogger.debug("Deep link (" + uri.toString() + ") processing skipped", new Object[0]);
return;
}
ActivityPackage buildDeeplinkSdkClickPackage = PackageFactory.buildDeeplinkSdkClickPackage(uri, j14, this.activityState, this.adjustConfig, this.deviceInfo, this.sessionParameters);
if (buildDeeplinkSdkClickPackage != null) {
this.sdkClickHandler.sendSdkClick(buildDeeplinkSdkClickPackage);
}
}
}
private void readSessionCallbackParametersI(Context context) {
try {
this.sessionParameters.callbackParameters = (Map) Util.readObject(context, Constants.SESSION_CALLBACK_PARAMETERS_FILENAME, SESSION_CALLBACK_PARAMETERS_NAME, Map.class);
} catch (Exception e14) {
this.logger.error("Failed to read %s file (%s)", SESSION_CALLBACK_PARAMETERS_NAME, e14.getMessage());
this.sessionParameters.callbackParameters = null;
}
}
private void readSessionPartnerParametersI(Context context) {
try {
this.sessionParameters.partnerParameters = (Map) Util.readObject(context, Constants.SESSION_PARTNER_PARAMETERS_FILENAME, SESSION_PARTNER_PARAMETERS_NAME, Map.class);
} catch (Exception e14) {
this.logger.error("Failed to read %s file (%s)", SESSION_PARTNER_PARAMETERS_NAME, e14.getMessage());
this.sessionParameters.partnerParameters = null;
}
}
private void resumeSendingI() {
this.attributionHandler.resumeSending();
this.packageHandler.resumeSending();
this.sdkClickHandler.resumeSending();
this.unbotifyHandler.resumeSending();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void sendFirstPackagesI() {
if (this.internalState.isNotInDelayedStart()) {
this.logger.info("Start delay expired or never configured", new Object[0]);
return;
}
updatePackagesI();
this.internalState.delayStart = false;
this.delayStartTimer.cancel();
this.delayStartTimer = null;
updateHandlersStatusAndSendI();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void sendInstallReferrerI(ReferrerDetails referrerDetails, String str) {
if (isEnabledI() && isValidReferrerDetails(referrerDetails) && !Util.isEqualReferrerDetails(referrerDetails, str, this.activityState)) {
this.sdkClickHandler.sendSdkClick(PackageFactory.buildInstallReferrerSdkClickPackage(referrerDetails, str, this.activityState, this.adjustConfig, this.deviceInfo, this.sessionParameters));
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void sendReftagReferrerI() {
if (isEnabledI() && !this.internalState.hasFirstSdkStartNotOcurred()) {
this.sdkClickHandler.sendReftagReferrers();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void setAskingAttributionI(boolean z14) {
this.activityState.askingAttribution = z14;
writeActivityStateI();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void setEnabledI(boolean z14) {
ActivityState activityState2;
if (hasChangedStateI(isEnabledI(), z14, "Adjust already enabled", "Adjust already disabled")) {
if (!z14 || (activityState2 = this.activityState) == null || !activityState2.isGdprForgotten) {
InternalState internalState2 = this.internalState;
internalState2.enabled = z14;
if (internalState2.hasFirstSdkStartNotOcurred()) {
updateStatusI(!z14, "Handlers will start as paused due to the SDK being disabled", "Handlers will still start as paused", "Handlers will start as active due to the SDK being enabled");
return;
}
this.activityState.enabled = z14;
writeActivityStateI();
if (z14) {
SharedPreferencesManager sharedPreferencesManager = new SharedPreferencesManager(getContext());
if (sharedPreferencesManager.getGdprForgetMe()) {
gdprForgetMeI();
} else if (sharedPreferencesManager.getDisableThirdPartySharing()) {
disableThirdPartySharingI();
}
if (!sharedPreferencesManager.getInstallTracked()) {
trackNewSessionI(System.currentTimeMillis());
}
checkAfterNewStartI(sharedPreferencesManager);
}
updateStatusI(!z14, "Pausing handlers due to SDK being disabled", "Handlers remain paused", "Resuming handlers due to SDK being enabled");
return;
}
this.logger.error("Re-enabling SDK not possible for forgotten user", new Object[0]);
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void setOfflineModeI(boolean z14) {
String str;
String str2;
String str3;
if (hasChangedStateI(this.internalState.isOffline(), z14, "Adjust already in offline mode", "Adjust already in online mode")) {
InternalState internalState2 = this.internalState;
internalState2.offline = z14;
if (internalState2.hasFirstSdkStartNotOcurred()) {
str = "Handlers will start paused due to SDK being offline";
str2 = "Handlers will still start as paused";
str3 = "Handlers will start as active due to SDK being online";
} else {
str = "Pausing handlers to put SDK offline mode";
str2 = "Handlers remain paused";
str3 = "Resuming handlers to put SDK in online mode";
}
updateStatusI(z14, str, str2, str3);
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void setPushTokenI(String str) {
if (checkActivityStateI(this.activityState) && isEnabledI()) {
ActivityState activityState2 = this.activityState;
if (!activityState2.isGdprForgotten && str != null && !str.equals(activityState2.pushToken)) {
this.activityState.pushToken = str;
writeActivityStateI();
ActivityPackage buildInfoPackage = new PackageBuilder(this.adjustConfig, this.deviceInfo, this.activityState, this.sessionParameters, System.currentTimeMillis()).buildInfoPackage("push");
this.packageHandler.addPackage(buildInfoPackage);
new SharedPreferencesManager(getContext()).removePushToken();
if (this.adjustConfig.eventBufferingEnabled) {
this.logger.info("Buffered event %s", buildInfoPackage.getSuffix());
return;
}
this.packageHandler.sendFirstPackage();
}
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void startBackgroundTimerI() {
if (this.backgroundTimer != null && toSendI() && this.backgroundTimer.getFireIn() <= 0) {
this.backgroundTimer.startIn(BACKGROUND_TIMER_INTERVAL);
}
}
private void startFirstSessionI() {
this.activityState = new ActivityState();
this.internalState.firstSdkStart = true;
updateHandlersStatusAndSendI();
long currentTimeMillis = System.currentTimeMillis();
SharedPreferencesManager sharedPreferencesManager = new SharedPreferencesManager(getContext());
this.activityState.pushToken = sharedPreferencesManager.getPushToken();
if (this.internalState.isEnabled()) {
if (sharedPreferencesManager.getGdprForgetMe()) {
gdprForgetMeI();
} else {
if (sharedPreferencesManager.getDisableThirdPartySharing()) {
disableThirdPartySharingI();
}
this.activityState.sessionCount = 1;
transferSessionPackageI(currentTimeMillis);
checkAfterNewStartI(sharedPreferencesManager);
}
}
this.activityState.resetSessionAttributes(currentTimeMillis);
this.activityState.enabled = this.internalState.isEnabled();
this.activityState.updatePackages = this.internalState.itHasToUpdatePackages();
writeActivityStateI();
sharedPreferencesManager.removePushToken();
sharedPreferencesManager.removeGdprForgetMe();
sharedPreferencesManager.removeDisableThirdPartySharing();
processCachedDeeplinkI();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void startForegroundTimerI() {
if (isEnabledI()) {
this.foregroundTimer.start();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void startI() {
if (this.internalState.hasFirstSdkStartNotOcurred()) {
AdjustSigner.onResume(this.adjustConfig.logger);
startFirstSessionI();
} else if (this.activityState.enabled) {
AdjustSigner.onResume(this.adjustConfig.logger);
updateHandlersStatusAndSendI();
processSessionI();
checkAttributionStateI();
processCachedDeeplinkI();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void stopBackgroundTimerI() {
TimerOnce timerOnce = this.backgroundTimer;
if (timerOnce != null) {
timerOnce.cancel();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void stopForegroundTimerI() {
this.foregroundTimer.suspend();
}
private void teardownActivityStateS() {
synchronized (ActivityState.class) {
if (this.activityState != null) {
this.activityState = null;
}
}
}
private void teardownAllSessionParametersS() {
synchronized (SessionParameters.class) {
if (this.sessionParameters != null) {
this.sessionParameters = null;
}
}
}
private void teardownAttributionS() {
synchronized (AdjustAttribution.class) {
if (this.attribution != null) {
this.attribution = null;
}
}
}
private boolean toSendI() {
return toSendI(false);
}
private boolean toSendI(boolean z14) {
if (pausedI(z14)) {
return false;
}
if (this.adjustConfig.sendInBackground) {
return true;
}
return this.internalState.isInForeground();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void trackAdRevenueI(String str, JSONObject jSONObject) {
if (checkActivityStateI(this.activityState) && isEnabledI() && !this.activityState.isGdprForgotten) {
this.packageHandler.addPackage(new PackageBuilder(this.adjustConfig, this.deviceInfo, this.activityState, this.sessionParameters, System.currentTimeMillis()).buildAdRevenuePackage(str, jSONObject));
this.packageHandler.sendFirstPackage();
}
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void trackEventI(AdjustEvent adjustEvent) {
if (checkActivityStateI(this.activityState) && isEnabledI() && checkEventI(adjustEvent) && checkOrderIdI(adjustEvent.orderId) && !this.activityState.isGdprForgotten) {
long currentTimeMillis = System.currentTimeMillis();
this.activityState.eventCount++;
updateActivityStateI(currentTimeMillis);
ActivityPackage buildEventPackage = new PackageBuilder(this.adjustConfig, this.deviceInfo, this.activityState, this.sessionParameters, currentTimeMillis).buildEventPackage(adjustEvent, this.internalState.isInDelayedStart());
this.packageHandler.addPackage(buildEventPackage);
if (this.adjustConfig.eventBufferingEnabled) {
this.logger.info("Buffered event %s", buildEventPackage.getSuffix());
} else {
this.packageHandler.sendFirstPackage();
}
if (this.adjustConfig.sendInBackground && this.internalState.isInBackground()) {
startBackgroundTimerI();
}
writeActivityStateI();
}
}
private void trackNewSessionI(long j14) {
ActivityState activityState2 = this.activityState;
activityState2.sessionCount++;
activityState2.lastInterval = j14 - activityState2.lastActivity;
transferSessionPackageI(j14);
this.activityState.resetSessionAttributes(j14);
writeActivityStateI();
}
/* access modifiers changed from: private */
/* access modifiers changed from: public */
private void trackSubscriptionI(AdjustPlayStoreSubscription adjustPlayStoreSubscription) {
if (checkActivityStateI(this.activityState) && isEnabledI() && !this.activityState.isGdprForgotten) {
this.packageHandler.addPackage(new PackageBuilder(this.adjustConfig, this.deviceInfo, this.activityState, this.sessionParameters, System.currentTimeMillis()).buildSubscriptionPackage(adjustPlayStoreSubscription, this.internalState.isInDelayedStart()));
this.packageHandler.sendFirstPackage();
}
}
private void transferSessionPackageI(long j14) {
this.packageHandler.addPackage(new PackageBuilder(this.adjustConfig, this.deviceInfo, this.activityState, this.sessionParameters, j14).buildSessionPackage(this.internalState.isInDelayedStart()));
this.packageHandler.sendFirstPackage();
}
private boolean updateActivityStateI(long j14) {
if (!checkActivityStateI(this.activityState)) {
return false;
}
ActivityState activityState2 = this.activityState;
long j15 = j14 - activityState2.lastActivity;
if (j15 > SESSION_INTERVAL) {
return false;
}
activityState2.lastActivity = j14;
if (j15 < 0) {
this.logger.error(TIME_TRAVEL, new Object[0]);
return true;
}
activityState2.sessionLength += j15;
activityState2.timeSpent += j15;
return true;
}
private void updateAdidI(String str) {
if (str != null && !str.equals(this.activityState.adid)) {
this.activityState.adid = str;
writeActivityStateI();
}
}
private void updateHandlersStatusAndSendI() {
if (!toSendI()) {
pauseSendingI();
return;
}
resumeSendingI();
if (!this.adjustConfig.eventBufferingEnabled || (this.internalState.isFirstLaunch() && this.internalState.hasSessionResponseNotBeenProcessed())) {
this.packageHandler.sendFirstPackage();
}
}
private void updatePackagesI() {
this.packageHandler.updatePackages(this.sessionParameters);
this.internalState.updatePackages = false;
ActivityState activityState2 = this.activityState;
if (activityState2 != null) {
activityState2.updatePackages = false;
writeActivityStateI();
}
}
private void updateStatusI(boolean z14, String str, String str2, String str3) {
if (z14) {
this.logger.info(str, new Object[0]);
} else if (!pausedI(false)) {
this.logger.info(str3, new Object[0]);
} else if (pausedI(true)) {
this.logger.info(str2, new Object[0]);
} else {
ILogger iLogger = this.logger;
iLogger.info(str2 + ", except the Sdk Click Handler", new Object[0]);
}
updateHandlersStatusAndSendI();
}
private void writeActivityStateI() {
synchronized (ActivityState.class) {
ActivityState activityState2 = this.activityState;
if (activityState2 != null) {
Util.writeObject(activityState2, this.adjustConfig.context, Constants.ACTIVITY_STATE_FILENAME, ACTIVITY_STATE_NAME);
}
}
}
private void writeAttributionI() {
synchronized (AdjustAttribution.class) {
AdjustAttribution adjustAttribution = this.attribution;
if (adjustAttribution != null) {
Util.writeObject(adjustAttribution, this.adjustConfig.context, Constants.ATTRIBUTION_FILENAME, ATTRIBUTION_NAME);
}
}
}
private void writeSessionCallbackParametersI() {
synchronized (SessionParameters.class) {
SessionParameters sessionParameters2 = this.sessionParameters;
if (sessionParameters2 != null) {
Util.writeObject(sessionParameters2.callbackParameters, this.adjustConfig.context, Constants.SESSION_CALLBACK_PARAMETERS_FILENAME, SESSION_CALLBACK_PARAMETERS_NAME);
}
}
}
private void writeSessionPartnerParametersI() {
synchronized (SessionParameters.class) {
SessionParameters sessionParameters2 = this.sessionParameters;
if (sessionParameters2 != null) {
Util.writeObject(sessionParameters2.partnerParameters, this.adjustConfig.context, Constants.SESSION_PARTNER_PARAMETERS_FILENAME, SESSION_PARTNER_PARAMETERS_NAME);
}
}
}
@Override // com.adjust.sdk.IActivityHandler
public void addSessionCallbackParameter(final String str, final String str2) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass16 */
public void run() {
ActivityHandler.this.addSessionCallbackParameterI(str, str2);
}
});
}
public void addSessionCallbackParameterI(String str, String str2) {
if (Util.isValidParameter(str, "key", "Session Callback") && Util.isValidParameter(str2, "value", "Session Callback")) {
SessionParameters sessionParameters2 = this.sessionParameters;
if (sessionParameters2.callbackParameters == null) {
sessionParameters2.callbackParameters = new LinkedHashMap();
}
String str3 = this.sessionParameters.callbackParameters.get(str);
if (str2.equals(str3)) {
this.logger.verbose("Key %s already present with the same value", str);
return;
}
if (str3 != null) {
this.logger.warn("Key %s will be overwritten", str);
}
this.sessionParameters.callbackParameters.put(str, str2);
writeSessionCallbackParametersI();
}
}
@Override // com.adjust.sdk.IActivityHandler
public void addSessionPartnerParameter(final String str, final String str2) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass17 */
public void run() {
ActivityHandler.this.addSessionPartnerParameterI(str, str2);
}
});
}
public void addSessionPartnerParameterI(String str, String str2) {
if (Util.isValidParameter(str, "key", "Session Partner") && Util.isValidParameter(str2, "value", "Session Partner")) {
SessionParameters sessionParameters2 = this.sessionParameters;
if (sessionParameters2.partnerParameters == null) {
sessionParameters2.partnerParameters = new LinkedHashMap();
}
String str3 = this.sessionParameters.partnerParameters.get(str);
if (str2.equals(str3)) {
this.logger.verbose("Key %s already present with the same value", str);
return;
}
if (str3 != null) {
this.logger.warn("Key %s will be overwritten", str);
}
this.sessionParameters.partnerParameters.put(str, str2);
writeSessionPartnerParametersI();
}
}
public void backgroundTimerFired() {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass29 */
public void run() {
ActivityHandler.this.backgroundTimerFiredI();
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void disableThirdPartySharing() {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass24 */
public void run() {
ActivityHandler.this.disableThirdPartySharingI();
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void finishedTrackingActivity(ResponseData responseData) {
if (responseData instanceof SessionResponseData) {
this.attributionHandler.checkSessionResponse((SessionResponseData) responseData);
} else if (responseData instanceof SdkClickResponseData) {
SdkClickResponseData sdkClickResponseData = (SdkClickResponseData) responseData;
checkForInstallReferrerInfo(sdkClickResponseData);
this.attributionHandler.checkSdkClickResponse(sdkClickResponseData);
} else if (responseData instanceof EventResponseData) {
launchEventResponseTasks((EventResponseData) responseData);
}
}
public void foregroundTimerFired() {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass28 */
public void run() {
ActivityHandler.this.foregroundTimerFiredI();
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void gdprForgetMe() {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass23 */
public void run() {
ActivityHandler.this.gdprForgetMeI();
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public ActivityState getActivityState() {
return this.activityState;
}
@Override // com.adjust.sdk.IActivityHandler
public String getAdid() {
ActivityState activityState2 = this.activityState;
if (activityState2 == null) {
return null;
}
return activityState2.adid;
}
@Override // com.adjust.sdk.IActivityHandler
public AdjustConfig getAdjustConfig() {
return this.adjustConfig;
}
@Override // com.adjust.sdk.IActivityHandler
public AdjustAttribution getAttribution() {
return this.attribution;
}
@Override // com.adjust.sdk.IActivityHandler
public String getBasePath() {
return this.basePath;
}
@Override // com.adjust.sdk.IActivityHandler
public Context getContext() {
return this.adjustConfig.context;
}
@Override // com.adjust.sdk.IActivityHandler
public DeviceInfo getDeviceInfo() {
return this.deviceInfo;
}
@Override // com.adjust.sdk.IActivityHandler
public String getGdprPath() {
return this.gdprPath;
}
public InternalState getInternalState() {
return this.internalState;
}
@Override // com.adjust.sdk.IActivityHandler
public SessionParameters getSessionParameters() {
return this.sessionParameters;
}
@Override // com.adjust.sdk.IActivityHandler
public String getSubscriptionPath() {
return this.subscriptionPath;
}
@Override // com.adjust.sdk.IActivityHandler
public String getUnbotifyPath() {
return this.unbotifyPath;
}
@Override // com.adjust.sdk.IActivityHandler
public void gotOptOutResponse() {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass27 */
public void run() {
ActivityHandler.this.gotOptOutResponseI();
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void init(AdjustConfig adjustConfig2) {
this.adjustConfig = adjustConfig2;
}
@Override // com.adjust.sdk.IActivityHandler
public boolean isEnabled() {
return isEnabledI();
}
@Override // com.adjust.sdk.IActivityHandler
public void launchAttributionResponseTasks(final AttributionResponseData attributionResponseData) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass14 */
public void run() {
ActivityHandler.this.launchAttributionResponseTasksI(attributionResponseData);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void launchEventResponseTasks(final EventResponseData eventResponseData) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass11 */
public void run() {
ActivityHandler.this.launchEventResponseTasksI(eventResponseData);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void launchSdkClickResponseTasks(final SdkClickResponseData sdkClickResponseData) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass12 */
public void run() {
ActivityHandler.this.launchSdkClickResponseTasksI(sdkClickResponseData);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void launchSessionResponseTasks(final SessionResponseData sessionResponseData) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass13 */
public void run() {
ActivityHandler.this.launchSessionResponseTasksI(sessionResponseData);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void onPause() {
this.internalState.background = true;
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass3 */
public void run() {
ActivityHandler.this.stopForegroundTimerI();
ActivityHandler.this.startBackgroundTimerI();
ActivityHandler.this.logger.verbose("Subsession end", new Object[0]);
ActivityHandler.this.endI();
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void onResume() {
this.internalState.background = false;
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass2 */
public void run() {
ActivityHandler.this.delayStartI();
ActivityHandler.this.stopBackgroundTimerI();
ActivityHandler.this.startForegroundTimerI();
ActivityHandler.this.logger.verbose("Subsession start", new Object[0]);
ActivityHandler.this.startI();
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void readOpenUrl(final Uri uri, final long j14) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass7 */
public void run() {
ActivityHandler.this.readOpenUrlI(uri, j14);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void removeSessionCallbackParameter(final String str) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass18 */
public void run() {
ActivityHandler.this.removeSessionCallbackParameterI(str);
}
});
}
public void removeSessionCallbackParameterI(String str) {
if (Util.isValidParameter(str, "key", "Session Callback")) {
Map<String, String> map = this.sessionParameters.callbackParameters;
if (map == null) {
this.logger.warn("Session Callback parameters are not set", new Object[0]);
} else if (map.remove(str) == null) {
this.logger.warn("Key %s does not exist", str);
} else {
this.logger.debug("Key %s will be removed", str);
writeSessionCallbackParametersI();
}
}
}
@Override // com.adjust.sdk.IActivityHandler
public void removeSessionPartnerParameter(final String str) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass19 */
public void run() {
ActivityHandler.this.removeSessionPartnerParameterI(str);
}
});
}
public void removeSessionPartnerParameterI(String str) {
if (Util.isValidParameter(str, "key", "Session Partner")) {
Map<String, String> map = this.sessionParameters.partnerParameters;
if (map == null) {
this.logger.warn("Session Partner parameters are not set", new Object[0]);
} else if (map.remove(str) == null) {
this.logger.warn("Key %s does not exist", str);
} else {
this.logger.debug("Key %s will be removed", str);
writeSessionPartnerParametersI();
}
}
}
@Override // com.adjust.sdk.IActivityHandler
public void resetSessionCallbackParameters() {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass20 */
public void run() {
ActivityHandler.this.resetSessionCallbackParametersI();
}
});
}
public void resetSessionCallbackParametersI() {
if (this.sessionParameters.callbackParameters == null) {
this.logger.warn("Session Callback parameters are not set", new Object[0]);
}
this.sessionParameters.callbackParameters = null;
writeSessionCallbackParametersI();
}
@Override // com.adjust.sdk.IActivityHandler
public void resetSessionPartnerParameters() {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass21 */
public void run() {
ActivityHandler.this.resetSessionPartnerParametersI();
}
});
}
public void resetSessionPartnerParametersI() {
if (this.sessionParameters.partnerParameters == null) {
this.logger.warn("Session Partner parameters are not set", new Object[0]);
}
this.sessionParameters.partnerParameters = null;
writeSessionPartnerParametersI();
}
@Override // com.adjust.sdk.IActivityHandler
public void sendFirstPackages() {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass15 */
public void run() {
ActivityHandler.this.sendFirstPackagesI();
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void sendInstallReferrer(final ReferrerDetails referrerDetails, final String str) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass10 */
public void run() {
ActivityHandler.this.sendInstallReferrerI(referrerDetails, str);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void sendReftagReferrer() {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass9 */
public void run() {
ActivityHandler.this.sendReftagReferrerI();
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void setAskingAttribution(final boolean z14) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass8 */
public void run() {
ActivityHandler.this.setAskingAttributionI(z14);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void setEnabled(final boolean z14) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass5 */
public void run() {
ActivityHandler.this.setEnabledI(z14);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void setOfflineMode(final boolean z14) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass6 */
public void run() {
ActivityHandler.this.setOfflineModeI(z14);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void setPushToken(final String str, final boolean z14) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass22 */
public void run() {
if (!z14) {
new SharedPreferencesManager(ActivityHandler.this.getContext()).savePushToken(str);
}
if (!ActivityHandler.this.internalState.hasFirstSdkStartNotOcurred()) {
ActivityHandler.this.setPushTokenI(str);
}
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void teardown() {
TimerOnce timerOnce = this.backgroundTimer;
if (timerOnce != null) {
timerOnce.teardown();
}
TimerCycle timerCycle = this.foregroundTimer;
if (timerCycle != null) {
timerCycle.teardown();
}
TimerOnce timerOnce2 = this.delayStartTimer;
if (timerOnce2 != null) {
timerOnce2.teardown();
}
ThreadExecutor threadExecutor = this.executor;
if (threadExecutor != null) {
threadExecutor.teardown();
}
IPackageHandler iPackageHandler = this.packageHandler;
if (iPackageHandler != null) {
iPackageHandler.teardown();
}
IAttributionHandler iAttributionHandler = this.attributionHandler;
if (iAttributionHandler != null) {
iAttributionHandler.teardown();
}
ISdkClickHandler iSdkClickHandler = this.sdkClickHandler;
if (iSdkClickHandler != null) {
iSdkClickHandler.teardown();
}
SessionParameters sessionParameters2 = this.sessionParameters;
if (sessionParameters2 != null) {
Map<String, String> map = sessionParameters2.callbackParameters;
if (map != null) {
map.clear();
}
Map<String, String> map2 = this.sessionParameters.partnerParameters;
if (map2 != null) {
map2.clear();
}
}
teardownActivityStateS();
teardownAttributionS();
teardownAllSessionParametersS();
this.packageHandler = null;
this.logger = null;
this.foregroundTimer = null;
this.executor = null;
this.backgroundTimer = null;
this.delayStartTimer = null;
this.internalState = null;
this.deviceInfo = null;
this.adjustConfig = null;
this.attributionHandler = null;
this.sdkClickHandler = null;
this.sessionParameters = null;
}
@Override // com.adjust.sdk.IActivityHandler
public void trackAdRevenue(final String str, final JSONObject jSONObject) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass25 */
public void run() {
ActivityHandler.this.trackAdRevenueI(str, jSONObject);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void trackEvent(final AdjustEvent adjustEvent) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass4 */
public void run() {
if (ActivityHandler.this.internalState.hasFirstSdkStartNotOcurred()) {
ActivityHandler.this.logger.warn("Event tracked before first activity resumed.\nIf it was triggered in the Application class, it might timestamp or even send an install long before the user opens the app.\nPlease check https://github.com/adjust/android_sdk#can-i-trigger-an-event-at-application-launch for more information.", new Object[0]);
ActivityHandler.this.startI();
}
ActivityHandler.this.trackEventI(adjustEvent);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public void trackPlayStoreSubscription(final AdjustPlayStoreSubscription adjustPlayStoreSubscription) {
this.executor.submit(new Runnable() {
/* class com.adjust.sdk.ActivityHandler.AnonymousClass26 */
public void run() {
ActivityHandler.this.trackSubscriptionI(adjustPlayStoreSubscription);
}
});
}
@Override // com.adjust.sdk.IActivityHandler
public boolean updateAttributionI(AdjustAttribution adjustAttribution) {
if (adjustAttribution == null || adjustAttribution.equals(this.attribution)) {
return false;
}
this.attribution = adjustAttribution;
writeAttributionI();
return true;
}
}