Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/singular/sdk/Singular.java

@@ -0,0 +1,174 @@
+package com.singular.sdk;
+
+import android.content.Context;
+import com.singular.sdk.internal.SingularExceptionReporter;
+import com.singular.sdk.internal.SingularInstance;
+import com.singular.sdk.internal.SingularLog;
+import com.singular.sdk.internal.Utils;
+import java.io.IOException;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public abstract class Singular {
+    public static SingularInstance singular;
+    public static final SingularLog logger = SingularLog.getLogger(Singular.class.getSimpleName());
+    public static boolean isInstanceAlreadyInitialized = false;
+    public static Context saved_application_context = null;
+
+    public static boolean init(Context context, SingularConfig singularConfig) {
+        if (context == null || singularConfig == null) {
+            return false;
+        }
+        try {
+            isInstanceAlreadyInitialized = singular != null;
+            SingularInstance singularInstance = SingularInstance.getInstance(context, singularConfig);
+            singular = singularInstance;
+            if (isInstanceAlreadyInitialized) {
+                singularInstance.startSessionIfOpenedWithDeeplink();
+            }
+            saved_application_context = context.getApplicationContext();
+        } catch (IOException e) {
+            SingularLog singularLog = logger;
+            singularLog.debug("Failed to init() Singular SDK");
+            singularLog.error("init() IOException", e);
+            singular = null;
+        } catch (RuntimeException e2) {
+            reportException(e2);
+            logger.error("Exception", e2);
+        }
+        return isInitialized();
+    }
+
+    public static void reportException(Throwable th) {
+        try {
+            SingularExceptionReporter.getReporter(saved_application_context).reportException(th);
+        } catch (RuntimeException unused) {
+        }
+    }
+
+    public static boolean isInitialized() {
+        if (singular != null) {
+            return true;
+        }
+        logger.error("Singular not initialized. You must call Singular.init() ");
+        return false;
+    }
+
+    public static boolean event(String str) {
+        try {
+            if (!isInitialized()) {
+                return false;
+            }
+            if (Utils.isEmptyOrNull(str)) {
+                logger.error("Event name can not be null or empty");
+                return false;
+            }
+            return singular.logEvent(str);
+        } catch (RuntimeException e) {
+            reportException(e);
+            logger.error("Exception", e);
+            return false;
+        }
+    }
+
+    public static boolean event(String str, Object... objArr) {
+        try {
+            if (!isInitialized()) {
+                return false;
+            }
+            if (Utils.isEmptyOrNull(str)) {
+                logger.error("Event name can not be null or empty");
+                return false;
+            }
+            if (objArr.length % 2 != 0) {
+                logger.error("Extra arguments must be in even numbers.");
+                return false;
+            }
+            try {
+                JSONObject jSONObject = new JSONObject();
+                for (int i = 0; i < objArr.length; i += 2) {
+                    jSONObject.put((String) objArr[i], objArr[i + 1]);
+                }
+                return eventJSON(str, jSONObject);
+            } catch (JSONException e) {
+                logger.error("error in serializing extra args", e);
+                return false;
+            }
+        } catch (RuntimeException e2) {
+            reportException(e2);
+            logger.error("Exception", e2);
+        }
+    }
+
+    public static boolean revenue(String str, double d, Object obj) {
+        return customRevenue("__iap__", str, d, obj);
+    }
+
+    public static boolean revenue(String str, double d) {
+        return customRevenue("__iap__", str, d);
+    }
+
+    public static boolean revenue(String str, double d, String str2, String str3, String str4, int i, double d2) {
+        return customRevenue("__iap__", str, d, str2, str3, str4, i, d2);
+    }
+
+    public static boolean customRevenue(String str, String str2, double d, Object obj) {
+        if (obj != null && obj.getClass().getName().equals("com.android.billingclient.api.Purchase")) {
+            try {
+                Class<?> cls = obj.getClass();
+                return event(str, "pcc", str2, "r", Double.valueOf(d), "pk", (String) cls.getDeclaredMethod("getSku", new Class[0]).invoke(obj, new Object[0]), "receipt", (String) cls.getDeclaredMethod("getOriginalJson", new Class[0]).invoke(obj, new Object[0]), "receipt_signature", (String) cls.getDeclaredMethod("getSignature", new Class[0]).invoke(obj, new Object[0]), "is_revenue_event", Boolean.TRUE);
+            } catch (Exception e) {
+                logger.error("customRevenue has encountered an unexpected exception. Please verify that the 'purchase' object is of type 'com.android.billingclient.api.Purchase'", e);
+            }
+        }
+        return customRevenue(str, str2, d);
+    }
+
+    public static boolean customRevenue(String str, String str2, double d) {
+        return event(str, "pcc", str2, "r", Double.valueOf(d), "is_revenue_event", Boolean.TRUE);
+    }
+
+    public static boolean customRevenue(String str, String str2, double d, String str3, String str4, String str5, int i, double d2) {
+        return event(str, "pcc", str2, "r", Double.valueOf(d), "pk", str3, "pn", str4, "pc", str5, "pq", Integer.valueOf(i), "pp", Double.valueOf(d2), "is_revenue_event", Boolean.TRUE);
+    }
+
+    public static boolean eventJSON(String str, JSONObject jSONObject) {
+        try {
+            if (!isInitialized()) {
+                return false;
+            }
+            if (Utils.isEmptyOrNull(str)) {
+                logger.error("Event name can not be null or empty");
+                return false;
+            }
+            return singular.logEvent(str, jSONObject != null ? jSONObject.toString() : null);
+        } catch (RuntimeException e) {
+            reportException(e);
+            logger.error("Exception", e);
+            return false;
+        }
+    }
+
+    public static void setCustomUserId(String str) {
+        try {
+            if (isInitialized()) {
+                singular.saveCustomUserId(str);
+            }
+        } catch (RuntimeException e) {
+            reportException(e);
+            logger.error("Exception", e);
+        }
+    }
+
+    public static void unsetCustomUserId() {
+        try {
+            if (isInitialized()) {
+                singular.saveCustomUserId("");
+            }
+        } catch (RuntimeException e) {
+            reportException(e);
+            logger.error("Exception", e);
+        }
+    }
+}

decompiled/sources/com/singular/sdk/SingularConfig.java

@@ -0,0 +1,59 @@
+package com.singular.sdk;
+
+import android.net.Uri;
+import com.singular.sdk.internal.Utils;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public class SingularConfig {
+    public final String apiKey;
+    public String customUserId;
+    public String facebookAppId;
+    public String imei;
+    public Uri openUri;
+    public final String secret;
+    public long shortlinkTimeoutSec;
+    public Uri singularLink;
+    public boolean wasCustomUserIdSetBeforeInit = false;
+    public Map globalProperties = new HashMap();
+    public long sessionTimeoutSec = 60;
+    public boolean enableLogging = false;
+    public int logLevel = 6;
+    public boolean isOpenedWithDeepLink = false;
+    public List approvedDomains = new ArrayList();
+
+    public SingularConfig(String str, String str2) {
+        if (Utils.isEmptyOrNull(str)) {
+            throw new IllegalArgumentException("apiKey can not be null or empty");
+        }
+        if (Utils.isEmptyOrNull(str2)) {
+            throw new IllegalArgumentException("secret can not be null or empty");
+        }
+        this.apiKey = str;
+        this.secret = str2;
+    }
+
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("apiKey='");
+        sb.append(this.apiKey);
+        sb.append('\'');
+        sb.append(", secret='");
+        sb.append(this.secret);
+        sb.append('\'');
+        if (this.openUri != null) {
+            sb.append(", openUri=");
+            sb.append(this.openUri);
+        }
+        sb.append(", logging='");
+        sb.append(this.enableLogging);
+        sb.append('\'');
+        sb.append(", logLevel='");
+        sb.append(this.logLevel);
+        sb.append('\'');
+        return sb.toString();
+    }
+}

decompiled/sources/com/singular/sdk/SingularInstallReceiver.java

@@ -0,0 +1,37 @@
+package com.singular.sdk;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import com.singular.sdk.internal.SingularInstance;
+import com.singular.sdk.internal.SingularLog;
+import com.singular.sdk.internal.Utils;
+
+/* loaded from: classes4.dex */
+public class SingularInstallReceiver extends BroadcastReceiver {
+    public static final SingularLog logger = SingularLog.getLogger(Singular.class.getSimpleName());
+
+    @Override // android.content.BroadcastReceiver
+    public void onReceive(Context context, Intent intent) {
+        SingularInstance singularInstance;
+        String action = intent.getAction();
+        if (Utils.isEmptyOrNull(action)) {
+            logger.debug("Install.onReceive() action is empty");
+            return;
+        }
+        if (!action.equals("com.android.vending.INSTALL_REFERRER")) {
+            logger.debug("Install.onReceive() unknown action = %s", action);
+            return;
+        }
+        String stringExtra = intent.getStringExtra("referrer");
+        if (Utils.isEmptyOrNull(stringExtra)) {
+            return;
+        }
+        Utils.saveCSIReferrer(context, stringExtra);
+        logger.debug("saved referrer = %s", stringExtra);
+        if (!Utils.isAsyncReferrerAllowed(context) || (singularInstance = SingularInstance.getInstance()) == null) {
+            return;
+        }
+        singularInstance.sendInstallReferrerEvent(stringExtra, "intent_async", -1L, -1L);
+    }
+}

decompiled/sources/com/singular/sdk/SingularLinkParams.java

@@ -0,0 +1,18 @@
+package com.singular.sdk;
+
+/* loaded from: classes4.dex */
+public class SingularLinkParams {
+    public String deeplink;
+    public boolean isDeferred;
+    public String passthrough;
+
+    public String getDeeplink() {
+        return this.deeplink;
+    }
+
+    public SingularLinkParams(String str, String str2, boolean z) {
+        this.deeplink = str;
+        this.passthrough = str2;
+        this.isDeferred = z;
+    }
+}

decompiled/sources/com/singular/sdk/internal/Api.java

@@ -0,0 +1,15 @@
+package com.singular.sdk.internal;
+
+/* loaded from: classes4.dex */
+public interface Api {
+
+    public interface OnApiCallback {
+        boolean handle(SingularInstance singularInstance, int i, String str);
+    }
+
+    OnApiCallback getOnApiCallback();
+
+    String getPath();
+
+    boolean makeRequest(SingularInstance singularInstance);
+}

decompiled/sources/com/singular/sdk/internal/ApiCustomUserId.java

@@ -0,0 +1,62 @@
+package com.singular.sdk.internal;
+
+import com.singular.sdk.internal.Api;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class ApiCustomUserId extends BaseApi {
+    public static final SingularLog logger = SingularLog.getLogger(ApiStartSession.class.getSimpleName());
+
+    @Override // com.singular.sdk.internal.Api
+    public String getPath() {
+        return "/set_device_for_custom_id";
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ long getTimestamp() {
+        return super.getTimestamp();
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ String getUrl() {
+        return super.getUrl();
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi, com.singular.sdk.internal.Api
+    public /* bridge */ /* synthetic */ boolean makeRequest(SingularInstance singularInstance) {
+        return super.makeRequest(singularInstance);
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ String toJsonAsString() {
+        return super.toJsonAsString();
+    }
+
+    public ApiCustomUserId(long j) {
+        super("CUSTOM_USER_ID", j);
+    }
+
+    @Override // com.singular.sdk.internal.Api
+    public Api.OnApiCallback getOnApiCallback() {
+        return new OnSetCustomUserIdCallback();
+    }
+
+    public class OnSetCustomUserIdCallback implements Api.OnApiCallback {
+        public OnSetCustomUserIdCallback() {
+        }
+
+        @Override // com.singular.sdk.internal.Api.OnApiCallback
+        public boolean handle(SingularInstance singularInstance, int i, String str) {
+            if (i != 200) {
+                return false;
+            }
+            try {
+                return new JSONObject(str).optString("status", "").equalsIgnoreCase("ok");
+            } catch (JSONException e) {
+                ApiCustomUserId.logger.error("error in handle()", e);
+                return false;
+            }
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/ApiGDPRConsent.java

@@ -0,0 +1,52 @@
+package com.singular.sdk.internal;
+
+import com.singular.sdk.internal.Api;
+
+/* loaded from: classes4.dex */
+public class ApiGDPRConsent extends BaseApi {
+    public static final SingularLog logger = SingularLog.getLogger(ApiGDPRConsent.class.getSimpleName());
+
+    @Override // com.singular.sdk.internal.Api
+    public String getPath() {
+        return "/opengdpr";
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ long getTimestamp() {
+        return super.getTimestamp();
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ String getUrl() {
+        return super.getUrl();
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi, com.singular.sdk.internal.Api
+    public /* bridge */ /* synthetic */ boolean makeRequest(SingularInstance singularInstance) {
+        return super.makeRequest(singularInstance);
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ String toJsonAsString() {
+        return super.toJsonAsString();
+    }
+
+    public ApiGDPRConsent(long j) {
+        super("GDPR_CONSENT", j);
+    }
+
+    @Override // com.singular.sdk.internal.Api
+    public Api.OnApiCallback getOnApiCallback() {
+        return new OnResolveCallback();
+    }
+
+    public class OnResolveCallback implements Api.OnApiCallback {
+        @Override // com.singular.sdk.internal.Api.OnApiCallback
+        public boolean handle(SingularInstance singularInstance, int i, String str) {
+            return i == 200;
+        }
+
+        public OnResolveCallback() {
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/ApiGDPRUnder13.java

@@ -0,0 +1,52 @@
+package com.singular.sdk.internal;
+
+import com.singular.sdk.internal.Api;
+
+/* loaded from: classes4.dex */
+public class ApiGDPRUnder13 extends BaseApi {
+    public static final SingularLog logger = SingularLog.getLogger(ApiGDPRUnder13.class.getSimpleName());
+
+    @Override // com.singular.sdk.internal.Api
+    public String getPath() {
+        return "/opengdpr";
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ long getTimestamp() {
+        return super.getTimestamp();
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ String getUrl() {
+        return super.getUrl();
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi, com.singular.sdk.internal.Api
+    public /* bridge */ /* synthetic */ boolean makeRequest(SingularInstance singularInstance) {
+        return super.makeRequest(singularInstance);
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ String toJsonAsString() {
+        return super.toJsonAsString();
+    }
+
+    public ApiGDPRUnder13(long j) {
+        super("GDPR_UNDER_13", j);
+    }
+
+    @Override // com.singular.sdk.internal.Api
+    public Api.OnApiCallback getOnApiCallback() {
+        return new OnResolveCallback();
+    }
+
+    public class OnResolveCallback implements Api.OnApiCallback {
+        @Override // com.singular.sdk.internal.Api.OnApiCallback
+        public boolean handle(SingularInstance singularInstance, int i, String str) {
+            return i == 200;
+        }
+
+        public OnResolveCallback() {
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/ApiManager.java

@@ -0,0 +1,142 @@
+package com.singular.sdk.internal;
+
+import android.content.Context;
+import java.io.File;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class ApiManager {
+    public static final SingularLog logger = SingularLog.getLogger(ApiManager.class.getSimpleName());
+    public final Context context;
+    public Queue queue;
+    public SingularWorkerThread worker;
+    public final Runnable runnable = new Runnable() { // from class: com.singular.sdk.internal.ApiManager.2
+        @Override // java.lang.Runnable
+        public void run() {
+            if (!SingularInstance.getInstance().isInitialized()) {
+                ApiManager.logger.debug("Singular is not initialized!");
+                return;
+            }
+            if (Utils.isConnected(ApiManager.this.context)) {
+                try {
+                    String peek = ApiManager.this.queue.peek();
+                    if (peek == null) {
+                        ApiManager.logger.debug("Queue is empty");
+                        return;
+                    }
+                    BaseApi from = BaseApi.from(peek);
+                    ApiManager.logger.debug("api = %s", from.getClass().getName());
+                    if (from.makeRequest(SingularInstance.getInstance())) {
+                        ApiManager.this.queue.remove();
+                        ApiManager.this.wakeUp();
+                        return;
+                    }
+                    return;
+                } catch (Exception e) {
+                    ApiManager.logger.error("IOException in processing an event: %s", e.getMessage());
+                    e.printStackTrace();
+                    return;
+                }
+            }
+            ApiManager.logger.debug("Oops, not connected to internet!");
+        }
+    };
+    public final Runnable migrateEventsFromFileQueue = new Runnable() { // from class: com.singular.sdk.internal.ApiManager.3
+        @Override // java.lang.Runnable
+        public void run() {
+            File file = new File(ApiManager.this.context.getFilesDir(), "api-r.dat");
+            ApiManager.logger.debug("Migrate events from QueueFile = %s", "api-r.dat");
+            if (!file.exists()) {
+                ApiManager.logger.debug("QueueFile does not exist");
+                return;
+            }
+            try {
+                FixedSizePersistentQueue create = FixedSizePersistentQueue.create(ApiManager.this.context, "api-r.dat", 10000);
+                if (create == null) {
+                    ApiManager.logger.debug("QueueFile failed to initialize");
+                    return;
+                }
+                int i = 0;
+                while (!create.isEmpty()) {
+                    ApiManager.this.queue.add(create.peek());
+                    create.remove();
+                    i++;
+                }
+                ApiManager.logger.debug("Migrated '%d' events", Integer.valueOf(i));
+                file.delete();
+                ApiManager.logger.debug("QueueFile deleted");
+            } catch (RuntimeException e) {
+                ApiManager.logger.error("loadFromFileQueue: RuntimeException", e);
+            } catch (Exception e2) {
+                ApiManager.logger.error("loadFromFileQueue: Exception", e2);
+            }
+        }
+    };
+
+    public ApiManager(SingularWorkerThread singularWorkerThread, Context context, Queue queue) {
+        this.context = context;
+        this.queue = queue;
+        if (queue == null) {
+            return;
+        }
+        logger.debug("Queue: %s", queue.getClass().getSimpleName());
+        if (singularWorkerThread == null) {
+            return;
+        }
+        this.worker = singularWorkerThread;
+        singularWorkerThread.start();
+    }
+
+    public void wakeUp() {
+        SingularWorkerThread singularWorkerThread = this.worker;
+        if (singularWorkerThread == null) {
+            return;
+        }
+        singularWorkerThread.getHandler().removeCallbacksAndMessages(null);
+        this.worker.post(this.runnable);
+    }
+
+    public void tryMigrateEventsFromFileQueue() {
+        if (this.queue instanceof SQLitePersistentQueue) {
+            this.worker.post(this.migrateEventsFromFileQueue);
+        }
+    }
+
+    public void tryMigrateEventsFromOldSQLiteQueue() {
+        this.worker.post(new Runnable() { // from class: com.singular.sdk.internal.ApiManager.1
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    new OfflineEventsMigrator(ApiManager.this.context).migrate();
+                } catch (RuntimeException e) {
+                    ApiManager.logger.error("migrateEventsFromOldSQLiteQueue: RuntimeException", e);
+                } catch (Exception e2) {
+                    ApiManager.logger.error("migrateEventsFromOldSQLiteQueue: Exception", e2);
+                }
+            }
+        });
+    }
+
+    public void enqueue(BaseApi baseApi) {
+        if (baseApi != null) {
+            try {
+                if (this.queue == null) {
+                    return;
+                }
+                if (!(baseApi instanceof ApiGDPRConsent) && !(baseApi instanceof ApiGDPRUnder13)) {
+                    baseApi.put("event_index", String.valueOf(Utils.getEventIndex(this.context)));
+                }
+                baseApi.put("singular_install_id", Utils.getSingularId(this.context).toString());
+                JSONObject globalPropertiesJSON = SingularInstance.getInstance().getGlobalPropertiesJSON();
+                if (globalPropertiesJSON.length() != 0) {
+                    baseApi.put("global_properties", globalPropertiesJSON.toString());
+                }
+                this.queue.add(baseApi.toJsonAsString());
+                wakeUp();
+            } catch (IndexOutOfBoundsException unused) {
+            } catch (Exception e) {
+                logger.error("error in enqueue()", e);
+            }
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/ApiStartSession.java

@@ -0,0 +1,304 @@
+package com.singular.sdk.internal;
+
+import android.content.Context;
+import android.net.Uri;
+import androidx.core.app.NotificationCompat;
+import com.facebook.gamingservices.cloudgaming.internal.SDKConstants;
+import com.ironsource.mediationsdk.impressionData.ImpressionData;
+import com.ironsource.nb;
+import com.mbridge.msdk.foundation.download.core.DownloadCommon;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.mbridge.msdk.foundation.same.report.i;
+import com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlNode;
+import com.singular.sdk.SingularConfig;
+import com.singular.sdk.internal.Api;
+import com.singular.sdk.internal.ApiSubmitEvent;
+import com.singular.sdk.internal.LicenseApiHelper;
+import com.singular.sdk.internal.NewPlayReferrerUtils;
+import com.unity3d.ads.metadata.InAppPurchaseMetaData;
+import csdk.gluads.Consts;
+import java.util.Locale;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class ApiStartSession extends BaseApi {
+    public static final SingularLog logger = SingularLog.getLogger(ApiStartSession.class.getSimpleName());
+    public int licenseAttemptsCounter;
+
+    @Override // com.singular.sdk.internal.Api
+    public String getPath() {
+        return "/start";
+    }
+
+    public static /* synthetic */ int access$108(ApiStartSession apiStartSession) {
+        int i = apiStartSession.licenseAttemptsCounter;
+        apiStartSession.licenseAttemptsCounter = i + 1;
+        return i;
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ long getTimestamp() {
+        return super.getTimestamp();
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ String getUrl() {
+        return super.getUrl();
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi, com.singular.sdk.internal.Api
+    public /* bridge */ /* synthetic */ boolean makeRequest(SingularInstance singularInstance) {
+        return super.makeRequest(singularInstance);
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ String toJsonAsString() {
+        return super.toJsonAsString();
+    }
+
+    public ApiStartSession(long j) {
+        super("SESSION_START", j);
+        this.licenseAttemptsCounter = 0;
+    }
+
+    @Override // com.singular.sdk.internal.Api
+    public Api.OnApiCallback getOnApiCallback() {
+        return new OnSessionStartCallback();
+    }
+
+    public class OnSessionStartCallback implements Api.OnApiCallback {
+        public final boolean isLicenseResponseValid(int i) {
+            return (i == -1 || i == 257 || i == 4) ? false : true;
+        }
+
+        public OnSessionStartCallback() {
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // com.singular.sdk.internal.Api.OnApiCallback
+        public boolean handle(SingularInstance singularInstance, int i, String str) {
+            String str2;
+            if (i != 200) {
+                return false;
+            }
+            try {
+                JSONObject jSONObject = new JSONObject(str);
+                if (!jSONObject.optString("status", "").equalsIgnoreCase("ok")) {
+                    return false;
+                }
+                String optString = jSONObject.optString("ddl", null);
+                String optString2 = jSONObject.optString("deferred_passthrough", null);
+                if (!Utils.isOpenedWithDeeplink()) {
+                    if (Utils.isEmptyOrNull(optString)) {
+                        if (!Utils.isEmptyOrNull(optString2)) {
+                        }
+                    }
+                    handleDDL(singularInstance, optString, optString2);
+                }
+                String optString3 = jSONObject.optString("resolved_singular_link", null);
+                if (!Utils.isEmptyOrNull(optString3) && (str2 = (String) ApiStartSession.this.get("singular_link_resolve_required")) != null && Boolean.parseBoolean(str2) && Utils.lagSince(ApiStartSession.this.getTimestamp()) < SingularInstance.getInstance().getSingularConfig().shortlinkTimeoutSec) {
+                    Utils.handleSingularLink(Uri.parse(optString3));
+                }
+                if (jSONObject.optBoolean("first_time", false)) {
+                    handleInstallFacebook(singularInstance);
+                    handleInstallReferrer(singularInstance);
+                }
+                String str3 = (String) ApiStartSession.this.get("u");
+                if (Utils.isEmptyOrNull(str3) || Utils.isLicenseRetrieved(singularInstance.getContext(), str3)) {
+                    return true;
+                }
+                performLicenseCheck(singularInstance, str3);
+                return true;
+            } catch (JSONException e) {
+                ApiStartSession.logger.error("error in handle()", e);
+                return false;
+            }
+        }
+
+        public void performLicenseCheck(final SingularInstance singularInstance, final String str) {
+            ApiStartSession.logger.debug("Trying to fetch license key from the Licensing Service");
+            new Thread(new Runnable() { // from class: com.singular.sdk.internal.ApiStartSession.OnSessionStartCallback.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    ApiStartSession.access$108(ApiStartSession.this);
+                    LicenseApiHelper.checkLicense(singularInstance.getContext(), new LicenseApiHelper.LicenseResultHandler() { // from class: com.singular.sdk.internal.ApiStartSession.OnSessionStartCallback.1.1
+                        @Override // com.singular.sdk.internal.LicenseApiHelper.LicenseResultHandler
+                        public void handle(int i, String str2, String str3) {
+                            try {
+                                if (!OnSessionStartCallback.this.isLicenseResponseValid(i) && ApiStartSession.this.licenseAttemptsCounter < 3) {
+                                    Thread.sleep(ApiStartSession.this.licenseAttemptsCounter * 3000);
+                                    AnonymousClass1 anonymousClass1 = AnonymousClass1.this;
+                                    OnSessionStartCallback.this.performLicenseCheck(singularInstance, str);
+                                    return;
+                                }
+                                Utils.saveLicenseInfo(singularInstance.getContext(), str);
+                                JSONObject jSONObject = new JSONObject();
+                                jSONObject.put("responseCode", String.valueOf(i));
+                                jSONObject.put("signedData", str2);
+                                jSONObject.put(InAppPurchaseMetaData.KEY_SIGNATURE, str3);
+                                singularInstance.logEvent(new ApiSubmitEvent.RawEvent("__LicensingStatus", jSONObject.toString()));
+                            } catch (InterruptedException e) {
+                                e.printStackTrace();
+                            } catch (JSONException e2) {
+                                ApiStartSession.logger.error("Error occurred while trying to send licensing status event", e2);
+                            }
+                        }
+                    });
+                }
+            }).start();
+        }
+
+        public void handleInstallReferrer(final SingularInstance singularInstance) {
+            ApiStartSession.logger.debug("Trying to fetch referrer by NEW play referrer method");
+            try {
+                NewPlayReferrerUtils.queryNewPlayReferrerValue(singularInstance.getContext(), new NewPlayReferrerUtils.NewPlayReferrerCallback() { // from class: com.singular.sdk.internal.ApiStartSession.OnSessionStartCallback.2
+                    @Override // com.singular.sdk.internal.NewPlayReferrerUtils.NewPlayReferrerCallback
+                    public void handleReferrerValue(String str, long j, long j2) {
+                        singularInstance.sendInstallReferrerEvent(str, NotificationCompat.CATEGORY_SERVICE, j, j2);
+                    }
+
+                    @Override // com.singular.sdk.internal.NewPlayReferrerUtils.NewPlayReferrerCallback
+                    public void handleNotSupported() {
+                        String cSIReferrer = Utils.getCSIReferrer(singularInstance.getContext());
+                        if (!Utils.isEmptyOrNull(cSIReferrer)) {
+                            singularInstance.sendInstallReferrerEvent(cSIReferrer, SDKConstants.PARAM_INTENT, -1L, -1L);
+                        } else {
+                            Utils.signalAsyncReferrerAllowed(singularInstance.getContext());
+                        }
+                    }
+                });
+            } catch (Exception e) {
+                ApiStartSession.logger.error("Failed to fetch play referrer value", e);
+            }
+        }
+
+        public void handleInstallFacebook(SingularInstance singularInstance) {
+            String str = singularInstance.getSingularConfig().facebookAppId;
+            if (Utils.isEmptyOrNull(str)) {
+                ApiStartSession.logger.error("facebookAppId is not set");
+                return;
+            }
+            String str2 = singularInstance.getDeviceInfo().fbAttributionId;
+            if (Utils.isEmptyOrNull(str2)) {
+                ApiStartSession.logger.error("fbAttributionId is not available");
+                return;
+            }
+            try {
+                JSONObject jSONObject = new JSONObject();
+                jSONObject.put("fb_app_attribution", str2);
+                jSONObject.put("fb_app_ids", str);
+                singularInstance.logEvent(new ApiSubmitEvent.RawEvent("__FBInstall", jSONObject.toString()));
+            } catch (JSONException e) {
+                ApiStartSession.logger.error("error in handleInstallFacebook()", e);
+            }
+        }
+
+        public void handleDDL(SingularInstance singularInstance, String str, String str2) {
+            singularInstance.getSingularConfig().getClass();
+            ApiStartSession.logger.error("DDLHandler is not configured, ignoring callback for url = %s", str);
+        }
+    }
+
+    public static class Params extends SingularMap {
+        public static Params build(long j, SingularInstance singularInstance) {
+            return new Params().withId(j).withSingularConfig(singularInstance.getSingularConfig()).withDeviceInfo(singularInstance.getDeviceInfo()).withConnectionType(Utils.getConnectionType(singularInstance.getContext())).withAppInstallInfo(singularInstance.getContext());
+        }
+
+        public final Params withId(long j) {
+            put("s", String.valueOf(j));
+            return this;
+        }
+
+        public final Params withConnectionType(String str) {
+            put("c", str);
+            return this;
+        }
+
+        public final Params withSingularConfig(SingularConfig singularConfig) {
+            put("a", singularConfig.apiKey);
+            Uri uri = singularConfig.openUri;
+            if (uri != null) {
+                put("ref", uri.getQueryParameter("referrer"));
+                put("extra", uri.getQuery());
+            }
+            put("ddl_enabled", "false");
+            Uri uri2 = singularConfig.singularLink;
+            if (uri2 != null) {
+                if (Utils.validateSingularLink(uri2)) {
+                    boolean isShortLink = Utils.isShortLink(singularConfig.singularLink);
+                    if (!isShortLink) {
+                        Utils.handleSingularLink(singularConfig.singularLink);
+                    }
+                    put("singular_link", singularConfig.singularLink.toString());
+                    put("singular_link_resolve_timeout", String.valueOf(singularConfig.shortlinkTimeoutSec));
+                    put("singular_link_resolve_required", String.valueOf(isShortLink));
+                }
+                singularConfig.singularLink = null;
+            }
+            return this;
+        }
+
+        public final Params withDeviceInfo(DeviceInfo deviceInfo) {
+            put(ImpressionData.IMPRESSION_DATA_KEY_ABTEST, deviceInfo.abi);
+            put("av", deviceInfo.appVersion);
+            put(TtmlNode.TAG_BR, deviceInfo.deviceBrand);
+            put(DownloadCommon.DOWNLOAD_REPORT_DOWNLOAD_ERROR, deviceInfo.deviceBuild);
+            put(i.a, deviceInfo.packageName);
+            put("ma", deviceInfo.deviceManufacturer);
+            put("mo", deviceInfo.deviceModel);
+            put(nb.q, deviceInfo.appName);
+            put(TtmlNode.TAG_P, deviceInfo.platform);
+            put("pr", deviceInfo.buildProduct);
+            put("sdk", Utils.getSdkVersion());
+            if (!Utils.isEmptyOrNull(deviceInfo.aifa)) {
+                put("aifa", deviceInfo.aifa);
+                put(CampaignEx.JSON_KEY_AD_K, "AIFA");
+                put("u", deviceInfo.aifa);
+            } else if (!Utils.isEmptyOrNull(deviceInfo.imei)) {
+                put("imei", deviceInfo.imei);
+                put(CampaignEx.JSON_KEY_AD_K, "IMEI");
+                put("u", deviceInfo.imei);
+                put("andi", deviceInfo.andi);
+            } else {
+                put(CampaignEx.JSON_KEY_AD_K, "ANDI");
+                put("u", deviceInfo.andi);
+            }
+            put("dnt", deviceInfo.isGooglePlayServicesAvailable ? deviceInfo.isLimitedTrackingEnabled ? "1" : "0" : "-1");
+            put(Consts.KEY_TAPJOY_USER_ID_VERSION, deviceInfo.osVersion);
+            if (!Utils.isEmptyOrNull(deviceInfo.installSource)) {
+                put("src", deviceInfo.installSource);
+            }
+            if (!Utils.isEmptyOrNull(deviceInfo.gcmRegId)) {
+                put("ri", deviceInfo.gcmRegId);
+            }
+            if (!Utils.isEmptyOrNull(deviceInfo.fcmRegId)) {
+                put("fi", deviceInfo.fcmRegId);
+            }
+            if (deviceInfo.hasPreloadCampaign()) {
+                put("apc", deviceInfo.preloadCampaign);
+                put("apg", deviceInfo.preloadGroup);
+                put("aps", deviceInfo.preloadSource);
+            }
+            put("lc", Locale.getDefault().toString());
+            put("install_time", Long.valueOf(deviceInfo.firstInstallTime).toString());
+            put("update_time", Long.valueOf(deviceInfo.lastUpdateTime).toString());
+            put("current_device_time", Long.valueOf(Utils.getCurrentTimeMillis()).toString());
+            put("device_type", deviceInfo.deviceType);
+            put("custom_user_id", deviceInfo.customUserId);
+            if (!Utils.isEmptyOrNull(deviceInfo.deviceUserAgent)) {
+                put("device_user_agent", deviceInfo.deviceUserAgent);
+            }
+            return this;
+        }
+
+        public final Params withAppInstallInfo(Context context) {
+            if (Utils.isFirstInstall(context)) {
+                put("is", "true");
+            } else {
+                put("is", "false");
+            }
+            return this;
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/ApiSubmitEvent.java

@@ -0,0 +1,155 @@
+package com.singular.sdk.internal;
+
+import com.ironsource.nb;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.mbridge.msdk.foundation.same.report.i;
+import com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlNode;
+import com.singular.sdk.SingularConfig;
+import com.singular.sdk.internal.Api;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class ApiSubmitEvent extends BaseApi {
+    public static final SingularLog logger = SingularLog.getLogger(ApiSubmitEvent.class.getSimpleName());
+
+    @Override // com.singular.sdk.internal.Api
+    public String getPath() {
+        return "/event";
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ long getTimestamp() {
+        return super.getTimestamp();
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ String getUrl() {
+        return super.getUrl();
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi, com.singular.sdk.internal.Api
+    public /* bridge */ /* synthetic */ boolean makeRequest(SingularInstance singularInstance) {
+        return super.makeRequest(singularInstance);
+    }
+
+    @Override // com.singular.sdk.internal.BaseApi
+    public /* bridge */ /* synthetic */ String toJsonAsString() {
+        return super.toJsonAsString();
+    }
+
+    public ApiSubmitEvent(long j) {
+        super("EVENT", j);
+    }
+
+    @Override // com.singular.sdk.internal.Api
+    public Api.OnApiCallback getOnApiCallback() {
+        return new OnEventSubmitCallback();
+    }
+
+    public class OnEventSubmitCallback implements Api.OnApiCallback {
+        public OnEventSubmitCallback() {
+        }
+
+        @Override // com.singular.sdk.internal.Api.OnApiCallback
+        public boolean handle(SingularInstance singularInstance, int i, String str) {
+            if (i == 413) {
+                return true;
+            }
+            if (i != 200) {
+                return false;
+            }
+            try {
+            } catch (JSONException e) {
+                ApiSubmitEvent.logger.error("error in handle()", e);
+            }
+            return new JSONObject(str).optString("status", "").equalsIgnoreCase("ok");
+        }
+    }
+
+    public static class RawEvent {
+        public final String extra;
+        public final String name;
+        public final long timestamp;
+
+        public RawEvent(String str, String str2) {
+            this.name = str.replace("\\n", "");
+            this.extra = !Utils.isEmptyOrNull(str2) ? str2.replace("\\n", "") : null;
+            this.timestamp = Utils.getCurrentTimeMillis();
+        }
+
+        public String toString() {
+            return "RawEvent{name='" + this.name + "', extra='" + this.extra + "', timestamp=" + this.timestamp + '}';
+        }
+    }
+
+    public static class Params extends SingularMap {
+        public static Params build(RawEvent rawEvent, SingularInstance singularInstance) {
+            return new Params().withName(rawEvent.name).withExtra(rawEvent.extra).withSecondsIntoSession((rawEvent.timestamp - r0) * 0.001d).withSession(singularInstance.getSessionManager().getSessionId()).withSequence(singularInstance.getSessionManager().getNextSequenceNumber()).withSingularConfig(singularInstance.getSingularConfig()).withDeviceInfo(singularInstance.getDeviceInfo());
+        }
+
+        public final Params withName(String str) {
+            put(nb.q, str);
+            return this;
+        }
+
+        public final Params withSession(long j) {
+            put("s", String.valueOf(j));
+            return this;
+        }
+
+        public final Params withSecondsIntoSession(double d) {
+            put("t", String.valueOf(d));
+            return this;
+        }
+
+        public final Params withExtra(String str) {
+            try {
+                if (Utils.isEmptyOrNull(str)) {
+                    str = new JSONObject().put("is_revenue_event", false).toString();
+                } else {
+                    JSONObject jSONObject = new JSONObject(str);
+                    if (!jSONObject.optBoolean("is_revenue_event", false)) {
+                        str = jSONObject.put("is_revenue_event", false).toString();
+                    }
+                }
+                put("e", str);
+            } catch (JSONException e) {
+                e.printStackTrace();
+            }
+            return this;
+        }
+
+        public final Params withSequence(long j) {
+            put("seq", String.valueOf(j));
+            return this;
+        }
+
+        public final Params withSingularConfig(SingularConfig singularConfig) {
+            put("a", singularConfig.apiKey);
+            return this;
+        }
+
+        public final Params withDeviceInfo(DeviceInfo deviceInfo) {
+            put("av", deviceInfo.appVersion);
+            put(i.a, deviceInfo.packageName);
+            put(TtmlNode.TAG_P, deviceInfo.platform);
+            put("sdk", Utils.getSdkVersion());
+            if (!Utils.isEmptyOrNull(deviceInfo.aifa)) {
+                put("aifa", deviceInfo.aifa);
+                put(CampaignEx.JSON_KEY_AD_K, "AIFA");
+                put("u", deviceInfo.aifa);
+            } else if (!Utils.isEmptyOrNull(deviceInfo.imei)) {
+                put("imei", deviceInfo.imei);
+                put(CampaignEx.JSON_KEY_AD_K, "IMEI");
+                put("u", deviceInfo.imei);
+                put("andi", deviceInfo.andi);
+            } else {
+                put(CampaignEx.JSON_KEY_AD_K, "ANDI");
+                put("u", deviceInfo.andi);
+            }
+            put("custom_user_id", deviceInfo.customUserId);
+            return this;
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/BaseApi.java

@@ -0,0 +1,105 @@
+package com.singular.sdk.internal;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.InvalidPropertiesFormatException;
+import java.util.Iterator;
+import java.util.Map;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public abstract class BaseApi extends SingularMap implements Api {
+    public static final SingularLog logger = SingularLog.getLogger(BaseApi.class.getSimpleName());
+
+    public BaseApi(String str, long j) {
+        put("__TYPE__", str);
+        put("__TIMESTAMP__", String.valueOf(j));
+    }
+
+    public Map getParams() {
+        HashMap hashMap = new HashMap(this);
+        hashMap.remove("__TYPE__");
+        hashMap.remove("__TIMESTAMP__");
+        return hashMap;
+    }
+
+    public void addParams(Map map) {
+        if (map == null) {
+            return;
+        }
+        putAll(map);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public long getTimestamp() {
+        String str = (String) get("__TIMESTAMP__");
+        if (Utils.isEmptyOrNull(str)) {
+            return -1L;
+        }
+        return Long.parseLong(str);
+    }
+
+    public String getUrl() {
+        return "https://sdk-api-v1.singular.net/api/v1" + getPath();
+    }
+
+    public boolean makeRequest(SingularInstance singularInstance) {
+        return SingularRequestHandler.makeRequest(singularInstance, getUrl(), getParams(), getTimestamp(), getOnApiCallback());
+    }
+
+    public String toJsonAsString() {
+        return new JSONObject(this).toString();
+    }
+
+    public static BaseApi from(String str) {
+        if (str == null) {
+            throw new NullPointerException("api string cannot be null");
+        }
+        Map fromString = fromString(str);
+        String str2 = (String) fromString.get("__TYPE__");
+        String str3 = (String) fromString.get("__TIMESTAMP__");
+        long parseLong = !Utils.isEmptyOrNull(str3) ? Long.parseLong(str3) : -1L;
+        if ("EVENT".equalsIgnoreCase(str2)) {
+            ApiSubmitEvent apiSubmitEvent = new ApiSubmitEvent(parseLong);
+            apiSubmitEvent.addParams(fromString);
+            return apiSubmitEvent;
+        }
+        if ("SESSION_START".equalsIgnoreCase(str2)) {
+            ApiStartSession apiStartSession = new ApiStartSession(parseLong);
+            apiStartSession.addParams(fromString);
+            return apiStartSession;
+        }
+        if ("GDPR_CONSENT".equalsIgnoreCase(str2)) {
+            ApiGDPRConsent apiGDPRConsent = new ApiGDPRConsent(parseLong);
+            apiGDPRConsent.addParams(fromString);
+            return apiGDPRConsent;
+        }
+        if ("GDPR_UNDER_13".equalsIgnoreCase(str2)) {
+            ApiGDPRUnder13 apiGDPRUnder13 = new ApiGDPRUnder13(parseLong);
+            apiGDPRUnder13.addParams(fromString);
+            return apiGDPRUnder13;
+        }
+        if ("CUSTOM_USER_ID".equalsIgnoreCase(str2)) {
+            ApiCustomUserId apiCustomUserId = new ApiCustomUserId(parseLong);
+            apiCustomUserId.addParams(fromString);
+            return apiCustomUserId;
+        }
+        throw new InvalidPropertiesFormatException(String.format("Unknown type = %s", str2));
+    }
+
+    public static Map fromString(String str) {
+        try {
+            JSONObject jSONObject = new JSONObject(str);
+            HashMap hashMap = new HashMap();
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                String next = keys.next();
+                hashMap.put(next, (String) jSONObject.get(next));
+            }
+            return hashMap;
+        } catch (JSONException e) {
+            throw new IOException(e);
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/BroadcastReceivers.java

@@ -0,0 +1,26 @@
+package com.singular.sdk.internal;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+
+/* loaded from: classes4.dex */
+public abstract class BroadcastReceivers {
+    public static final SingularLog logger = SingularLog.getLogger(BroadcastReceivers.class.getSimpleName());
+
+    public static class NetworkChange extends BroadcastReceiver {
+        public final SingularInstance singular;
+
+        public NetworkChange(SingularInstance singularInstance) {
+            this.singular = singularInstance;
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public void onReceive(Context context, Intent intent) {
+            BroadcastReceivers.logger.debug("onReceive() action=%s ", intent.getAction());
+            if (Utils.isConnected(context)) {
+                this.singular.getApiManager().wakeUp();
+            }
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/Constants.java

@@ -0,0 +1,17 @@
+package com.singular.sdk.internal;
+
+import java.util.Locale;
+
+/* loaded from: classes4.dex */
+public interface Constants {
+    public static final String HTTP_USER_AGENT;
+    public static final String SDK_BUILD_INFO;
+    public static final String SDK_VERSION;
+
+    static {
+        Locale locale = Locale.US;
+        SDK_BUILD_INFO = String.format(locale, "%s; %s", "540af8d9.master", Utils.formatTimestamp(1593601221472L));
+        SDK_VERSION = String.format(locale, "Singular/v%s", "9.4.1");
+        HTTP_USER_AGENT = String.format(locale, "Singular/SDK-v%s.%s", "9.4.1", "PROD");
+    }
+}

decompiled/sources/com/singular/sdk/internal/DeviceInfo.java

@@ -0,0 +1,322 @@
+package com.singular.sdk.internal;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.DisplayMetrics;
+import android.webkit.WebSettings;
+import com.ironsource.tj;
+import com.ironsource.v8;
+import java.util.Locale;
+
+/* loaded from: classes4.dex */
+public class DeviceInfo {
+    public static final SingularLog logger = SingularLog.getLogger(DeviceInfo.class.getSimpleName());
+    public String abi;
+    public String aifa;
+    public String andi;
+    public String apiLevel;
+    public String appName;
+    public String appVersion;
+    public String buildProduct;
+    public String country;
+    public String customUserId;
+    public String deviceBrand;
+    public String deviceBuild;
+    public String deviceManufacturer;
+    public String deviceModel;
+    public String deviceType;
+    public String deviceUserAgent;
+    public String displayHeight;
+    public String displayWidth;
+    public String fbAttributionId;
+    public String fcmRegId;
+    public long firstInstallTime;
+    public String gcmProcessId;
+    public String gcmRegId;
+    public String hardwareName;
+    public String imei;
+    public String installSource;
+    public boolean isGooglePlayServicesAvailable;
+    public boolean isLimitedTrackingEnabled;
+    public String language;
+    public long lastUpdateTime;
+    public Locale locale;
+    public String osVersion;
+    public String packageName;
+    public String platform;
+    public String preloadCampaign;
+    public String preloadGroup;
+    public String preloadSource;
+    public String screenDensity;
+    public String screenFormat;
+    public String screenSize;
+    public String sdkVersion;
+
+    public final String getDeviceType(int i) {
+        int i2 = i & 15;
+        if (i2 == 1 || i2 == 2) {
+            return "phone";
+        }
+        if (i2 == 3 || i2 == 4) {
+            return "tablet";
+        }
+        return null;
+    }
+
+    public final String getScreenFormat(int i) {
+        int i2 = i & 48;
+        if (i2 == 16) {
+            return "normal";
+        }
+        if (i2 != 32) {
+            return null;
+        }
+        return "long";
+    }
+
+    public final String getScreenSize(int i) {
+        int i2 = i & 15;
+        if (i2 == 1) {
+            return "small";
+        }
+        if (i2 == 2) {
+            return "normal";
+        }
+        if (i2 == 3) {
+            return "large";
+        }
+        if (i2 != 4) {
+            return null;
+        }
+        return "xlarge";
+    }
+
+    public void setCustomUserId(String str) {
+        this.customUserId = str;
+    }
+
+    public void setFcmRegId(String str) {
+        this.fcmRegId = str;
+    }
+
+    public void setGcmRegId(String str) {
+        this.gcmRegId = str;
+    }
+
+    public DeviceInfo(Context context) {
+        setAppInfo(context);
+        setPreloadCampaign(context);
+        Resources resources = context.getResources();
+        DisplayMetrics displayMetrics = resources.getDisplayMetrics();
+        Configuration configuration = resources.getConfiguration();
+        Locale locale = Utils.getLocale(configuration);
+        this.locale = locale;
+        this.language = locale.getLanguage();
+        this.country = this.locale.getCountry();
+        int i = configuration.screenLayout;
+        this.screenSize = getScreenSize(i);
+        this.screenFormat = getScreenFormat(i);
+        this.deviceType = getDeviceType(i);
+        this.screenDensity = getScreenDensity(displayMetrics);
+        this.displayWidth = getDisplayWidth(displayMetrics);
+        this.displayHeight = getDisplayHeight(displayMetrics);
+        boolean isGooglePlayServicesAvailable = Utils.isGooglePlayServicesAvailable();
+        this.isGooglePlayServicesAvailable = isGooglePlayServicesAvailable;
+        if (isGooglePlayServicesAvailable) {
+            this.isLimitedTrackingEnabled = Utils.isLimitedTrackingEnabled(context);
+            this.aifa = Utils.getPlayStoreAdId(context);
+        }
+        if (Utils.isEmptyOrNull(this.aifa)) {
+            this.aifa = Utils.getPlayStoreAdIdByBackupMethod(context);
+        }
+        this.andi = Utils.getAndroidId(context);
+        this.installSource = getInstallSource(context);
+        this.fbAttributionId = getFacebookAttributionId(context);
+        setFcmRegId(context.getSharedPreferences("singular-pref-session", 0).getString("fcm_device_token_key", ""));
+        setGcmRegId(context.getSharedPreferences("singular-pref-session", 0).getString("gcm_device_token_key", ""));
+        getInstallTimestamps(context);
+        setCustomUserId(context.getSharedPreferences("singular-pref-session", 0).getString("custom_user_id", ""));
+        this.deviceUserAgent = getDeviceUserAgent(context);
+        log();
+    }
+
+    public final void setAppInfo(Context context) {
+        this.abi = getABI();
+        this.deviceBrand = Build.BRAND;
+        this.deviceBuild = Build.DEVICE;
+        this.packageName = context.getPackageName();
+        this.deviceManufacturer = Build.MANUFACTURER;
+        this.deviceModel = Build.MODEL;
+        this.platform = v8.d;
+        this.buildProduct = Build.PRODUCT;
+        this.osVersion = Build.VERSION.RELEASE;
+        this.hardwareName = Build.DISPLAY;
+        this.sdkVersion = Constants.SDK_VERSION;
+        this.appName = getAppName(context);
+        this.appVersion = getAppVersion(context);
+        this.apiLevel = String.format("%d", Integer.valueOf(Build.VERSION.SDK_INT));
+    }
+
+    public final String getAppVersion(Context context) {
+        try {
+            PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+            return TextUtils.isEmpty(packageInfo.versionName) ? "unknown" : packageInfo.versionName;
+        } catch (Exception unused) {
+            return "unknown";
+        }
+    }
+
+    public final String getInstallSource(Context context) {
+        try {
+            String installerPackageName = context.getPackageManager().getInstallerPackageName(context.getPackageName());
+            this.installSource = installerPackageName;
+            return installerPackageName;
+        } catch (Exception unused) {
+            return null;
+        }
+    }
+
+    public final String getAppName(Context context) {
+        try {
+            PackageManager packageManager = context.getPackageManager();
+            return packageManager.getApplicationLabel(packageManager.getApplicationInfo(context.getPackageName(), 128)).toString();
+        } catch (Exception unused) {
+            return "unknown";
+        }
+    }
+
+    public final String getScreenDensity(DisplayMetrics displayMetrics) {
+        int i = displayMetrics.densityDpi;
+        if (i == 0) {
+            return null;
+        }
+        return i < 140 ? "low" : i > 200 ? "high" : "medium";
+    }
+
+    public final String getDisplayWidth(DisplayMetrics displayMetrics) {
+        return String.valueOf(displayMetrics.widthPixels);
+    }
+
+    public final String getDisplayHeight(DisplayMetrics displayMetrics) {
+        return String.valueOf(displayMetrics.heightPixels);
+    }
+
+    public final String getFacebookAttributionId(Context context) {
+        try {
+            Cursor query = context.getContentResolver().query(Uri.parse("content://com.facebook.katana.provider.AttributionIdProvider"), new String[]{tj.b}, null, null, null);
+            if (query == null) {
+                return null;
+            }
+            if (!query.moveToFirst()) {
+                query.close();
+                return null;
+            }
+            String string = query.getString(query.getColumnIndex(tj.b));
+            query.close();
+            return string;
+        } catch (Exception unused) {
+            return null;
+        }
+    }
+
+    public final String getABI() {
+        String[] supportedAbis = Utils.getSupportedAbis();
+        if (supportedAbis == null || supportedAbis.length == 0) {
+            return Utils.getCpuAbi();
+        }
+        return supportedAbis[0];
+    }
+
+    public final String getDeviceUserAgent(Context context) {
+        String property = System.getProperty("http.agent", "");
+        if (!TextUtils.isEmpty(property)) {
+            return property;
+        }
+        try {
+            Class.forName("android.os.AsyncTask");
+            return WebSettings.getDefaultUserAgent(context);
+        } catch (Exception | VerifyError unused) {
+            return property;
+        }
+    }
+
+    public boolean hasPreloadCampaign() {
+        return (Utils.isEmptyOrNull(this.preloadCampaign) || Utils.isEmptyOrNull(this.preloadGroup) || Utils.isEmptyOrNull(this.preloadSource)) ? false : true;
+    }
+
+    public final void setPreloadCampaign(Context context) {
+        try {
+            Bundle bundle = context.getPackageManager().getApplicationInfo(context.getPackageName(), 128).metaData;
+            this.preloadCampaign = bundle.getString("SINGULAR_PRELOAD_CAMPAIGN");
+            this.preloadGroup = bundle.getString("SINGULAR_PRELOAD_GROUP");
+            this.preloadSource = bundle.getString("SINGULAR_PRELOAD_SOURCE");
+        } catch (Exception e) {
+            logger.error("error in setPreloadCampaign()", e);
+        }
+    }
+
+    public final void getInstallTimestamps(Context context) {
+        try {
+            PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+            this.firstInstallTime = packageInfo.firstInstallTime;
+            this.lastUpdateTime = packageInfo.lastUpdateTime;
+        } catch (PackageManager.NameNotFoundException unused) {
+        } catch (RuntimeException e) {
+            logger.error("getInstallDates failed", e);
+        }
+    }
+
+    public void log() {
+        SingularLog singularLog = logger;
+        if (singularLog.isDebugEnabled()) {
+            singularLog.debug("DeviceInfo ----> ");
+            singularLog.debug("\t andi : %s", this.andi);
+            singularLog.debug("\t aifa : %s", this.aifa);
+            singularLog.debug("\t isGooglePlayServicesAvailable : %b", Boolean.valueOf(this.isGooglePlayServicesAvailable));
+            singularLog.debug("\t isLimitedTrackingEnabled : %b", Boolean.valueOf(this.isLimitedTrackingEnabled));
+            singularLog.debug("\t appVersion : %s", this.appVersion);
+            singularLog.debug("\t sdkVersion : %s", this.sdkVersion);
+            singularLog.debug("\t packageName : %s", this.packageName);
+            singularLog.debug("\t appName : %s", this.appName);
+            singularLog.debug("\t preloadCampaign : %s", this.preloadCampaign);
+            singularLog.debug("\t preloadGroup : %s", this.preloadGroup);
+            singularLog.debug("\t preloadSource : %s", this.preloadSource);
+            singularLog.debug("\t installSource : %s", this.installSource);
+            singularLog.debug("\t fbAttributionId : %s", this.fbAttributionId);
+            singularLog.debug("\t abi : %s", this.abi);
+            singularLog.debug("\t deviceBrand : %s", this.deviceBrand);
+            singularLog.debug("\t deviceBuild : %s", this.deviceBuild);
+            singularLog.debug("\t deviceManufacturer : %s", this.deviceManufacturer);
+            singularLog.debug("\t deviceModel : %s", this.deviceModel);
+            singularLog.debug("\t platform : %s", this.platform);
+            singularLog.debug("\t buildProduct : %s", this.buildProduct);
+            singularLog.debug("\t osVersion : %s", this.osVersion);
+            singularLog.debug("\t apiLevel : %s", this.apiLevel);
+            singularLog.debug("\t hardwareName : %s", this.hardwareName);
+            singularLog.debug("\t locale : %s", this.locale);
+            singularLog.debug("\t language : %s", this.language);
+            singularLog.debug("\t country : %s", this.country);
+            singularLog.debug("\t screenSize : %s", this.screenSize);
+            singularLog.debug("\t screenFormat : %s", this.screenFormat);
+            singularLog.debug("\t screenDensity : %s", this.screenDensity);
+            singularLog.debug("\t displayWidth : %s", this.displayWidth);
+            singularLog.debug("\t displayHeight : %s", this.displayHeight);
+            singularLog.debug("\t gcmProcessId : %s", this.gcmProcessId);
+            singularLog.debug("\t gcmRegId : %s", this.gcmRegId);
+            singularLog.debug("\t fcmRegId : %s", this.fcmRegId);
+            singularLog.debug("\t firstInstallTime : %d", Long.valueOf(this.firstInstallTime));
+            singularLog.debug("\t lastUpdateTime : %d", Long.valueOf(this.lastUpdateTime));
+            singularLog.debug("\t deviceType : %s", this.deviceType);
+            singularLog.debug("\t customUserId : %s", this.customUserId);
+            singularLog.debug("\t deviceUserAgent: %s", this.deviceUserAgent);
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/ExternalAIFAHelper.java

@@ -0,0 +1,116 @@
+package com.singular.sdk.internal;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.util.Log;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/* loaded from: classes4.dex */
+public abstract class ExternalAIFAHelper {
+    public static String getAIFA(Context context) {
+        try {
+            return queryAdvertisingIdFromService(context);
+        } catch (Exception unused) {
+            Log.w("Singular/ExtAIFAHelper", "Could not determine AIFA");
+            return null;
+        }
+    }
+
+    public static String queryAdvertisingIdFromService(Context context) {
+        GoogleAdvertisingServiceConnection googleAdvertisingServiceConnection = new GoogleAdvertisingServiceConnection();
+        Intent intent = new Intent("com.google.android.gms.ads.identifier.service.START");
+        intent.setPackage("com.google.android.gms");
+        if (!context.bindService(intent, googleAdvertisingServiceConnection, 1)) {
+            return "";
+        }
+        try {
+            return GoogleAdvertisingInfo.GoogleAdvertisingInfoBinder.Create(googleAdvertisingServiceConnection.getBinder()).getId();
+        } catch (Exception unused) {
+            return "";
+        } finally {
+            context.unbindService(googleAdvertisingServiceConnection);
+        }
+    }
+
+    public static class GoogleAdvertisingServiceConnection implements ServiceConnection {
+        public final BlockingQueue _binderQueue;
+        public boolean _consumed;
+
+        @Override // android.content.ServiceConnection
+        public void onServiceDisconnected(ComponentName componentName) {
+        }
+
+        public GoogleAdvertisingServiceConnection() {
+            this._consumed = false;
+            this._binderQueue = new LinkedBlockingQueue();
+        }
+
+        @Override // android.content.ServiceConnection
+        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
+            try {
+                this._binderQueue.put(iBinder);
+            } catch (InterruptedException unused) {
+            }
+        }
+
+        public IBinder getBinder() {
+            if (this._consumed) {
+                throw new IllegalStateException();
+            }
+            this._consumed = true;
+            return (IBinder) this._binderQueue.take();
+        }
+    }
+
+    public interface GoogleAdvertisingInfo extends IInterface {
+        String getId();
+
+        public static abstract class GoogleAdvertisingInfoBinder extends Binder implements GoogleAdvertisingInfo {
+            public static GoogleAdvertisingInfo Create(IBinder iBinder) {
+                if (iBinder == null) {
+                    return null;
+                }
+                IInterface queryLocalInterface = iBinder.queryLocalInterface("com.google.android.gms.ads.identifier.internal.IAdvertisingIdService");
+                if (queryLocalInterface != null && (queryLocalInterface instanceof GoogleAdvertisingInfo)) {
+                    return (GoogleAdvertisingInfo) queryLocalInterface;
+                }
+                return new GoogleAdvertisingInfoImplementation(iBinder);
+            }
+
+            public static class GoogleAdvertisingInfoImplementation implements GoogleAdvertisingInfo {
+                public IBinder _binder;
+
+                @Override // android.os.IInterface
+                public IBinder asBinder() {
+                    return this._binder;
+                }
+
+                public GoogleAdvertisingInfoImplementation(IBinder iBinder) {
+                    this._binder = iBinder;
+                }
+
+                @Override // com.singular.sdk.internal.ExternalAIFAHelper.GoogleAdvertisingInfo
+                public String getId() {
+                    Parcel obtain = Parcel.obtain();
+                    Parcel obtain2 = Parcel.obtain();
+                    try {
+                        obtain.writeInterfaceToken("com.google.android.gms.ads.identifier.internal.IAdvertisingIdService");
+                        this._binder.transact(1, obtain, obtain2, 0);
+                        obtain2.readException();
+                        return obtain2.readString();
+                    } finally {
+                        obtain2.recycle();
+                        obtain.recycle();
+                    }
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/FixedSizePersistentQueue.java

@@ -0,0 +1,81 @@
+package com.singular.sdk.internal;
+
+import android.content.Context;
+import com.singular.sdk.internal.QueueFile;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.OutputStreamWriter;
+
+/* loaded from: classes4.dex */
+public final class FixedSizePersistentQueue implements Queue {
+    public static final SingularLog logger = SingularLog.getLogger(FixedSizePersistentQueue.class.getSimpleName());
+    public final int MAX_SIZE;
+    public final DirectByteArrayOutputStream bytes = new DirectByteArrayOutputStream();
+    public final QueueFile queueFile;
+
+    public static class DirectByteArrayOutputStream extends ByteArrayOutputStream {
+        public byte[] getArray() {
+            return ((ByteArrayOutputStream) this).buf;
+        }
+    }
+
+    public static FixedSizePersistentQueue create(Context context, String str, int i) {
+        File file = new File(context.getFilesDir(), str);
+        if (file.exists()) {
+            logger.debug("FYI - file %s already exists, will reuse.", file.getName());
+        }
+        return new FixedSizePersistentQueue(new QueueFile.Builder(file).build(), i);
+    }
+
+    public FixedSizePersistentQueue(QueueFile queueFile, int i) {
+        this.queueFile = queueFile;
+        this.MAX_SIZE = i;
+    }
+
+    public synchronized int size() {
+        return this.queueFile.size();
+    }
+
+    public synchronized boolean isEmpty() {
+        return size() == 0;
+    }
+
+    @Override // com.singular.sdk.internal.Queue
+    public synchronized void add(String str) {
+        try {
+            if (Utils.isEmptyOrNull(str)) {
+                return;
+            }
+            if (this.queueFile.size() >= this.MAX_SIZE) {
+                this.queueFile.remove(1);
+            }
+            this.bytes.reset();
+            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(this.bytes);
+            outputStreamWriter.write(str);
+            outputStreamWriter.close();
+            this.queueFile.add(this.bytes.getArray(), 0, this.bytes.size());
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    @Override // com.singular.sdk.internal.Queue
+    public synchronized String peek() {
+        byte[] peek = this.queueFile.peek();
+        if (peek == null) {
+            return null;
+        }
+        return new String(peek, "UTF-8");
+    }
+
+    @Override // com.singular.sdk.internal.Queue
+    public synchronized void remove() {
+        remove(1);
+    }
+
+    public synchronized void remove(int i) {
+        if (i <= size()) {
+            this.queueFile.remove(i);
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/LicenseApiHelper.java

@@ -0,0 +1,20 @@
+package com.singular.sdk.internal;
+
+import android.content.Context;
+
+/* loaded from: classes4.dex */
+public abstract class LicenseApiHelper {
+    public static final SingularLog logger = SingularLog.getLogger(LicenseApiHelper.class.getSimpleName());
+
+    public static abstract class LicenseResultHandler {
+        public abstract void handle(int i, String str, String str2);
+    }
+
+    public static void checkLicense(Context context, LicenseResultHandler licenseResultHandler) {
+        try {
+            new LicenseChecker(context, licenseResultHandler).checkAccess();
+        } catch (Exception e) {
+            logger.error("Error occurred while trying to run license check", e);
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/LicenseChecker.java

@@ -0,0 +1,94 @@
+package com.singular.sdk.internal;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.IBinder;
+import android.os.RemoteException;
+import com.android.vending.licensing.ILicenseResultListener;
+import com.android.vending.licensing.ILicensingService;
+import com.singular.sdk.internal.LicenseApiHelper;
+import java.security.SecureRandom;
+
+/* loaded from: classes4.dex */
+public class LicenseChecker implements ServiceConnection {
+    public static final SecureRandom RANDOM = new SecureRandom();
+    public static final SingularLog logger = SingularLog.getLogger(LicenseApiHelper.class.getSimpleName());
+    public final LicenseApiHelper.LicenseResultHandler handler;
+    public final Context mContext;
+    public Handler mHandler;
+    public final String mPackageName;
+    public ILicensingService mService;
+
+    public LicenseChecker(Context context, LicenseApiHelper.LicenseResultHandler licenseResultHandler) {
+        HandlerThread handlerThread = new HandlerThread("license_checker");
+        handlerThread.start();
+        this.mContext = context;
+        this.mPackageName = context.getPackageName();
+        this.mHandler = new Handler(handlerThread.getLooper());
+        this.handler = licenseResultHandler;
+    }
+
+    public synchronized void checkAccess() {
+        ILicensingService iLicensingService = this.mService;
+        if (iLicensingService == null) {
+            SingularLog singularLog = logger;
+            singularLog.info("Binding to licensing service.");
+            try {
+                if (!this.mContext.bindService(new Intent("com.android.vending.licensing.ILicensingService").setPackage("com.android.vending"), this, 1)) {
+                    singularLog.error("Could not bind to service.");
+                    this.handler.handle(-1, "Binding failed", "");
+                }
+            } catch (SecurityException e) {
+                logger.error("SecurityException", e);
+                this.handler.handle(-1, String.format("Exception: %s, Message: %s", e.toString(), e.getMessage()), "");
+            }
+            logger.info("Binding done.");
+        } else {
+            try {
+                iLicensingService.checkLicense(generateNonce(), this.mPackageName, new ResultListener());
+            } catch (RemoteException e2) {
+                logger.error("RemoteException in checkLicense call.", e2);
+                this.handler.handle(-1, String.format("Exception: %s, Message: %s", e2.toString(), e2.getMessage()), "");
+            }
+        }
+    }
+
+    @Override // android.content.ServiceConnection
+    public synchronized void onServiceConnected(ComponentName componentName, IBinder iBinder) {
+        SingularLog singularLog = logger;
+        singularLog.info("onServiceConnected.");
+        ILicensingService asInterface = ILicensingService.Stub.asInterface(iBinder);
+        this.mService = asInterface;
+        try {
+            asInterface.checkLicense(generateNonce(), this.mPackageName, new ResultListener());
+            singularLog.info("checkLicense call done.");
+        } catch (RemoteException e) {
+            logger.error("RemoteException in checkLicense call.", e);
+            this.handler.handle(-1, e.toString(), "");
+        }
+    }
+
+    @Override // android.content.ServiceConnection
+    public synchronized void onServiceDisconnected(ComponentName componentName) {
+        logger.info("Service unexpectedly disconnected.");
+        this.mService = null;
+    }
+
+    public class ResultListener extends ILicenseResultListener.Stub {
+        public ResultListener() {
+        }
+
+        @Override // com.android.vending.licensing.ILicenseResultListener
+        public void verifyLicense(int i, String str, String str2) {
+            LicenseChecker.this.handler.handle(i, str, str2);
+        }
+    }
+
+    public final int generateNonce() {
+        return RANDOM.nextInt();
+    }
+}

decompiled/sources/com/singular/sdk/internal/NewPlayReferrerUtils.java

@@ -0,0 +1,54 @@
+package com.singular.sdk.internal;
+
+import android.content.Context;
+import com.android.installreferrer.api.InstallReferrerClient;
+import com.android.installreferrer.api.InstallReferrerStateListener;
+import com.android.installreferrer.api.ReferrerDetails;
+
+/* loaded from: classes4.dex */
+public abstract class NewPlayReferrerUtils {
+    public static final SingularLog logger = SingularLog.getLogger(NewPlayReferrerUtils.class.getSimpleName());
+
+    public static class NewPlayReferrerCallback {
+        public abstract void handleNotSupported();
+
+        public abstract void handleReferrerValue(String str, long j, long j2);
+    }
+
+    public static void queryNewPlayReferrerValue(Context context, final NewPlayReferrerCallback newPlayReferrerCallback) {
+        final InstallReferrerClient build = InstallReferrerClient.newBuilder(context).build();
+        build.startConnection(new InstallReferrerStateListener() { // from class: com.singular.sdk.internal.NewPlayReferrerUtils.1
+            @Override // com.android.installreferrer.api.InstallReferrerStateListener
+            public void onInstallReferrerServiceDisconnected() {
+            }
+
+            @Override // com.android.installreferrer.api.InstallReferrerStateListener
+            public void onInstallReferrerSetupFinished(int i) {
+                NewPlayReferrerUtils.logger.debug("onInstallReferrerSetupFinished: responseCode=" + i);
+                if (i == 0) {
+                    try {
+                        ReferrerDetails installReferrer = InstallReferrerClient.this.getInstallReferrer();
+                        NewPlayReferrerCallback newPlayReferrerCallback2 = newPlayReferrerCallback;
+                        if (newPlayReferrerCallback2 != null) {
+                            newPlayReferrerCallback2.handleReferrerValue(installReferrer.getInstallReferrer(), installReferrer.getReferrerClickTimestampSeconds(), installReferrer.getInstallBeginTimestampSeconds());
+                        }
+                    } catch (Exception unused) {
+                        NewPlayReferrerUtils.logger.error("onInstallReferrerSetupFinished: failed to get referrer value");
+                    }
+                } else if (i == 1) {
+                    newPlayReferrerCallback.handleNotSupported();
+                    NewPlayReferrerUtils.logger.debug("onInstallReferrerSetupFinished: SERVICE_UNAVAILABLE");
+                } else if (i == 2) {
+                    newPlayReferrerCallback.handleNotSupported();
+                    NewPlayReferrerUtils.logger.debug("onInstallReferrerSetupFinished: FEATURE_NOT_SUPPORTED");
+                } else if (i == 3) {
+                    newPlayReferrerCallback.handleNotSupported();
+                    NewPlayReferrerUtils.logger.error("onInstallReferrerSetupFinished: DEVELOPER_ERROR");
+                }
+                if (InstallReferrerClient.this.isReady()) {
+                    InstallReferrerClient.this.endConnection();
+                }
+            }
+        });
+    }
+}

decompiled/sources/com/singular/sdk/internal/OfflineEventsMigrator.java

@@ -0,0 +1,144 @@
+package com.singular.sdk.internal;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import com.applovin.sdk.AppLovinEventTypes;
+import com.glu.plugins.gluanalytics.AnalyticsData;
+import com.ironsource.mediationsdk.impressionData.ImpressionData;
+import com.ironsource.nb;
+import com.ironsource.v8;
+import com.mbridge.msdk.foundation.download.core.DownloadCommon;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.mbridge.msdk.foundation.same.report.i;
+import com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlNode;
+import csdk.gluads.Consts;
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class OfflineEventsMigrator {
+    public static final SingularLog logger = SingularLog.getLogger("OfflineEventsMigrator");
+    public String aifa;
+    public String andi;
+    public String apiKey;
+    public String apid;
+    public String bmac;
+    public String canonicalDeviceId;
+    public String canonicalKeyspace;
+    public Context ctx;
+    public SQLiteDatabase database;
+    public String databaseName;
+    public String imei;
+    public String mac1;
+
+    public OfflineEventsMigrator(Context context) {
+        this.databaseName = "";
+        this.ctx = context;
+        try {
+            File databasePath = context.getDatabasePath("Apsalar.sqlite_" + context.getSharedPreferences("ApsalarAppPrefs", 0).getString("HASH", ""));
+            if (databasePath.exists()) {
+                String path = databasePath.getPath();
+                this.databaseName = path;
+                this.database = SQLiteDatabase.openDatabase(path, null, 0);
+            }
+        } catch (Exception e) {
+            logger.error("Error in OfflineEventsMigrator", e);
+        }
+    }
+
+    public void deleteDatabase() {
+        if (this.database != null) {
+            this.ctx.deleteDatabase(this.databaseName);
+        }
+    }
+
+    public void migrate() {
+        SQLiteDatabase sQLiteDatabase = this.database;
+        if (sQLiteDatabase == null) {
+            logger.debug("No database found; skipping.");
+            return;
+        }
+        Cursor rawQuery = sQLiteDatabase.rawQuery("SELECT * FROM config", null);
+        if (rawQuery == null || rawQuery.getCount() == 0) {
+            return;
+        }
+        while (rawQuery.moveToNext()) {
+            this.apiKey = rawQuery.getString(0);
+            this.andi = rawQuery.getString(5);
+            this.aifa = rawQuery.getString(6);
+            this.imei = rawQuery.getString(7);
+            this.apid = rawQuery.getString(10);
+            this.canonicalDeviceId = rawQuery.getString(12);
+            this.canonicalKeyspace = rawQuery.getString(11);
+            this.mac1 = rawQuery.getString(8);
+            this.bmac = rawQuery.getString(9);
+        }
+        rawQuery.close();
+        Cursor rawQuery2 = this.database.rawQuery("SELECT * FROM events", null);
+        if (rawQuery2 == null || rawQuery2.getCount() == 0) {
+            return;
+        }
+        int i = 0;
+        while (rawQuery2.moveToNext()) {
+            try {
+                HashMap hashMap = new HashMap();
+                hashMap.put("__TIMESTAMP__", rawQuery2.getString(1));
+                String string = rawQuery2.getString(4);
+                if (!Utils.isEmptyOrNull(string)) {
+                    hashMap.put(nb.q, string);
+                }
+                String string2 = rawQuery2.getString(5);
+                if (!Utils.isEmptyOrNull(string2)) {
+                    hashMap.put("e", string2);
+                }
+                JSONObject jSONObject = new JSONObject(rawQuery2.getString(2));
+                int i2 = rawQuery2.getInt(3);
+                if (i2 == 1) {
+                    hashMap.put("__TYPE__", "SESSION_START");
+                    hashMap.put(nb.q, jSONObject.getString("appName"));
+                } else if (i2 == 3) {
+                    hashMap.put("__TYPE__", "EVENT");
+                } else if (i2 == 5) {
+                    hashMap.put("__TYPE__", "RESOLVE");
+                }
+                hashMap.put("s", jSONObject.getString("sessionId"));
+                hashMap.put("a", jSONObject.getString("apiKey"));
+                hashMap.put(ImpressionData.IMPRESSION_DATA_KEY_ABTEST, jSONObject.getString("abi"));
+                hashMap.put(TtmlNode.TAG_P, jSONObject.getString("platform"));
+                hashMap.put(i.a, jSONObject.getString("clsPackage"));
+                hashMap.put("av", jSONObject.getString(v8.i.W));
+                hashMap.put("sdk", jSONObject.getString("sdkVersion"));
+                hashMap.put("ma", jSONObject.getString("manufacturer"));
+                hashMap.put(TtmlNode.TAG_BR, jSONObject.getString("brand"));
+                hashMap.put("mo", jSONObject.getString("model"));
+                hashMap.put(Consts.KEY_TAPJOY_USER_ID_VERSION, jSONObject.getString(AnalyticsData.S_OS_VERSION));
+                hashMap.put("c", jSONObject.getString("connType"));
+                hashMap.put("pr", jSONObject.getString(AppLovinEventTypes.USER_VIEWED_PRODUCT));
+                hashMap.put(DownloadCommon.DOWNLOAD_REPORT_DOWNLOAD_ERROR, jSONObject.getString("device"));
+                if (!Utils.isEmptyOrNull(this.aifa)) {
+                    hashMap.put("aifa", this.aifa);
+                    hashMap.put(CampaignEx.JSON_KEY_AD_K, "AIFA");
+                    hashMap.put("u", this.canonicalDeviceId);
+                } else {
+                    hashMap.put(CampaignEx.JSON_KEY_AD_K, "ANDI");
+                    hashMap.put("u", this.andi);
+                }
+                try {
+                    SingularInstance.getInstance().getApiManager().enqueue(BaseApi.from(new JSONObject(hashMap).toString()));
+                    this.database.delete("events", "id=" + rawQuery2.getString(0), null);
+                    i++;
+                } catch (IOException e) {
+                    logger.error("Error in JSON serialization", e);
+                }
+            } catch (Exception e2) {
+                logger.debug(e2.getMessage());
+            }
+        }
+        rawQuery2.close();
+        deleteDatabase();
+        logger.debug("Migrated " + i + " events!");
+    }
+}

decompiled/sources/com/singular/sdk/internal/Queue.java

@@ -0,0 +1,10 @@
+package com.singular.sdk.internal;
+
+/* loaded from: classes4.dex */
+public interface Queue {
+    void add(String str);
+
+    String peek();
+
+    void remove();
+}

decompiled/sources/com/singular/sdk/internal/QueueFile.java

@@ -0,0 +1,507 @@
+package com.singular.sdk.internal;
+
+import android.support.v4.media.session.PlaybackStateCompat;
+import com.ironsource.v8;
+import csdk.gluads.Consts;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.channels.FileChannel;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.ByteCompanionObject;
+
+/* loaded from: classes4.dex */
+public final class QueueFile implements Closeable, Iterable {
+    public static final byte[] ZEROES = new byte[4096];
+    public final byte[] buffer;
+    public boolean closed;
+    public int elementCount;
+    public final File file;
+    public long fileLength;
+    public Element first;
+    public int headerLength;
+    public Element last;
+    public int modCount = 0;
+    public final RandomAccessFile raf;
+    public boolean versioned;
+    public final boolean zero;
+
+    public boolean isEmpty() {
+        return this.elementCount == 0;
+    }
+
+    public int size() {
+        return this.elementCount;
+    }
+
+    public long wrapPosition(long j) {
+        long j2 = this.fileLength;
+        return j < j2 ? j : (this.headerLength + j) - j2;
+    }
+
+    public static RandomAccessFile initializeFromFile(File file, boolean z) {
+        if (!file.exists()) {
+            File file2 = new File(file.getPath() + ".tmp");
+            RandomAccessFile open = open(file2);
+            try {
+                open.setLength(PlaybackStateCompat.ACTION_SKIP_TO_QUEUE_ITEM);
+                open.seek(0L);
+                if (z) {
+                    open.writeInt(4096);
+                } else {
+                    open.writeInt(-2147483647);
+                    open.writeLong(PlaybackStateCompat.ACTION_SKIP_TO_QUEUE_ITEM);
+                }
+                open.close();
+                if (!file2.renameTo(file)) {
+                    throw new IOException("Rename failed!");
+                }
+            } catch (Throwable th) {
+                open.close();
+                throw th;
+            }
+        }
+        return open(file);
+    }
+
+    public static RandomAccessFile open(File file) {
+        return new RandomAccessFile(file, "rwd");
+    }
+
+    public QueueFile(File file, RandomAccessFile randomAccessFile, boolean z, boolean z2) {
+        long readInt;
+        long j;
+        byte[] bArr = new byte[32];
+        this.buffer = bArr;
+        this.file = file;
+        this.raf = randomAccessFile;
+        this.zero = z;
+        randomAccessFile.seek(0L);
+        randomAccessFile.readFully(bArr);
+        boolean z3 = (z2 || (bArr[0] & ByteCompanionObject.MIN_VALUE) == 0) ? false : true;
+        this.versioned = z3;
+        if (z3) {
+            this.headerLength = 32;
+            int readInt2 = readInt(bArr, 0) & Integer.MAX_VALUE;
+            if (readInt2 != 1) {
+                throw new IOException("Unable to read version " + readInt2 + " format. Supported versions are 1 and legacy.");
+            }
+            this.fileLength = readLong(bArr, 4);
+            this.elementCount = readInt(bArr, 12);
+            j = readLong(bArr, 16);
+            readInt = readLong(bArr, 24);
+        } else {
+            this.headerLength = 16;
+            this.fileLength = readInt(bArr, 0);
+            this.elementCount = readInt(bArr, 4);
+            long readInt3 = readInt(bArr, 8);
+            readInt = readInt(bArr, 12);
+            j = readInt3;
+        }
+        if (this.fileLength > randomAccessFile.length()) {
+            throw new IOException("File is truncated. Expected length: " + this.fileLength + ", Actual length: " + randomAccessFile.length());
+        }
+        if (this.fileLength <= this.headerLength) {
+            throw new IOException("File is corrupt; length stored in header (" + this.fileLength + ") is invalid.");
+        }
+        this.first = readElement(j);
+        this.last = readElement(readInt);
+    }
+
+    public static void writeInt(byte[] bArr, int i, int i2) {
+        bArr[i] = (byte) (i2 >> 24);
+        bArr[i + 1] = (byte) (i2 >> 16);
+        bArr[i + 2] = (byte) (i2 >> 8);
+        bArr[i + 3] = (byte) i2;
+    }
+
+    public static int readInt(byte[] bArr, int i) {
+        return ((bArr[i] & 255) << 24) + ((bArr[i + 1] & 255) << 16) + ((bArr[i + 2] & 255) << 8) + (bArr[i + 3] & 255);
+    }
+
+    public static void writeLong(byte[] bArr, int i, long j) {
+        bArr[i] = (byte) (j >> 56);
+        bArr[i + 1] = (byte) (j >> 48);
+        bArr[i + 2] = (byte) (j >> 40);
+        bArr[i + 3] = (byte) (j >> 32);
+        bArr[i + 4] = (byte) (j >> 24);
+        bArr[i + 5] = (byte) (j >> 16);
+        bArr[i + 6] = (byte) (j >> 8);
+        bArr[i + 7] = (byte) j;
+    }
+
+    public static long readLong(byte[] bArr, int i) {
+        return ((bArr[i] & 255) << 56) + ((bArr[i + 1] & 255) << 48) + ((bArr[i + 2] & 255) << 40) + ((bArr[i + 3] & 255) << 32) + ((bArr[i + 4] & 255) << 24) + ((bArr[i + 5] & 255) << 16) + ((bArr[i + 6] & 255) << 8) + (bArr[i + 7] & 255);
+    }
+
+    public final void writeHeader(long j, int i, long j2, long j3) {
+        this.raf.seek(0L);
+        if (this.versioned) {
+            writeInt(this.buffer, 0, -2147483647);
+            writeLong(this.buffer, 4, j);
+            writeInt(this.buffer, 12, i);
+            writeLong(this.buffer, 16, j2);
+            writeLong(this.buffer, 24, j3);
+            this.raf.write(this.buffer, 0, 32);
+            return;
+        }
+        writeInt(this.buffer, 0, (int) j);
+        writeInt(this.buffer, 4, i);
+        writeInt(this.buffer, 8, (int) j2);
+        writeInt(this.buffer, 12, (int) j3);
+        this.raf.write(this.buffer, 0, 16);
+    }
+
+    public Element readElement(long j) {
+        if (j == 0) {
+            return Element.NULL;
+        }
+        ringRead(j, this.buffer, 0, 4);
+        return new Element(j, readInt(this.buffer, 0));
+    }
+
+    public final void ringWrite(long j, byte[] bArr, int i, int i2) {
+        long wrapPosition = wrapPosition(j);
+        long j2 = i2 + wrapPosition;
+        long j3 = this.fileLength;
+        if (j2 <= j3) {
+            this.raf.seek(wrapPosition);
+            this.raf.write(bArr, i, i2);
+            return;
+        }
+        int i3 = (int) (j3 - wrapPosition);
+        this.raf.seek(wrapPosition);
+        this.raf.write(bArr, i, i3);
+        this.raf.seek(this.headerLength);
+        this.raf.write(bArr, i + i3, i2 - i3);
+    }
+
+    public final void ringErase(long j, long j2) {
+        while (j2 > 0) {
+            byte[] bArr = ZEROES;
+            int min = (int) Math.min(j2, bArr.length);
+            ringWrite(j, bArr, 0, min);
+            long j3 = min;
+            j2 -= j3;
+            j += j3;
+        }
+    }
+
+    public void ringRead(long j, byte[] bArr, int i, int i2) {
+        long wrapPosition = wrapPosition(j);
+        long j2 = i2 + wrapPosition;
+        long j3 = this.fileLength;
+        if (j2 <= j3) {
+            this.raf.seek(wrapPosition);
+            this.raf.readFully(bArr, i, i2);
+            return;
+        }
+        int i3 = (int) (j3 - wrapPosition);
+        this.raf.seek(wrapPosition);
+        this.raf.readFully(bArr, i, i3);
+        this.raf.seek(this.headerLength);
+        this.raf.readFully(bArr, i + i3, i2 - i3);
+    }
+
+    public void add(byte[] bArr, int i, int i2) {
+        long wrapPosition;
+        if (bArr == null) {
+            throw new NullPointerException("data == null");
+        }
+        if ((i | i2) < 0 || i2 > bArr.length - i) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        expandIfNecessary(i2);
+        boolean isEmpty = isEmpty();
+        if (isEmpty) {
+            wrapPosition = this.headerLength;
+        } else {
+            wrapPosition = wrapPosition(this.last.position + 4 + r0.length);
+        }
+        Element element = new Element(wrapPosition, i2);
+        writeInt(this.buffer, 0, i2);
+        ringWrite(element.position, this.buffer, 0, 4);
+        ringWrite(element.position + 4, bArr, i, i2);
+        writeHeader(this.fileLength, this.elementCount + 1, isEmpty ? element.position : this.first.position, element.position);
+        this.last = element;
+        this.elementCount++;
+        this.modCount++;
+        if (isEmpty) {
+            this.first = element;
+        }
+    }
+
+    public final long usedBytes() {
+        if (this.elementCount == 0) {
+            return this.headerLength;
+        }
+        long j = this.last.position;
+        long j2 = this.first.position;
+        if (j >= j2) {
+            return (j - j2) + 4 + r0.length + this.headerLength;
+        }
+        return (((j + 4) + r0.length) + this.fileLength) - j2;
+    }
+
+    public final long remainingBytes() {
+        return this.fileLength - usedBytes();
+    }
+
+    public final void expandIfNecessary(long j) {
+        long j2;
+        long j3;
+        long j4 = j + 4;
+        long remainingBytes = remainingBytes();
+        if (remainingBytes >= j4) {
+            return;
+        }
+        long j5 = this.fileLength;
+        while (true) {
+            remainingBytes += j5;
+            j2 = j5 << 1;
+            if (remainingBytes >= j4) {
+                break;
+            } else {
+                j5 = j2;
+            }
+        }
+        setLength(j2);
+        long wrapPosition = wrapPosition(this.last.position + 4 + r2.length);
+        if (wrapPosition <= this.first.position) {
+            FileChannel channel = this.raf.getChannel();
+            channel.position(this.fileLength);
+            int i = this.headerLength;
+            j3 = wrapPosition - i;
+            if (channel.transferTo(i, j3, channel) != j3) {
+                throw new AssertionError("Copied insufficient number of bytes!");
+            }
+        } else {
+            j3 = 0;
+        }
+        long j6 = j3;
+        long j7 = this.last.position;
+        long j8 = this.first.position;
+        if (j7 < j8) {
+            long j9 = (this.fileLength + j7) - this.headerLength;
+            writeHeader(j2, this.elementCount, j8, j9);
+            this.last = new Element(j9, this.last.length);
+        } else {
+            writeHeader(j2, this.elementCount, j8, j7);
+        }
+        this.fileLength = j2;
+        if (this.zero) {
+            ringErase(this.headerLength, j6);
+        }
+    }
+
+    public final void setLength(long j) {
+        this.raf.setLength(j);
+        this.raf.getChannel().force(true);
+    }
+
+    public byte[] peek() {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        if (isEmpty()) {
+            return null;
+        }
+        Element element = this.first;
+        int i = element.length;
+        if (i > 32768) {
+            throw new IOException("QueueFile is probably corrupt, first.length is " + this.first.length);
+        }
+        byte[] bArr = new byte[i];
+        ringRead(4 + element.position, bArr, 0, i);
+        return bArr;
+    }
+
+    @Override // java.lang.Iterable
+    public Iterator iterator() {
+        return new ElementIterator();
+    }
+
+    public final class ElementIterator implements Iterator {
+        public int expectedModCount;
+        public int nextElementIndex = 0;
+        public long nextElementPosition;
+
+        public ElementIterator() {
+            this.nextElementPosition = QueueFile.this.first.position;
+            this.expectedModCount = QueueFile.this.modCount;
+        }
+
+        public final void checkForComodification() {
+            if (QueueFile.this.modCount != this.expectedModCount) {
+                throw new ConcurrentModificationException();
+            }
+        }
+
+        @Override // java.util.Iterator
+        public boolean hasNext() {
+            if (QueueFile.this.closed) {
+                throw new IllegalStateException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            checkForComodification();
+            return this.nextElementIndex != QueueFile.this.elementCount;
+        }
+
+        @Override // java.util.Iterator
+        public byte[] next() {
+            if (QueueFile.this.closed) {
+                throw new IllegalStateException(Consts.PLACEMENT_STATUS_CLOSED);
+            }
+            checkForComodification();
+            if (QueueFile.this.isEmpty()) {
+                throw new NoSuchElementException();
+            }
+            int i = this.nextElementIndex;
+            QueueFile queueFile = QueueFile.this;
+            if (i >= queueFile.elementCount) {
+                throw new NoSuchElementException();
+            }
+            try {
+                Element readElement = queueFile.readElement(this.nextElementPosition);
+                byte[] bArr = new byte[readElement.length];
+                long wrapPosition = QueueFile.this.wrapPosition(readElement.position + 4);
+                this.nextElementPosition = wrapPosition;
+                QueueFile.this.ringRead(wrapPosition, bArr, 0, readElement.length);
+                this.nextElementPosition = QueueFile.this.wrapPosition(readElement.position + 4 + readElement.length);
+                this.nextElementIndex++;
+                return bArr;
+            } catch (IOException e) {
+                throw new RuntimeException("todo: throw a proper error", e);
+            }
+        }
+
+        @Override // java.util.Iterator
+        public void remove() {
+            checkForComodification();
+            if (QueueFile.this.isEmpty()) {
+                throw new NoSuchElementException();
+            }
+            if (this.nextElementIndex != 1) {
+                throw new UnsupportedOperationException("Removal is only permitted from the head.");
+            }
+            try {
+                QueueFile.this.remove();
+                this.expectedModCount = QueueFile.this.modCount;
+                this.nextElementIndex--;
+            } catch (IOException e) {
+                throw new RuntimeException("todo: throw a proper error", e);
+            }
+        }
+    }
+
+    public void remove() {
+        remove(1);
+    }
+
+    public void remove(int i) {
+        if (i < 0) {
+            throw new IllegalArgumentException("Cannot remove negative (" + i + ") number of elements.");
+        }
+        if (i == 0) {
+            return;
+        }
+        if (i == this.elementCount) {
+            clear();
+            return;
+        }
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        if (i > this.elementCount) {
+            throw new IllegalArgumentException("Cannot remove more elements (" + i + ") than present in queue (" + this.elementCount + ").");
+        }
+        Element element = this.first;
+        long j = element.position;
+        int i2 = element.length;
+        long j2 = 0;
+        int i3 = 0;
+        long j3 = j;
+        while (i3 < i) {
+            j2 += i2 + 4;
+            long wrapPosition = wrapPosition(j3 + 4 + i2);
+            ringRead(wrapPosition, this.buffer, 0, 4);
+            i2 = readInt(this.buffer, 0);
+            i3++;
+            j3 = wrapPosition;
+        }
+        writeHeader(this.fileLength, this.elementCount - i, j3, this.last.position);
+        this.elementCount -= i;
+        this.modCount++;
+        this.first = new Element(j3, i2);
+        if (this.zero) {
+            ringErase(j, j2);
+        }
+    }
+
+    public void clear() {
+        if (this.closed) {
+            throw new IOException(Consts.PLACEMENT_STATUS_CLOSED);
+        }
+        writeHeader(PlaybackStateCompat.ACTION_SKIP_TO_QUEUE_ITEM, 0, 0L, 0L);
+        if (this.zero) {
+            this.raf.seek(this.headerLength);
+            this.raf.write(ZEROES, 0, 4096 - this.headerLength);
+        }
+        this.elementCount = 0;
+        Element element = Element.NULL;
+        this.first = element;
+        this.last = element;
+        if (this.fileLength > PlaybackStateCompat.ACTION_SKIP_TO_QUEUE_ITEM) {
+            setLength(PlaybackStateCompat.ACTION_SKIP_TO_QUEUE_ITEM);
+        }
+        this.fileLength = PlaybackStateCompat.ACTION_SKIP_TO_QUEUE_ITEM;
+        this.modCount++;
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public void close() {
+        this.closed = true;
+        this.raf.close();
+    }
+
+    public String toString() {
+        return QueueFile.class.getSimpleName() + "[length=" + this.fileLength + ", size=" + this.elementCount + ", first=" + this.first + ", last=" + this.last + v8.i.e;
+    }
+
+    public static class Element {
+        public static final Element NULL = new Element(0, 0);
+        public final int length;
+        public final long position;
+
+        public Element(long j, int i) {
+            this.position = j;
+            this.length = i;
+        }
+
+        public String toString() {
+            return getClass().getSimpleName() + "[position=" + this.position + ", length=" + this.length + v8.i.e;
+        }
+    }
+
+    public static final class Builder {
+        public final File file;
+        public boolean zero = true;
+        public boolean forceLegacy = false;
+
+        public Builder(File file) {
+            if (file == null) {
+                throw new NullPointerException("file == null");
+            }
+            this.file = file;
+        }
+
+        public QueueFile build() {
+            return new QueueFile(this.file, QueueFile.initializeFromFile(this.file, this.forceLegacy), this.zero, this.forceLegacy);
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/SQLitePersistentQueue.java

@@ -0,0 +1,278 @@
+package com.singular.sdk.internal;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.database.SQLException;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.provider.BaseColumns;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public class SQLitePersistentQueue implements Queue {
+    public static final SingularLog logger = SingularLog.getLogger(SQLitePersistentQueue.class.getSimpleName());
+    public SQLiteManager sqlite;
+
+    public SQLitePersistentQueue(Context context) {
+        this.sqlite = new SQLiteManager(new SQLiteHelper(context.getApplicationContext()));
+    }
+
+    @Override // com.singular.sdk.internal.Queue
+    public synchronized void add(String str) {
+        if (this.sqlite.insert(str) == -1) {
+            throw new IOException("Failed to add element = " + str);
+        }
+    }
+
+    @Override // com.singular.sdk.internal.Queue
+    public synchronized String peek() {
+        return this.sqlite.getHead();
+    }
+
+    @Override // com.singular.sdk.internal.Queue
+    public synchronized void remove() {
+        this.sqlite.removeHead();
+    }
+
+    public static class SQLiteManager {
+        public final SQLiteHelper helper;
+
+        public SQLiteManager(SQLiteHelper sQLiteHelper) {
+            this.helper = sQLiteHelper;
+        }
+
+        /* JADX WARN: Removed duplicated region for block: B:18:0x0070  */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public long insert(java.lang.String r9) {
+            /*
+                r8 = this;
+                android.content.ContentValues r0 = new android.content.ContentValues
+                r0.<init>()
+                java.lang.String r1 = "value"
+                r0.put(r1, r9)
+                r9 = 0
+                com.singular.sdk.internal.SQLitePersistentQueue$SQLiteHelper r1 = r8.helper     // Catch: java.lang.Throwable -> L61 android.database.SQLException -> L65
+                android.database.sqlite.SQLiteDatabase r1 = r1.getWritableDatabase()     // Catch: java.lang.Throwable -> L61 android.database.SQLException -> L65
+                java.lang.String r2 = "events"
+                long r2 = r1.insert(r2, r9, r0)     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                com.singular.sdk.internal.SingularLog r9 = com.singular.sdk.internal.SQLitePersistentQueue.access$000()     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                java.lang.StringBuilder r0 = new java.lang.StringBuilder     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                r0.<init>()     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                java.lang.String r4 = "insert() row = "
+                r0.append(r4)     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                r0.append(r2)     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                java.lang.String r0 = r0.toString()     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                r9.debug(r0)     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                long r4 = r8.getCount(r1)     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                r6 = 10000(0x2710, double:4.9407E-320)
+                int r9 = (r4 > r6 ? 1 : (r4 == r6 ? 0 : -1))
+                if (r9 <= 0) goto L5d
+                com.singular.sdk.internal.SingularLog r9 = com.singular.sdk.internal.SQLitePersistentQueue.access$000()     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                java.lang.String r0 = "Pruning Queue; current size = %d; max size = %d"
+                r6 = 2
+                java.lang.Object[] r6 = new java.lang.Object[r6]     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                java.lang.Long r4 = java.lang.Long.valueOf(r4)     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                r5 = 0
+                r6[r5] = r4     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                r4 = 10000(0x2710, float:1.4013E-41)
+                java.lang.Integer r4 = java.lang.Integer.valueOf(r4)     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                r5 = 1
+                r6[r5] = r4     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                r9.debug(r0, r6)     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                r8.removeHead(r1)     // Catch: java.lang.Throwable -> L59 android.database.SQLException -> L5b
+                goto L5d
+            L59:
+                r9 = move-exception
+                goto L6e
+            L5b:
+                r9 = move-exception
+                goto L68
+            L5d:
+                r1.close()
+                return r2
+            L61:
+                r0 = move-exception
+                r1 = r9
+                r9 = r0
+                goto L6e
+            L65:
+                r0 = move-exception
+                r1 = r9
+                r9 = r0
+            L68:
+                java.io.IOException r0 = new java.io.IOException     // Catch: java.lang.Throwable -> L59
+                r0.<init>(r9)     // Catch: java.lang.Throwable -> L59
+                throw r0     // Catch: java.lang.Throwable -> L59
+            L6e:
+                if (r1 == 0) goto L73
+                r1.close()
+            L73:
+                throw r9
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.singular.sdk.internal.SQLitePersistentQueue.SQLiteManager.insert(java.lang.String):long");
+        }
+
+        public String getHead() {
+            Cursor cursor;
+            Throwable th;
+            SQLiteDatabase sQLiteDatabase;
+            SQLException e;
+            String str = null;
+            try {
+                try {
+                    sQLiteDatabase = this.helper.getReadableDatabase();
+                } catch (Throwable th2) {
+                    th = th2;
+                }
+            } catch (SQLException e2) {
+                e = e2;
+            } catch (Throwable th3) {
+                cursor = null;
+                th = th3;
+                sQLiteDatabase = null;
+            }
+            try {
+                long minId = getMinId(sQLiteDatabase);
+                Cursor query = sQLiteDatabase.query("events", new String[]{"value"}, "_id = ?", new String[]{String.valueOf(minId)}, null, null, null);
+                try {
+                    query.moveToFirst();
+                    if (query.getCount() != 0) {
+                        str = query.getString(0);
+                    }
+                    SQLitePersistentQueue.logger.debug("getHead() _id = %d, value = %s", Long.valueOf(minId), str);
+                    query.close();
+                    sQLiteDatabase.close();
+                    return str;
+                } catch (SQLException e3) {
+                    e = e3;
+                    throw new IOException(e);
+                }
+            } catch (SQLException e4) {
+                e = e4;
+            } catch (Throwable th4) {
+                cursor = null;
+                th = th4;
+                if (cursor != null) {
+                    cursor.close();
+                }
+                if (sQLiteDatabase != null) {
+                    sQLiteDatabase.close();
+                }
+                throw th;
+            }
+        }
+
+        public String removeHead() {
+            SQLiteDatabase sQLiteDatabase = null;
+            try {
+                sQLiteDatabase = this.helper.getWritableDatabase();
+                return removeHead(sQLiteDatabase);
+            } finally {
+                if (sQLiteDatabase != null) {
+                    sQLiteDatabase.close();
+                }
+            }
+        }
+
+        public final String removeHead(SQLiteDatabase sQLiteDatabase) {
+            long minId;
+            String[] strArr;
+            Cursor query;
+            Cursor cursor = null;
+            try {
+                try {
+                    minId = getMinId(sQLiteDatabase);
+                    strArr = new String[]{String.valueOf(minId)};
+                    query = sQLiteDatabase.query("events", new String[]{"value"}, "_id = ?", strArr, null, null, null);
+                } catch (SQLException e) {
+                    e = e;
+                }
+            } catch (Throwable th) {
+                th = th;
+            }
+            try {
+                query.moveToFirst();
+                if (query.getCount() != 0) {
+                    String string = query.getString(query.getColumnIndex("value"));
+                    sQLiteDatabase.delete("events", "_id = ?", strArr);
+                    SQLitePersistentQueue.logger.debug("removeHead() _id = %d", Long.valueOf(minId));
+                    query.close();
+                    return string;
+                }
+                query.close();
+                return null;
+            } catch (SQLException e2) {
+                e = e2;
+                cursor = query;
+                throw new IOException(e);
+            } catch (Throwable th2) {
+                th = th2;
+                cursor = query;
+                if (cursor != null) {
+                    cursor.close();
+                }
+                throw th;
+            }
+        }
+
+        public final long getMinId(SQLiteDatabase sQLiteDatabase) {
+            Cursor cursor = null;
+            try {
+                try {
+                    cursor = sQLiteDatabase.rawQuery("SELECT MIN(_id) FROM events", null);
+                    cursor.moveToFirst();
+                    long j = cursor.getLong(0);
+                    SQLitePersistentQueue.logger.debug("getMinId() id = %d", Long.valueOf(j));
+                    cursor.close();
+                    return j;
+                } catch (SQLException e) {
+                    throw new IOException(e);
+                }
+            } catch (Throwable th) {
+                if (cursor != null) {
+                    cursor.close();
+                }
+                throw th;
+            }
+        }
+
+        public final long getCount(SQLiteDatabase sQLiteDatabase) {
+            Cursor cursor = null;
+            try {
+                try {
+                    cursor = sQLiteDatabase.rawQuery("SELECT COUNT(_id) FROM events", null);
+                    cursor.moveToFirst();
+                    long j = cursor.getLong(0);
+                    SQLitePersistentQueue.logger.debug("getCount() = %d", Long.valueOf(j));
+                    cursor.close();
+                    return j;
+                } catch (SQLException e) {
+                    throw new IOException(e);
+                }
+            } catch (Throwable th) {
+                if (cursor != null) {
+                    cursor.close();
+                }
+                throw th;
+            }
+        }
+    }
+
+    public static class SQLiteHelper extends SQLiteOpenHelper implements BaseColumns {
+        @Override // android.database.sqlite.SQLiteOpenHelper
+        public void onUpgrade(SQLiteDatabase sQLiteDatabase, int i, int i2) {
+        }
+
+        public SQLiteHelper(Context context) {
+            super(context, "singular-1.db", (SQLiteDatabase.CursorFactory) null, 1);
+        }
+
+        @Override // android.database.sqlite.SQLiteOpenHelper
+        public void onCreate(SQLiteDatabase sQLiteDatabase) {
+            sQLiteDatabase.execSQL("CREATE TABLE events (_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,value TEXT )");
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/SessionManager.java

@@ -0,0 +1,165 @@
+package com.singular.sdk.internal;
+
+import android.app.Application;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import com.singular.sdk.internal.BroadcastReceivers;
+
+/* loaded from: classes4.dex */
+public class SessionManager {
+    public static final SingularLog logger = SingularLog.getLogger("Session");
+    public final BroadcastReceivers.NetworkChange networkChangeReceiver;
+    public final SingularInstance singular;
+    public boolean usingForegroundTracking = false;
+    public long sessionId = -1;
+    public long lastSessionPauseTime = -1;
+    public long sequence = 0;
+    public boolean inForeground = true;
+
+    public long getNextSequenceNumber() {
+        long j = this.sequence + 1;
+        this.sequence = j;
+        return j;
+    }
+
+    public long getSessionId() {
+        return this.sessionId;
+    }
+
+    public final boolean inSession() {
+        return this.sessionId > 0;
+    }
+
+    public final void resetSequence() {
+        this.sequence = 0L;
+    }
+
+    public final void setSessionId(long j) {
+        this.sessionId = j;
+    }
+
+    public void useForegroundTracking() {
+        this.usingForegroundTracking = true;
+    }
+
+    public SessionManager(SingularInstance singularInstance) {
+        this.singular = singularInstance;
+        this.networkChangeReceiver = new BroadcastReceivers.NetworkChange(singularInstance);
+        load();
+        startNewSessionIfNeeded(Utils.getCurrentTimeMillis());
+        enableForegroundTracking((Application) singularInstance.getContext());
+        registerNetworkChangeReceiver();
+    }
+
+    public final void enableForegroundTracking(Application application) {
+        if (this.usingForegroundTracking) {
+            return;
+        }
+        new SingularLifecycleCallbacks(this).registerSelf(application);
+    }
+
+    public final void load() {
+        SharedPreferences sharedPreferences = this.singular.getContext().getSharedPreferences("singular-pref-session", 0);
+        this.sessionId = sharedPreferences.getLong("id", -1L);
+        long j = sharedPreferences.getLong("lastSessionPauseTime", -1L);
+        this.lastSessionPauseTime = j;
+        if (j < 0) {
+            this.lastSessionPauseTime = sharedPreferences.getLong("lastEvent", -1L);
+        }
+        this.sequence = sharedPreferences.getLong("seq", 0L);
+        logger.debug("load() <= %s", toString());
+    }
+
+    public final void persist() {
+        SharedPreferences.Editor edit = this.singular.getContext().getSharedPreferences("singular-pref-session", 0).edit();
+        edit.putLong("id", this.sessionId);
+        edit.putLong("lastSessionPauseTime", this.lastSessionPauseTime);
+        edit.putLong("seq", this.sequence);
+        edit.commit();
+    }
+
+    public final void setLastSessionPauseTime(long j) {
+        this.lastSessionPauseTime = j;
+        persist();
+    }
+
+    public final boolean startNewSessionIfNeeded(long j) {
+        if (SingularInstance.getInstance().getSingularConfig().singularLink != null) {
+            startNewSession(j);
+            return true;
+        }
+        if (inSession() && isWithinMinTimeBetweenSessions(j)) {
+            return false;
+        }
+        startNewSession(j);
+        return true;
+    }
+
+    public void startNewSession(long j) {
+        logger.debug("startNewSession() At %d", Long.valueOf(j));
+        setSessionId(j);
+        resetSequence();
+        sendSessionStartEvent();
+    }
+
+    public final boolean isWithinMinTimeBetweenSessions(long j) {
+        return j - this.lastSessionPauseTime < this.singular.getSingularConfig().sessionTimeoutSec * 1000;
+    }
+
+    public final void sendSessionStartEvent() {
+        if (inSession()) {
+            this.singular.logSessionStart(this.sessionId);
+        }
+    }
+
+    public void onExitForeground(final long j) {
+        logger.debug("onExitForeground() At %d", Long.valueOf(j));
+        this.singular.runOnWorker(new Runnable() { // from class: com.singular.sdk.internal.SessionManager.1
+            @Override // java.lang.Runnable
+            public void run() {
+                SessionManager.this.setLastSessionPauseTime(j);
+                SessionManager.this.inForeground = false;
+                SessionManager.this.unregisterNetworkChangeReceiver();
+                Utils.appMovedToBackground();
+            }
+        });
+    }
+
+    public void onEnterForeground(final long j) {
+        if (Utils.isOpenedWithDeeplink()) {
+            return;
+        }
+        logger.debug("onEnterForeground() At %d", Long.valueOf(j));
+        this.singular.runOnWorker(new Runnable() { // from class: com.singular.sdk.internal.SessionManager.2
+            @Override // java.lang.Runnable
+            public void run() {
+                SessionManager.this.inForeground = true;
+                SessionManager.this.startNewSessionIfNeeded(j);
+                SessionManager.this.registerNetworkChangeReceiver();
+            }
+        });
+    }
+
+    public void registerNetworkChangeReceiver() {
+        if (this.inForeground || !this.usingForegroundTracking) {
+            IntentFilter intentFilter = new IntentFilter();
+            intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
+            this.singular.getContext().registerReceiver(this.networkChangeReceiver, intentFilter);
+            logger.debug("registerNetworkChangeReceiver()");
+        }
+    }
+
+    public void unregisterNetworkChangeReceiver() {
+        if (this.networkChangeReceiver != null) {
+            try {
+                this.singular.getContext().unregisterReceiver(this.networkChangeReceiver);
+                logger.debug("unregisterNetworkChangeReceiver()");
+            } catch (Exception unused) {
+            }
+        }
+    }
+
+    public String toString() {
+        return "{id=" + this.sessionId + ", lastSessionPauseTime=" + this.lastSessionPauseTime + ", seq=" + this.sequence + '}';
+    }
+}

decompiled/sources/com/singular/sdk/internal/SingularExceptionReporter.java

@@ -0,0 +1,117 @@
+package com.singular.sdk.internal;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Log;
+import com.ea.nimble.ApplicationEnvironment;
+import com.facebook.devicerequests.internal.DeviceRequestsHelper;
+import com.glu.plugins.gluanalytics.AnalyticsData;
+import com.google.firebase.perf.network.FirebasePerfUrlConnection;
+import com.ironsource.nb;
+import com.ironsource.v8;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
+import org.apache.http.protocol.HTTP;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class SingularExceptionReporter extends HandlerThread {
+    public static SingularExceptionReporter instance;
+    public Context context;
+    public DeviceInfo device_info;
+    public Handler handler;
+
+    public static SingularExceptionReporter getReporter(Context context) {
+        if (instance == null) {
+            synchronized (SingularExceptionReporter.class) {
+                SingularExceptionReporter singularExceptionReporter = new SingularExceptionReporter("singular_exception_reporter", context);
+                instance = singularExceptionReporter;
+                singularExceptionReporter.initDeviceInfo();
+            }
+        }
+        return instance;
+    }
+
+    public SingularExceptionReporter(String str, Context context) {
+        super(str);
+        this.handler = null;
+        this.context = null;
+        this.device_info = null;
+        start();
+        this.handler = new Handler(getLooper());
+        this.context = context;
+    }
+
+    public final void initDeviceInfo() {
+        if (this.device_info != null || this.handler == null || this.context == null) {
+            return;
+        }
+        this.handler.post(new Runnable() { // from class: com.singular.sdk.internal.SingularExceptionReporter.1
+            @Override // java.lang.Runnable
+            public void run() {
+                try {
+                    SingularExceptionReporter.this.device_info = new DeviceInfo(SingularExceptionReporter.this.context);
+                } catch (Exception unused) {
+                }
+            }
+        });
+    }
+
+    public void reportException(final Throwable th) {
+        if (this.handler != null) {
+            Runnable runnable = new Runnable() { // from class: com.singular.sdk.internal.SingularExceptionReporter.2
+                @Override // java.lang.Runnable
+                public void run() {
+                    try {
+                        JSONObject jSONObject = new JSONObject();
+                        Throwable th2 = th;
+                        if (th2 != null) {
+                            jSONObject.put("name", th2.getClass().getSimpleName());
+                            jSONObject.put("message", th.getMessage());
+                            jSONObject.put("stack_trace", Log.getStackTraceString(th));
+                            if (SingularExceptionReporter.this.device_info != null) {
+                                JSONObject jSONObject2 = new JSONObject();
+                                jSONObject2.put("aifa", SingularExceptionReporter.this.device_info.aifa);
+                                jSONObject2.put("appName", SingularExceptionReporter.this.device_info.appName);
+                                jSONObject2.put(v8.i.W, SingularExceptionReporter.this.device_info.appVersion);
+                                jSONObject2.put("deviceModel", SingularExceptionReporter.this.device_info.deviceModel);
+                                jSONObject2.put(ApplicationEnvironment.NIMBLE_PARAMETER_DEVICE_BRAND, SingularExceptionReporter.this.device_info.deviceBrand);
+                                jSONObject2.put("deviceManufacturer", SingularExceptionReporter.this.device_info.deviceManufacturer);
+                                jSONObject2.put(AnalyticsData.S_OS_VERSION, SingularExceptionReporter.this.device_info.osVersion);
+                                jSONObject2.put("sdkVersion", SingularExceptionReporter.this.device_info.sdkVersion);
+                                jSONObject2.put("isGooglePlayServicesAvailable", SingularExceptionReporter.this.device_info.isGooglePlayServicesAvailable);
+                                jSONObject.put(DeviceRequestsHelper.DEVICE_INFO_PARAM, jSONObject2);
+                            }
+                        } else {
+                            jSONObject.put("error", "Throwable is null!");
+                        }
+                        SingularExceptionReporter.this.postExceptionDataToServer(jSONObject);
+                    } catch (Exception unused) {
+                    }
+                }
+            };
+            this.handler.removeCallbacksAndMessages(null);
+            this.handler.post(runnable);
+        }
+    }
+
+    public final int postExceptionDataToServer(JSONObject jSONObject) {
+        try {
+            HttpURLConnection httpURLConnection = (HttpURLConnection) ((URLConnection) FirebasePerfUrlConnection.instrument(new URL("https://exceptions.singular.net/v2/exceptions/android").openConnection()));
+            httpURLConnection.setRequestMethod("POST");
+            httpURLConnection.setRequestProperty("Content-Type", nb.L);
+            httpURLConnection.setConnectTimeout(10000);
+            httpURLConnection.setReadTimeout(10000);
+            httpURLConnection.setDoOutput(true);
+            byte[] bytes = jSONObject.toString().getBytes();
+            httpURLConnection.setRequestProperty(HTTP.CONTENT_LEN, Integer.toString(bytes.length));
+            httpURLConnection.getOutputStream().write(bytes);
+            httpURLConnection.connect();
+            return httpURLConnection.getResponseCode();
+        } catch (Exception unused) {
+            return -1;
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/SingularInstance.java

@@ -0,0 +1,295 @@
+package com.singular.sdk.internal;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.SharedPreferences;
+import com.amazonaws.handlers.HandlerChainFactory$$ExternalSyntheticThrowCCEIfNotNull0;
+import com.applovin.impl.sdk.utils.JsonUtils;
+import com.singular.sdk.SingularConfig;
+import com.singular.sdk.internal.ApiStartSession;
+import com.singular.sdk.internal.ApiSubmitEvent;
+import java.util.HashMap;
+import java.util.Iterator;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class SingularInstance {
+    public static SingularInstance instance;
+    public static final SingularLog logger = SingularLog.getLogger("Instance");
+    public static int retryCounter = 0;
+    public final ApiManager apiManager;
+    public SingularConfig config;
+    public final Context context;
+    public DeviceInfo deviceInfo;
+    public HashMap globalProperties;
+    public boolean initialized = false;
+    public SessionManager sessionManager;
+    public final SingularWorkerThread worker;
+
+    public static SingularInstance getInstance() {
+        return instance;
+    }
+
+    public ApiManager getApiManager() {
+        return this.apiManager;
+    }
+
+    public Context getContext() {
+        return this.context;
+    }
+
+    public DeviceInfo getDeviceInfo() {
+        return this.deviceInfo;
+    }
+
+    public SessionManager getSessionManager() {
+        return this.sessionManager;
+    }
+
+    public SingularConfig getSingularConfig() {
+        return this.config;
+    }
+
+    public boolean isInitialized() {
+        return this.initialized;
+    }
+
+    public static SingularInstance getInstance(Context context, SingularConfig singularConfig) {
+        if (instance == null) {
+            synchronized (SingularInstance.class) {
+                try {
+                    if (instance == null) {
+                        SingularLog.ENABLE_LOGGING = singularConfig.enableLogging;
+                        SingularLog.LOG_LEVEL = singularConfig.logLevel;
+                        instance = new SingularInstance(context, singularConfig);
+                    }
+                } finally {
+                }
+            }
+        }
+        SingularInstance singularInstance = instance;
+        singularInstance.config = singularConfig;
+        return singularInstance;
+    }
+
+    public SingularInstance(Context context, SingularConfig singularConfig) {
+        SingularLog singularLog = logger;
+        singularLog.debug("SDK version: %s", Constants.SDK_VERSION);
+        singularLog.debug("SDK build info: %s", Constants.SDK_BUILD_INFO);
+        singularLog.debug("new SingularInstance() with config: %s", singularConfig);
+        Context applicationContext = context.getApplicationContext();
+        if (!(applicationContext instanceof Application)) {
+            throw new IllegalStateException("Context failed to cast to ApplicationContext");
+        }
+        this.context = applicationContext;
+        this.config = singularConfig;
+        SingularWorkerThread singularWorkerThread = new SingularWorkerThread("worker");
+        this.worker = singularWorkerThread;
+        ApiManager apiManager = new ApiManager(new SingularWorkerThread("api"), context, new SQLitePersistentQueue(context));
+        this.apiManager = apiManager;
+        singularWorkerThread.start();
+        initGlobalProperties();
+        apiManager.tryMigrateEventsFromFileQueue();
+        apiManager.tryMigrateEventsFromOldSQLiteQueue();
+        runOnWorker(new Runnable() { // from class: com.singular.sdk.internal.SingularInstance.1
+            @Override // java.lang.Runnable
+            public void run() {
+                SingularInstance.this.init(this);
+            }
+        });
+    }
+
+    public final void init(SingularInstance singularInstance) {
+        if (isInitialized()) {
+            logger.error("Singular is already initialized, please don't call init() again.");
+            return;
+        }
+        try {
+            singularInstance.deviceInfo = new DeviceInfo(singularInstance.context);
+            DeviceInfo deviceInfo = this.deviceInfo;
+            SingularConfig singularConfig = this.config;
+            deviceInfo.imei = singularConfig.imei;
+            if (singularConfig.wasCustomUserIdSetBeforeInit) {
+                saveCustomUserId(singularConfig.customUserId);
+            }
+            singularInstance.sessionManager = new SessionManager(singularInstance);
+            this.initialized = true;
+            logger.info("Singular is initialized now.");
+        } catch (Exception e) {
+            logger.error("error in init()", e);
+        }
+    }
+
+    public final void initGlobalProperties() {
+        this.globalProperties = loadGlobalProperties();
+        if (this.config.globalProperties.size() == 0) {
+            return;
+        }
+        HashMap hashMap = (HashMap) this.globalProperties.clone();
+        Iterator it = this.config.globalProperties.values().iterator();
+        if (it.hasNext()) {
+            HandlerChainFactory$$ExternalSyntheticThrowCCEIfNotNull0.m(it.next());
+            throw null;
+        }
+        if (hashMap.size() > 5) {
+            return;
+        }
+        this.globalProperties = hashMap;
+        saveGlobalProperties();
+        if (this.globalProperties == null) {
+            clearGlobalProperties();
+        }
+    }
+
+    public final boolean isSessionManagerInitialized() {
+        return (!isInitialized() || getInstance() == null || getSessionManager() == null) ? false : true;
+    }
+
+    public boolean logEvent(String str) {
+        return logEvent(str, null);
+    }
+
+    public boolean logEvent(String str, String str2) {
+        int length = (str != null ? str.length() : 0) + (str2 != null ? str2.length() : 0);
+        if (length > 3746) {
+            logger.debug("Event discarded! payload length = %d", Integer.valueOf(length));
+            return false;
+        }
+        logEvent(new ApiSubmitEvent.RawEvent(str, str2));
+        return true;
+    }
+
+    public void logEvent(final ApiSubmitEvent.RawEvent rawEvent) {
+        if (isAllTrackingStopped()) {
+            logger.debug("Tracking was stopped! not logging event!");
+        } else if (!isSessionManagerInitialized()) {
+            retryTask(new Runnable() { // from class: com.singular.sdk.internal.SingularInstance.2
+                @Override // java.lang.Runnable
+                public void run() {
+                    SingularInstance.this.logEvent(rawEvent);
+                }
+            });
+        } else {
+            runOnWorker(new Runnable() { // from class: com.singular.sdk.internal.SingularInstance.3
+                @Override // java.lang.Runnable
+                public void run() {
+                    ApiSubmitEvent apiSubmitEvent = new ApiSubmitEvent(rawEvent.timestamp);
+                    apiSubmitEvent.addParams(ApiSubmitEvent.Params.build(rawEvent, SingularInstance.instance));
+                    SingularInstance.instance.apiManager.enqueue(apiSubmitEvent);
+                }
+            });
+        }
+    }
+
+    public void logSessionStart(final long j) {
+        if (isAllTrackingStopped()) {
+            logger.debug("Tracking was stopped! not logging event!");
+        } else {
+            runOnWorkerAtFront(new Runnable() { // from class: com.singular.sdk.internal.SingularInstance.6
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (SingularInstance.instance != null) {
+                        ApiStartSession apiStartSession = new ApiStartSession(j);
+                        apiStartSession.addParams(ApiStartSession.Params.build(j, SingularInstance.instance));
+                        SingularInstance.instance.apiManager.enqueue(apiStartSession);
+                        SingularInstance.instance.config.openUri = null;
+                    }
+                }
+            });
+        }
+    }
+
+    public void retryTask(Runnable runnable) {
+        if (retryCounter < 10) {
+            runOnWorkerDelayed(runnable, 200);
+            retryCounter++;
+        }
+    }
+
+    public void runOnWorker(Runnable runnable) {
+        this.worker.post(runnable);
+    }
+
+    public void runOnWorkerAtFront(Runnable runnable) {
+        this.worker.postAtFront(runnable);
+    }
+
+    public void runOnWorkerDelayed(Runnable runnable, int i) {
+        this.worker.postDelayed(runnable, i);
+    }
+
+    public void startSessionIfOpenedWithDeeplink() {
+        if (this.config.singularLink == null) {
+            return;
+        }
+        runOnWorker(new Runnable() { // from class: com.singular.sdk.internal.SingularInstance.8
+            @Override // java.lang.Runnable
+            public void run() {
+                SingularInstance.this.sessionManager.startNewSession(Utils.getCurrentTimeMillis());
+            }
+        });
+    }
+
+    public void saveCustomUserId(String str) {
+        SharedPreferences.Editor edit = getContext().getSharedPreferences("singular-pref-session", 0).edit();
+        edit.putString("custom_user_id", str);
+        edit.commit();
+        this.deviceInfo.setCustomUserId(str);
+    }
+
+    public void sendInstallReferrerEvent(String str, String str2, long j, long j2) {
+        try {
+            JSONObject jSONObject = new JSONObject();
+            jSONObject.put("referrer", str);
+            jSONObject.put("referrer_source", str2);
+            jSONObject.put("clickTimestampSeconds", j);
+            jSONObject.put("installBeginTimestampSeconds", j2);
+            jSONObject.put("current_device_time", Utils.getCurrentTimeMillis());
+            logEvent(new ApiSubmitEvent.RawEvent("__InstallReferrer", jSONObject.toString()));
+        } catch (JSONException e) {
+            logger.error("error in sendInstallReferrerEvent()", e);
+        }
+    }
+
+    public boolean isAllTrackingStopped() {
+        return this.context.getSharedPreferences("singular-pref-session", 0).getBoolean("stop_all_tracking", false);
+    }
+
+    public JSONObject getGlobalPropertiesJSON() {
+        return new JSONObject(this.globalProperties);
+    }
+
+    public void clearGlobalProperties() {
+        this.globalProperties = null;
+        saveGlobalProperties();
+    }
+
+    public final void saveGlobalProperties() {
+        if (this.globalProperties == null) {
+            this.globalProperties = new HashMap();
+        }
+        SharedPreferences.Editor edit = this.context.getSharedPreferences("singular-pref-session", 0).edit();
+        edit.putString("global_properties", getGlobalPropertiesJSON().toString());
+        edit.commit();
+    }
+
+    public HashMap loadGlobalProperties() {
+        JSONObject jSONObject;
+        try {
+            jSONObject = new JSONObject(this.context.getSharedPreferences("singular-pref-session", 0).getString("global_properties", JsonUtils.EMPTY_JSON));
+        } catch (Exception unused) {
+            jSONObject = new JSONObject();
+        }
+        HashMap hashMap = new HashMap();
+        Iterator<String> keys = jSONObject.keys();
+        while (keys.hasNext()) {
+            try {
+                String next = keys.next();
+                hashMap.put(next, jSONObject.getString(next));
+            } catch (Exception unused2) {
+            }
+        }
+        return hashMap;
+    }
+}

decompiled/sources/com/singular/sdk/internal/SingularLifecycleCallbacks.java

@@ -0,0 +1,60 @@
+package com.singular.sdk.internal;
+
+import android.app.Application;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+/* loaded from: classes4.dex */
+public class SingularLifecycleCallbacks implements InvocationHandler {
+    public static final SingularLog logger = SingularLog.getLogger(SingularLifecycleCallbacks.class.getSimpleName());
+    public final SessionManager sessionManager;
+
+    public SingularLifecycleCallbacks(SessionManager sessionManager) {
+        this.sessionManager = sessionManager;
+        sessionManager.useForegroundTracking();
+    }
+
+    public void registerSelf(Application application) {
+        Method method;
+        try {
+            int i = 0;
+            Object newProxyInstance = Proxy.newProxyInstance(Application.class.getClassLoader(), new Class[]{Application.ActivityLifecycleCallbacks.class}, this);
+            Method[] methods = Application.class.getMethods();
+            int length = methods.length;
+            while (true) {
+                if (i >= length) {
+                    method = null;
+                    break;
+                }
+                method = methods[i];
+                if (method.getName().equals("registerActivityLifecycleCallbacks")) {
+                    break;
+                } else {
+                    i++;
+                }
+            }
+            if (method != null) {
+                method.invoke(application, newProxyInstance);
+                logger.debug("ActivityLifecycleCallbacks registration successful, Automatic session management will work.");
+            } else {
+                logger.error("ActivityLifecycleCallbacks registration not available, Automatic session management will not work");
+            }
+        } catch (Throwable th) {
+            logger.error("ActivityLifecycleCallbacks registration failed, Automatic session management will not work", th);
+        }
+    }
+
+    @Override // java.lang.reflect.InvocationHandler
+    public Object invoke(Object obj, Method method, Object[] objArr) {
+        if ("onActivityResumed".equals(method.getName())) {
+            this.sessionManager.onEnterForeground(Utils.getCurrentTimeMillis());
+            return null;
+        }
+        if (!"onActivityPaused".equals(method.getName())) {
+            return null;
+        }
+        this.sessionManager.onExitForeground(Utils.getCurrentTimeMillis());
+        return null;
+    }
+}

decompiled/sources/com/singular/sdk/internal/SingularLog.java

@@ -0,0 +1,78 @@
+package com.singular.sdk.internal;
+
+import android.util.Log;
+import com.mbridge.msdk.out.reveue.MBridgeRevenueParamsEntity;
+
+/* loaded from: classes4.dex */
+public class SingularLog {
+    public static boolean ENABLE_LOGGING = false;
+    public static int LOG_LEVEL = 6;
+    public final String TAG = MBridgeRevenueParamsEntity.ATTRIBUTION_PLATFORM_SINGULAR;
+    public final String tag;
+
+    public boolean shouldLog(int i) {
+        return ENABLE_LOGGING && LOG_LEVEL <= i;
+    }
+
+    public SingularLog(String str) {
+        this.tag = str;
+    }
+
+    public static SingularLog getLogger(String str) {
+        return new SingularLog(str);
+    }
+
+    public String text(String str) {
+        return String.format("%s [%s] - %s", this.tag, getThreadInfo(), str);
+    }
+
+    public boolean isDebugEnabled() {
+        return shouldLog(3);
+    }
+
+    public int debug(String str) {
+        if (shouldLog(3)) {
+            return Log.d(MBridgeRevenueParamsEntity.ATTRIBUTION_PLATFORM_SINGULAR, text(str));
+        }
+        return 0;
+    }
+
+    public int debug(String str, Object... objArr) {
+        if (shouldLog(3)) {
+            return Log.d(MBridgeRevenueParamsEntity.ATTRIBUTION_PLATFORM_SINGULAR, text(String.format(str, objArr)));
+        }
+        return 0;
+    }
+
+    public int info(String str) {
+        if (shouldLog(4)) {
+            return Log.i(MBridgeRevenueParamsEntity.ATTRIBUTION_PLATFORM_SINGULAR, text(str));
+        }
+        return 0;
+    }
+
+    public int error(String str) {
+        if (shouldLog(6)) {
+            return Log.e(MBridgeRevenueParamsEntity.ATTRIBUTION_PLATFORM_SINGULAR, text(str));
+        }
+        return 0;
+    }
+
+    public int error(String str, Throwable th) {
+        if (shouldLog(6)) {
+            return Log.e(MBridgeRevenueParamsEntity.ATTRIBUTION_PLATFORM_SINGULAR, text(str), th);
+        }
+        return 0;
+    }
+
+    public int error(String str, Object... objArr) {
+        if (shouldLog(6)) {
+            return Log.e(MBridgeRevenueParamsEntity.ATTRIBUTION_PLATFORM_SINGULAR, text(String.format(str, objArr)));
+        }
+        return 0;
+    }
+
+    public static String getThreadInfo() {
+        return String.format("%s", Thread.currentThread().getName());
+    }
+}

decompiled/sources/com/singular/sdk/internal/SingularMap.java

@@ -0,0 +1,14 @@
+package com.singular.sdk.internal;
+
+import java.util.HashMap;
+
+/* loaded from: classes4.dex */
+public abstract class SingularMap extends HashMap {
+    @Override // java.util.HashMap, java.util.AbstractMap, java.util.Map
+    public String put(String str, String str2) {
+        if (Utils.isEmptyOrNull(str2)) {
+            return null;
+        }
+        return (String) super.put((SingularMap) str, str2);
+    }
+}

decompiled/sources/com/singular/sdk/internal/SingularRequestHandler.java

@@ -0,0 +1,194 @@
+package com.singular.sdk.internal;
+
+import com.google.firebase.perf.network.FirebasePerfUrlConnection;
+import com.ironsource.nb;
+import com.ironsource.v8;
+import com.singular.sdk.internal.Api;
+import com.unity3d.ads.metadata.InAppPurchaseMetaData;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLEncoder;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.zip.GZIPInputStream;
+import javax.net.ssl.HttpsURLConnection;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public abstract class SingularRequestHandler {
+    public static final SingularLog logger = SingularLog.getLogger(SingularRequestHandler.class.getSimpleName());
+    public static int counter = 0;
+    public static final String[] POST_PAYLOAD_PARAMS_KEYS = {"e", "global_properties"};
+
+    public static boolean makeRequest(SingularInstance singularInstance, String str, Map map, long j, Api.OnApiCallback onApiCallback) {
+        long currentTimeMillis = Utils.getCurrentTimeMillis();
+        int i = counter + 1;
+        counter = i;
+        SingularLog singularLog = logger;
+        singularLog.debug("---------------------------> /%d", Integer.valueOf(i));
+        singularLog.debug("url = %s", str);
+        singularLog.debug("params = %s", map);
+        HttpURLConnection buildRequest = buildRequest(singularInstance, str, map, j);
+        try {
+            try {
+                return sendRequest(singularInstance, onApiCallback, currentTimeMillis, i, buildRequest);
+            } catch (IOException e) {
+                throw e;
+            }
+        } finally {
+            if (buildRequest != null) {
+                buildRequest.disconnect();
+            }
+        }
+    }
+
+    public static HttpURLConnection buildRequest(SingularInstance singularInstance, String str, Map map, long j) {
+        HttpURLConnection httpConnection;
+        Map postPayloadParams = getPostPayloadParams(map);
+        String str2 = str + "?" + appendHash(getQueryString(singularInstance, map, j), singularInstance.getSingularConfig().secret);
+        URL url = new URL(str2);
+        if (url.getProtocol().equalsIgnoreCase("https")) {
+            httpConnection = getHttpsConnection(url);
+        } else {
+            httpConnection = getHttpConnection(url);
+        }
+        setDefaultConnectionProperties(httpConnection);
+        setPayloadForRequest(httpConnection, postPayloadParams, singularInstance.getSingularConfig().secret);
+        logger.debug("__API__ %s %s", httpConnection.getRequestMethod(), str2);
+        return httpConnection;
+    }
+
+    public static boolean sendRequest(SingularInstance singularInstance, Api.OnApiCallback onApiCallback, long j, int i, HttpURLConnection httpURLConnection) {
+        httpURLConnection.connect();
+        int responseCode = httpURLConnection.getResponseCode();
+        String readResponse = readResponse(httpURLConnection);
+        httpURLConnection.disconnect();
+        long currentTimeMillis = Utils.getCurrentTimeMillis() - j;
+        SingularLog singularLog = logger;
+        singularLog.debug("%d %s", Integer.valueOf(responseCode), readResponse);
+        singularLog.debug("<--------------------------- /%d - took %dms", Integer.valueOf(i), Long.valueOf(currentTimeMillis));
+        return onApiCallback.handle(singularInstance, responseCode, readResponse);
+    }
+
+    public static String readResponse(HttpURLConnection httpURLConnection) {
+        InputStreamReader inputStreamReader;
+        StringBuffer stringBuffer = new StringBuffer();
+        InputStream inputStream = httpURLConnection.getInputStream();
+        if (httpURLConnection.getContentEncoding() != null && httpURLConnection.getContentEncoding().equals("gzip")) {
+            inputStreamReader = new InputStreamReader(new GZIPInputStream(inputStream));
+        } else {
+            inputStreamReader = new InputStreamReader(inputStream);
+        }
+        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
+        while (true) {
+            String readLine = bufferedReader.readLine();
+            if (readLine != null) {
+                stringBuffer.append(readLine);
+            } else {
+                return stringBuffer.toString();
+            }
+        }
+    }
+
+    public static Map getPostPayloadParams(Map map) {
+        HashMap hashMap = new HashMap();
+        for (String str : POST_PAYLOAD_PARAMS_KEYS) {
+            if (map.containsKey(str)) {
+                hashMap.put(str, map.get(str));
+                map.remove(str);
+            }
+        }
+        return hashMap;
+    }
+
+    public static void setPayloadForRequest(HttpURLConnection httpURLConnection, Map map, String str) {
+        if (httpURLConnection == null) {
+            return;
+        }
+        try {
+            JSONObject jSONObject = new JSONObject();
+            if (map != null && map.size() > 0) {
+                String jSONObject2 = new JSONObject(map).toString();
+                String sha1Hash = Utils.sha1Hash(jSONObject2, str);
+                jSONObject.put("payload", jSONObject2);
+                jSONObject.put(InAppPurchaseMetaData.KEY_SIGNATURE, sha1Hash);
+            }
+            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(httpURLConnection.getOutputStream(), "UTF-8");
+            outputStreamWriter.write(jSONObject.toString());
+            outputStreamWriter.close();
+        } catch (IOException e) {
+            e = e;
+            e.printStackTrace();
+        } catch (JSONException e2) {
+            e = e2;
+            e.printStackTrace();
+        }
+    }
+
+    public static void setDefaultConnectionProperties(HttpURLConnection httpURLConnection) {
+        httpURLConnection.setConnectTimeout(10000);
+        httpURLConnection.setReadTimeout(10000);
+        httpURLConnection.setRequestMethod("POST");
+        httpURLConnection.setDoInput(true);
+        httpURLConnection.setUseCaches(false);
+        httpURLConnection.setRequestProperty("User-Agent", Constants.HTTP_USER_AGENT);
+        httpURLConnection.setRequestProperty("Content-Type", nb.L);
+    }
+
+    public static String getQueryString(SingularInstance singularInstance, Map map, long j) {
+        StringBuilder sb = new StringBuilder();
+        if (map == null) {
+            map = new HashMap();
+        }
+        TreeMap treeMap = new TreeMap(map);
+        treeMap.put("rt", "json");
+        treeMap.put("lag", String.valueOf(Utils.lagSince(j)));
+        treeMap.put("c", Utils.getConnectionType(singularInstance.getContext()));
+        for (Map.Entry entry : treeMap.entrySet()) {
+            String encode = URLEncoder.encode((String) entry.getKey(), "UTF-8");
+            String str = (String) entry.getValue();
+            String encode2 = str != null ? URLEncoder.encode(str, "UTF-8") : "";
+            if (sb.length() > 0) {
+                sb.append(v8.i.c);
+            }
+            sb.append(encode);
+            sb.append(v8.i.b);
+            sb.append(encode2);
+        }
+        return sb.toString();
+    }
+
+    public static String appendHash(String str, String str2) {
+        if (str == null) {
+            return "";
+        }
+        String sha1Hash = Utils.sha1Hash(String.format("?%s", str), str2);
+        logger.debug("hash = %s", sha1Hash);
+        if (Utils.isEmptyOrNull(sha1Hash)) {
+            return str;
+        }
+        return str + "&h=" + sha1Hash;
+    }
+
+    public static HttpURLConnection getHttpConnection(URL url) {
+        if (url != null) {
+            return (HttpURLConnection) ((URLConnection) FirebasePerfUrlConnection.instrument(url.openConnection()));
+        }
+        return null;
+    }
+
+    public static HttpURLConnection getHttpsConnection(URL url) {
+        if (url == null) {
+            return null;
+        }
+        return (HttpsURLConnection) ((URLConnection) FirebasePerfUrlConnection.instrument(url.openConnection()));
+    }
+}

decompiled/sources/com/singular/sdk/internal/SingularWorkerThread.java

@@ -0,0 +1,36 @@
+package com.singular.sdk.internal;
+
+import android.os.Handler;
+import android.os.HandlerThread;
+
+/* loaded from: classes4.dex */
+public class SingularWorkerThread extends HandlerThread {
+    public Handler handler;
+
+    public SingularWorkerThread(String str) {
+        super(str);
+    }
+
+    public Handler getHandler() {
+        ensureInit();
+        return this.handler;
+    }
+
+    public void post(Runnable runnable) {
+        getHandler().post(runnable);
+    }
+
+    public void postDelayed(Runnable runnable, int i) {
+        getHandler().postDelayed(runnable, i);
+    }
+
+    public void postAtFront(Runnable runnable) {
+        getHandler().postAtFrontOfQueue(runnable);
+    }
+
+    public final synchronized void ensureInit() {
+        if (this.handler == null) {
+            this.handler = new Handler(getLooper());
+        }
+    }
+}

decompiled/sources/com/singular/sdk/internal/Utils.java

@@ -0,0 +1,380 @@
+package com.singular.sdk.internal;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.res.Configuration;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.net.Uri;
+import android.provider.Settings;
+import com.applovin.exoplayer2.common.base.Ascii;
+import com.ironsource.v8;
+import com.singular.sdk.SingularLinkParams;
+import com.unity3d.ads.core.data.datasource.AndroidStaticDeviceInfoDataSource;
+import java.io.File;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.security.MessageDigest;
+import java.text.SimpleDateFormat;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Locale;
+import java.util.Set;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public abstract class Utils {
+    public static final SingularLog logger = SingularLog.getLogger(Utils.class.getSimpleName());
+    public static String wrapperName = null;
+    public static String wrapperVersion = null;
+
+    public static boolean isEmptyOrNull(String str) {
+        return str == null || str.trim().length() == 0;
+    }
+
+    public static long getCurrentTimeMillis() {
+        return System.currentTimeMillis();
+    }
+
+    public static double lagSince(long j) {
+        return (getCurrentTimeMillis() - j) * 0.001d;
+    }
+
+    public static String sha1Hash(String str, String str2) {
+        try {
+            MessageDigest messageDigest = MessageDigest.getInstance(AndroidStaticDeviceInfoDataSource.ALGORITHM_SHA1);
+            messageDigest.update(str2.getBytes("UTF-8"));
+            messageDigest.update(str.getBytes("UTF-8"));
+            return bytesToHexString(messageDigest.digest());
+        } catch (Exception e) {
+            logger.error("error in sha1Hash()", e);
+            return null;
+        }
+    }
+
+    public static String bytesToHexString(byte[] bArr) {
+        char[] cArr = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+        char[] cArr2 = new char[bArr.length * 2];
+        for (int i = 0; i < bArr.length; i++) {
+            byte b = bArr[i];
+            int i2 = i * 2;
+            cArr2[i2] = cArr[(b & 255) >>> 4];
+            cArr2[i2 + 1] = cArr[b & Ascii.SI];
+        }
+        return new String(cArr2);
+    }
+
+    public static String formatTimestamp(long j) {
+        return new SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss Z").format(Long.valueOf(j));
+    }
+
+    public static boolean isGooglePlayServicesAvailable() {
+        return Reflection.forName("com.google.android.gms.ads.identifier.AdvertisingIdClient") != null;
+    }
+
+    public static Object getAdvertisingInfoObject(Context context) {
+        return Reflection.invokeStaticMethod("com.google.android.gms.ads.identifier.AdvertisingIdClient", "getAdvertisingIdInfo", new Class[]{Context.class}, context);
+    }
+
+    public static String getPlayStoreAdId(Context context) {
+        try {
+            return (String) Reflection.invokeInstanceMethod(getAdvertisingInfoObject(context), "getId", null, new Object[0]);
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    public static boolean isLimitedTrackingEnabled(Context context) {
+        try {
+            return ((Boolean) Reflection.invokeInstanceMethod(getAdvertisingInfoObject(context), v8.i.M, null, new Object[0])).booleanValue();
+        } catch (Throwable unused) {
+            return false;
+        }
+    }
+
+    public static String getAndroidId(Context context) {
+        String string = Settings.Secure.getString(context.getContentResolver(), "android_id");
+        return !getInvalidDeviceIds().contains(string) ? string : "None";
+    }
+
+    public static Set getInvalidDeviceIds() {
+        HashSet hashSet = new HashSet();
+        hashSet.add("");
+        hashSet.add("9774d56d682e549c");
+        hashSet.add("unknown");
+        hashSet.add("000000000000000");
+        hashSet.add(v8.d);
+        hashSet.add("DEFACE");
+        hashSet.add("00000000-0000-0000-0000-000000000000");
+        return hashSet;
+    }
+
+    public static NetworkInfo getNetworkInfo(Context context) {
+        return ((ConnectivityManager) context.getSystemService("connectivity")).getActiveNetworkInfo();
+    }
+
+    public static boolean isConnected(Context context) {
+        NetworkInfo networkInfo = getNetworkInfo(context);
+        return networkInfo != null && networkInfo.isConnected();
+    }
+
+    public static boolean isConnectedWifi(Context context) {
+        NetworkInfo networkInfo = getNetworkInfo(context);
+        return networkInfo != null && networkInfo.isConnected() && networkInfo.getType() == 1;
+    }
+
+    public static boolean isConnectedMobile(Context context) {
+        NetworkInfo networkInfo = getNetworkInfo(context);
+        return networkInfo != null && networkInfo.isConnected() && networkInfo.getType() == 0;
+    }
+
+    public static String getConnectionType(Context context) {
+        if (isConnectedMobile(context)) {
+            return "wwan";
+        }
+        isConnectedWifi(context);
+        return "wifi";
+    }
+
+    public static Locale getLocale(Configuration configuration) {
+        Locale localeFromLocaleList = Reflection.getLocaleFromLocaleList(configuration);
+        return localeFromLocaleList != null ? localeFromLocaleList : Reflection.getLocaleFromField(configuration);
+    }
+
+    public static String[] getSupportedAbis() {
+        return Reflection.getSupportedAbis();
+    }
+
+    public static String getCpuAbi() {
+        return Reflection.getCpuAbi();
+    }
+
+    public static void saveCSIReferrer(Context context, String str) {
+        SharedPreferences.Editor edit = context.getSharedPreferences("install-openUri", 0).edit();
+        edit.putString("openUri", str);
+        edit.commit();
+    }
+
+    public static String getCSIReferrer(Context context) {
+        return context.getSharedPreferences("install-openUri", 0).getString("openUri", null);
+    }
+
+    public static void signalAsyncReferrerAllowed(Context context) {
+        SharedPreferences.Editor edit = context.getSharedPreferences("install-openUri", 0).edit();
+        edit.putBoolean("asyncReferrerAllowed", true);
+        edit.commit();
+    }
+
+    public static boolean isAsyncReferrerAllowed(Context context) {
+        return context.getSharedPreferences("install-openUri", 0).getBoolean("asyncReferrerAllowed", false);
+    }
+
+    public static boolean isFirstInstall(Context context) {
+        File file = new File(context.getFilesDir(), "appInstallInfo");
+        if (file.exists()) {
+            saveFirstInstallInfo(context);
+            file.delete();
+            return false;
+        }
+        if (context.getSharedPreferences("singular-first-install", 0).getBoolean("wasOpenedAfterInstall", false)) {
+            return false;
+        }
+        saveFirstInstallInfo(context);
+        return true;
+    }
+
+    public static void saveFirstInstallInfo(Context context) {
+        SharedPreferences.Editor edit = context.getSharedPreferences("singular-first-install", 0).edit();
+        edit.putBoolean("wasOpenedAfterInstall", true);
+        edit.commit();
+    }
+
+    public static UUID getSingularId(Context context) {
+        SharedPreferences sharedPreferences = context.getSharedPreferences("pref-singular-id", 0);
+        String string = sharedPreferences.getString("singular-id", null);
+        if (string != null) {
+            return UUID.fromString(string);
+        }
+        return createSingularId(sharedPreferences);
+    }
+
+    public static UUID createSingularId(SharedPreferences sharedPreferences) {
+        UUID randomUUID = UUID.randomUUID();
+        SharedPreferences.Editor edit = sharedPreferences.edit();
+        edit.putString("singular-id", randomUUID.toString());
+        edit.commit();
+        return randomUUID;
+    }
+
+    public static long getEventIndex(Context context) {
+        SharedPreferences sharedPreferences = context.getSharedPreferences("pref-event-index", 0);
+        return increaseEventIndex(sharedPreferences, sharedPreferences.getLong("event-index", -1L));
+    }
+
+    public static long increaseEventIndex(SharedPreferences sharedPreferences, long j) {
+        long j2 = j + 1;
+        SharedPreferences.Editor edit = sharedPreferences.edit();
+        edit.putLong("event-index", j2);
+        edit.commit();
+        return j2;
+    }
+
+    public static boolean isLicenseRetrieved(Context context, String str) {
+        return context.getSharedPreferences("singular-licensing-api", 0).getBoolean(str, false);
+    }
+
+    public static void saveLicenseInfo(Context context, String str) {
+        SharedPreferences.Editor edit = context.getSharedPreferences("singular-licensing-api", 0).edit();
+        edit.putBoolean(str, true);
+        edit.commit();
+    }
+
+    public static class Reflection {
+        public static String[] getSupportedAbis() {
+            try {
+                return (String[]) readField("android.os.Build", "SUPPORTED_ABIS");
+            } catch (Throwable unused) {
+                return null;
+            }
+        }
+
+        public static String getCpuAbi() {
+            try {
+                return (String) readField("android.os.Build", "CPU_ABI");
+            } catch (Throwable unused) {
+                return null;
+            }
+        }
+
+        public static Locale getLocaleFromLocaleList(Configuration configuration) {
+            try {
+                Object invokeInstanceMethod = invokeInstanceMethod(configuration, "getLocales", null, new Object[0]);
+                if (invokeInstanceMethod == null) {
+                    return null;
+                }
+                return (Locale) invokeInstanceMethod(invokeInstanceMethod, "get", new Class[]{Integer.TYPE}, 0);
+            } catch (Throwable unused) {
+                return null;
+            }
+        }
+
+        public static Locale getLocaleFromField(Configuration configuration) {
+            try {
+                return (Locale) readField("android.content.res.Configuration", "locale", configuration);
+            } catch (Throwable unused) {
+                return null;
+            }
+        }
+
+        public static Object invokeInstanceMethod(Object obj, String str, Class[] clsArr, Object... objArr) {
+            return invokeMethod(obj.getClass(), str, obj, clsArr, objArr);
+        }
+
+        public static Object invokeStaticMethod(String str, String str2, Class[] clsArr, Object... objArr) {
+            return invokeMethod(Class.forName(str), str2, null, clsArr, objArr);
+        }
+
+        public static Object invokeMethod(Class cls, String str, Object obj, Class[] clsArr, Object... objArr) {
+            Method method = cls.getMethod(str, clsArr);
+            if (method == null) {
+                return null;
+            }
+            return method.invoke(obj, objArr);
+        }
+
+        public static Object readField(String str, String str2) {
+            return readField(str, str2, null);
+        }
+
+        public static Object readField(String str, String str2, Object obj) {
+            Field field;
+            Class forName = forName(str);
+            if (forName == null || (field = forName.getField(str2)) == null) {
+                return null;
+            }
+            return field.get(obj);
+        }
+
+        public static Class forName(String str) {
+            try {
+                return Class.forName(str);
+            } catch (Throwable unused) {
+                return null;
+            }
+        }
+    }
+
+    public static String getPlayStoreAdIdByBackupMethod(Context context) {
+        try {
+            return ExternalAIFAHelper.getAIFA(context);
+        } catch (Throwable unused) {
+            return null;
+        }
+    }
+
+    public static boolean isShortLink(Uri uri) {
+        return extractDeepLink(uri) == null;
+    }
+
+    public static String extractDeepLink(Uri uri) {
+        if (uri == null) {
+            return null;
+        }
+        String queryParameter = uri.getQueryParameter("_android_dl");
+        return queryParameter != null ? queryParameter : uri.getQueryParameter("_dl");
+    }
+
+    public static String extractPassthroughFromSingularLink(Uri uri) {
+        return uri.getQueryParameter("_p");
+    }
+
+    public static void handleSingularLink(Uri uri) {
+        String extractDeepLink = extractDeepLink(uri);
+        if (extractDeepLink != null) {
+            handleDeepLink(new SingularLinkParams(extractDeepLink, extractPassthroughFromSingularLink(uri), false));
+        }
+    }
+
+    public static boolean handleDeepLink(SingularLinkParams singularLinkParams) {
+        SingularInstance.getInstance().getSingularConfig().getClass();
+        singularLinkParams.getDeeplink();
+        return false;
+    }
+
+    public static boolean validateSingularLink(Uri uri) {
+        if (uri == null) {
+            return false;
+        }
+        if (uri.getScheme() == null) {
+            uri = Uri.parse("https://" + uri.toString());
+        }
+        if (uri.getHost() != null && uri.getHost().endsWith("sng.link")) {
+            return true;
+        }
+        if (SingularInstance.getInstance() != null && SingularInstance.getInstance().getSingularConfig() != null && SingularInstance.getInstance().getSingularConfig().approvedDomains != null) {
+            Iterator it = SingularInstance.getInstance().getSingularConfig().approvedDomains.iterator();
+            while (it.hasNext()) {
+                if (uri.getHost().equals((String) it.next())) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public static boolean isOpenedWithDeeplink() {
+        return SingularInstance.getInstance().getSingularConfig().isOpenedWithDeepLink;
+    }
+
+    public static boolean appMovedToBackground() {
+        SingularInstance.getInstance().getSingularConfig().isOpenedWithDeepLink = false;
+        return false;
+    }
+
+    public static String getSdkVersion() {
+        String str;
+        String str2 = SingularInstance.getInstance().getDeviceInfo().sdkVersion;
+        String str3 = wrapperName;
+        return (str3 == null || (str = wrapperVersion) == null) ? str2 : String.format("%s-%s/%s", str2, str3, str);
+    }
+}