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/helpshift/concurrency/HSThreader.java

@@ -0,0 +1,6 @@
+package com.helpshift.concurrency;
+
+/* loaded from: classes3.dex */
+public interface HSThreader {
+    void submit(Runnable runnable);
+}

decompiled/sources/com/helpshift/concurrency/HSThreadingService.java

@@ -0,0 +1,40 @@
+package com.helpshift.concurrency;
+
+/* loaded from: classes3.dex */
+public class HSThreadingService {
+    public final HSThreader hsuiThreader;
+    public final HSThreader networkService;
+    public final HSThreader serialQueue;
+    public final Object syncLock = new Object();
+
+    public HSThreader getNetworkService() {
+        return this.networkService;
+    }
+
+    public HSThreadingService(HSThreader hSThreader, HSThreader hSThreader2, HSThreader hSThreader3) {
+        this.networkService = hSThreader;
+        this.serialQueue = hSThreader2;
+        this.hsuiThreader = hSThreader3;
+    }
+
+    public void runSerial(Runnable runnable) {
+        this.serialQueue.submit(runnable);
+    }
+
+    public void runSync(Runnable runnable) {
+        NotifyingRunnable notifyingRunnable = new NotifyingRunnable(runnable);
+        synchronized (this.syncLock) {
+            runSerial(notifyingRunnable);
+            notifyingRunnable.waitForCompletion();
+        }
+    }
+
+    public void runOnUIThread(final Runnable runnable) {
+        this.serialQueue.submit(new Runnable() { // from class: com.helpshift.concurrency.HSThreadingService.2
+            @Override // java.lang.Runnable
+            public void run() {
+                HSThreadingService.this.hsuiThreader.submit(runnable);
+            }
+        });
+    }
+}

decompiled/sources/com/helpshift/concurrency/HSUIThreader.java

@@ -0,0 +1,18 @@
+package com.helpshift.concurrency;
+
+import android.os.Handler;
+import android.os.Looper;
+import com.helpshift.util.SafeWrappedRunnable;
+
+/* loaded from: classes3.dex */
+public class HSUIThreader implements HSThreader {
+    @Override // com.helpshift.concurrency.HSThreader
+    public void submit(Runnable runnable) {
+        SafeWrappedRunnable safeWrappedRunnable = new SafeWrappedRunnable(runnable);
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            safeWrappedRunnable.run();
+        } else {
+            new Handler(Looper.getMainLooper()).post(safeWrappedRunnable);
+        }
+    }
+}

decompiled/sources/com/helpshift/concurrency/HSWorkerThreader.java

@@ -0,0 +1,23 @@
+package com.helpshift.concurrency;
+
+import com.helpshift.log.HSLogger;
+import com.helpshift.util.SafeWrappedRunnable;
+import java.util.concurrent.ExecutorService;
+
+/* loaded from: classes3.dex */
+public class HSWorkerThreader implements HSThreader {
+    public ExecutorService executorService;
+
+    public HSWorkerThreader(ExecutorService executorService) {
+        this.executorService = executorService;
+    }
+
+    @Override // com.helpshift.concurrency.HSThreader
+    public void submit(Runnable runnable) {
+        try {
+            this.executorService.submit(new SafeWrappedRunnable(runnable));
+        } catch (Exception e) {
+            HSLogger.e("HSThreader", "Error while submitting request.", e);
+        }
+    }
+}

decompiled/sources/com/helpshift/concurrency/NotifyingRunnable.java

@@ -0,0 +1,44 @@
+package com.helpshift.concurrency;
+
+import com.helpshift.log.HSLogger;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* loaded from: classes3.dex */
+public class NotifyingRunnable implements Runnable {
+    public final Runnable runnable;
+    public final Object syncLock = new Object();
+    public AtomicBoolean isFinished = new AtomicBoolean(false);
+
+    public NotifyingRunnable(Runnable runnable) {
+        this.runnable = runnable;
+    }
+
+    public void waitForCompletion() {
+        synchronized (this.syncLock) {
+            while (!this.isFinished.get()) {
+                try {
+                    this.syncLock.wait();
+                } catch (InterruptedException e) {
+                    HSLogger.d("NotifyingRunnable", "Exception in NotifyingRunnable", e);
+                    Thread.currentThread().interrupt();
+                }
+            }
+        }
+    }
+
+    @Override // java.lang.Runnable
+    public void run() {
+        synchronized (this.syncLock) {
+            try {
+                try {
+                    this.runnable.run();
+                } finally {
+                    this.isFinished.set(true);
+                    this.syncLock.notifyAll();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}