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/vungle/ads/internal/executor/Executors.java

@@ -0,0 +1,20 @@
+package com.vungle.ads.internal.executor;
+
+/* loaded from: classes4.dex */
+public interface Executors {
+    VungleThreadPoolExecutor getApiExecutor();
+
+    VungleThreadPoolExecutor getBackgroundExecutor();
+
+    VungleThreadPoolExecutor getDownloaderExecutor();
+
+    VungleThreadPoolExecutor getIoExecutor();
+
+    VungleThreadPoolExecutor getJobExecutor();
+
+    VungleThreadPoolExecutor getLoggerExecutor();
+
+    VungleThreadPoolExecutor getOffloadExecutor();
+
+    VungleThreadPoolExecutor getUaExecutor();
+}

decompiled/sources/com/vungle/ads/internal/executor/FutureResult.java

@@ -0,0 +1,121 @@
+package com.vungle.ads.internal.executor;
+
+import com.vungle.ads.internal.util.Logger;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes4.dex */
+public final class FutureResult<T> implements Future<T> {
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = FutureResult.class.getSimpleName();
+    private final Future<T> future;
+
+    public final Future<T> getFuture() {
+        return this.future;
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        public final String getTAG() {
+            return FutureResult.TAG;
+        }
+    }
+
+    public FutureResult(Future<T> future) {
+        this.future = future;
+    }
+
+    @Override // java.util.concurrent.Future
+    public boolean cancel(boolean z) {
+        Future<T> future = this.future;
+        if (future != null) {
+            return future.cancel(z);
+        }
+        return false;
+    }
+
+    @Override // java.util.concurrent.Future
+    public boolean isCancelled() {
+        Future<T> future = this.future;
+        if (future != null) {
+            return future.isCancelled();
+        }
+        return false;
+    }
+
+    @Override // java.util.concurrent.Future
+    public boolean isDone() {
+        Future<T> future = this.future;
+        if (future != null) {
+            return future.isDone();
+        }
+        return false;
+    }
+
+    @Override // java.util.concurrent.Future
+    public T get() {
+        try {
+            Future<T> future = this.future;
+            if (future != null) {
+                return future.get();
+            }
+            return null;
+        } catch (InterruptedException unused) {
+            Logger.Companion companion = Logger.Companion;
+            String TAG2 = TAG;
+            Intrinsics.checkNotNullExpressionValue(TAG2, "TAG");
+            companion.w(TAG2, "future.get() Interrupted on Thread " + Thread.currentThread().getName());
+            Thread.currentThread().interrupt();
+            return null;
+        } catch (ExecutionException e) {
+            Logger.Companion companion2 = Logger.Companion;
+            String TAG3 = TAG;
+            Intrinsics.checkNotNullExpressionValue(TAG3, "TAG");
+            companion2.e(TAG3, "error on execution", e);
+            return null;
+        }
+    }
+
+    @Override // java.util.concurrent.Future
+    public T get(long j, TimeUnit unit) {
+        Intrinsics.checkNotNullParameter(unit, "unit");
+        try {
+            Future<T> future = this.future;
+            if (future != null) {
+                return future.get(j, unit);
+            }
+            return null;
+        } catch (InterruptedException unused) {
+            Logger.Companion companion = Logger.Companion;
+            String TAG2 = TAG;
+            Intrinsics.checkNotNullExpressionValue(TAG2, "TAG");
+            companion.w(TAG2, "future.get() Interrupted on Thread " + Thread.currentThread().getName());
+            Thread.currentThread().interrupt();
+            return null;
+        } catch (ExecutionException e) {
+            Logger.Companion companion2 = Logger.Companion;
+            String TAG3 = TAG;
+            Intrinsics.checkNotNullExpressionValue(TAG3, "TAG");
+            companion2.e(TAG3, "error on execution", e);
+            return null;
+        } catch (TimeoutException e2) {
+            Logger.Companion companion3 = Logger.Companion;
+            String TAG4 = TAG;
+            Intrinsics.checkNotNullExpressionValue(TAG4, "TAG");
+            companion3.e(TAG4, "error on timeout", e2);
+            Intrinsics.checkNotNullExpressionValue(TAG4, "TAG");
+            companion3.w(TAG4, "future.get() Timeout on Thread " + Thread.currentThread().getName());
+            return null;
+        }
+    }
+}

decompiled/sources/com/vungle/ads/internal/executor/NamedThreadFactory.java

@@ -0,0 +1,28 @@
+package com.vungle.ads.internal.executor;
+
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes4.dex */
+public final class NamedThreadFactory implements ThreadFactory {
+    private final AtomicInteger atomicInteger;
+    private final String name;
+    private final ThreadFactory threadFactory;
+
+    public NamedThreadFactory(String name) {
+        Intrinsics.checkNotNullParameter(name, "name");
+        this.name = name;
+        this.threadFactory = java.util.concurrent.Executors.defaultThreadFactory();
+        this.atomicInteger = new AtomicInteger(0);
+    }
+
+    @Override // java.util.concurrent.ThreadFactory
+    public Thread newThread(Runnable r) {
+        Intrinsics.checkNotNullParameter(r, "r");
+        Thread t = this.threadFactory.newThread(r);
+        t.setName(this.name + "-th-" + this.atomicInteger.incrementAndGet());
+        Intrinsics.checkNotNullExpressionValue(t, "t");
+        return t;
+    }
+}

decompiled/sources/com/vungle/ads/internal/executor/SDKExecutors.java

@@ -0,0 +1,85 @@
+package com.vungle.ads.internal.executor;
+
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+
+/* loaded from: classes4.dex */
+public final class SDKExecutors implements Executors {
+    public static final Companion Companion = new Companion(null);
+    private static final int IO_KEEP_ALIVE_TIME_SECONDS = 5;
+    private static final int JOBS_KEEP_ALIVE_TIME_SECONDS = 1;
+    private static final int SINGLE_CORE_POOL_SIZE = 1;
+    private static final int VUNGLE_KEEP_ALIVE_TIME_SECONDS = 10;
+    private VungleThreadPoolExecutor API_EXECUTOR;
+    private VungleThreadPoolExecutor BACKGROUND_EXECUTOR;
+    private VungleThreadPoolExecutor DOWNLOADER_EXECUTOR;
+    private VungleThreadPoolExecutor IO_EXECUTOR;
+    private VungleThreadPoolExecutor JOB_EXECUTOR;
+    private VungleThreadPoolExecutor LOGGER_EXECUTOR;
+    private final int NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors();
+    private VungleThreadPoolExecutor OFFLOAD_EXECUTOR;
+    private VungleThreadPoolExecutor UA_EXECUTOR;
+
+    @Override // com.vungle.ads.internal.executor.Executors
+    public VungleThreadPoolExecutor getApiExecutor() {
+        return this.API_EXECUTOR;
+    }
+
+    @Override // com.vungle.ads.internal.executor.Executors
+    public VungleThreadPoolExecutor getBackgroundExecutor() {
+        return this.BACKGROUND_EXECUTOR;
+    }
+
+    @Override // com.vungle.ads.internal.executor.Executors
+    public VungleThreadPoolExecutor getDownloaderExecutor() {
+        return this.DOWNLOADER_EXECUTOR;
+    }
+
+    @Override // com.vungle.ads.internal.executor.Executors
+    public VungleThreadPoolExecutor getIoExecutor() {
+        return this.IO_EXECUTOR;
+    }
+
+    @Override // com.vungle.ads.internal.executor.Executors
+    public VungleThreadPoolExecutor getJobExecutor() {
+        return this.JOB_EXECUTOR;
+    }
+
+    @Override // com.vungle.ads.internal.executor.Executors
+    public VungleThreadPoolExecutor getLoggerExecutor() {
+        return this.LOGGER_EXECUTOR;
+    }
+
+    @Override // com.vungle.ads.internal.executor.Executors
+    public VungleThreadPoolExecutor getOffloadExecutor() {
+        return this.OFFLOAD_EXECUTOR;
+    }
+
+    @Override // com.vungle.ads.internal.executor.Executors
+    public VungleThreadPoolExecutor getUaExecutor() {
+        return this.UA_EXECUTOR;
+    }
+
+    public SDKExecutors() {
+        TimeUnit timeUnit = TimeUnit.SECONDS;
+        this.JOB_EXECUTOR = new VungleThreadPoolExecutor(1, 1, 1L, timeUnit, new LinkedBlockingQueue(), new NamedThreadFactory("vng_jr"));
+        this.IO_EXECUTOR = new VungleThreadPoolExecutor(1, 1, 5L, timeUnit, new LinkedBlockingQueue(), new NamedThreadFactory("vng_io"));
+        this.API_EXECUTOR = new VungleThreadPoolExecutor(1, 1, 10L, timeUnit, new LinkedBlockingQueue(), new NamedThreadFactory("vng_api"));
+        this.LOGGER_EXECUTOR = new VungleThreadPoolExecutor(1, 1, 10L, timeUnit, new LinkedBlockingQueue(), new NamedThreadFactory("vng_logger"));
+        this.BACKGROUND_EXECUTOR = new VungleThreadPoolExecutor(1, 1, 10L, timeUnit, new LinkedBlockingQueue(), new NamedThreadFactory("vng_background"));
+        this.UA_EXECUTOR = new VungleThreadPoolExecutor(1, 1, 10L, timeUnit, new LinkedBlockingQueue(), new NamedThreadFactory("vng_ua"));
+        this.DOWNLOADER_EXECUTOR = new VungleThreadPoolExecutor(4, 4, 1L, timeUnit, new PriorityBlockingQueue(), new NamedThreadFactory("vng_down"));
+        this.OFFLOAD_EXECUTOR = new VungleThreadPoolExecutor(1, 1, 10L, timeUnit, new LinkedBlockingQueue(), new NamedThreadFactory("vng_ol"));
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+    }
+}

decompiled/sources/com/vungle/ads/internal/executor/VungleThreadPoolExecutor.java

@@ -0,0 +1,233 @@
+package com.vungle.ads.internal.executor;
+
+import com.vungle.ads.OutOfMemory;
+import com.vungle.ads.internal.executor.VungleThreadPoolExecutor;
+import com.vungle.ads.internal.task.PriorityRunnable;
+import com.vungle.ads.internal.util.Logger;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import kotlin.Unit;
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.DefaultConstructorMarker;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes4.dex */
+public final class VungleThreadPoolExecutor extends ThreadPoolExecutor {
+    public static final Companion Companion = new Companion(null);
+    private static final String TAG = "VungleThreadPool";
+
+    public interface ComparableRunnable extends Comparable<Object>, Runnable {
+    }
+
+    public VungleThreadPoolExecutor(int i, int i2, long j, TimeUnit timeUnit, BlockingQueue<Runnable> blockingQueue, ThreadFactory threadFactory) {
+        super(i, i2, j, timeUnit, blockingQueue, threadFactory);
+        allowCoreThreadTimeOut(true);
+    }
+
+    public static final class Companion {
+        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
+            this();
+        }
+
+        private Companion() {
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final void wrapRunnableWithFail(Runnable runnable, Runnable runnable2) {
+            try {
+                runnable.run();
+            } catch (OutOfMemoryError unused) {
+                runnable2.run();
+            }
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final ComparableRunnable getWrappedRunnableWithFail(final Runnable runnable, final Runnable runnable2) {
+            if (runnable instanceof PriorityRunnable) {
+                return new PriorityRunnable() { // from class: com.vungle.ads.internal.executor.VungleThreadPoolExecutor$Companion$getWrappedRunnableWithFail$1
+                    @Override // com.vungle.ads.internal.task.PriorityRunnable
+                    public int getPriority() {
+                        return ((PriorityRunnable) runnable).getPriority();
+                    }
+
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        VungleThreadPoolExecutor.Companion.wrapRunnableWithFail(runnable, runnable2);
+                    }
+
+                    @Override // com.vungle.ads.internal.task.PriorityRunnable, java.lang.Comparable
+                    public int compareTo(Object other) {
+                        Intrinsics.checkNotNullParameter(other, "other");
+                        if (!(other instanceof PriorityRunnable)) {
+                            return 0;
+                        }
+                        return Intrinsics.compare(((PriorityRunnable) other).getPriority(), getPriority());
+                    }
+                };
+            }
+            return new ComparableRunnable() { // from class: com.vungle.ads.internal.executor.VungleThreadPoolExecutor$Companion$getWrappedRunnableWithFail$2
+                @Override // java.lang.Runnable
+                public void run() {
+                    VungleThreadPoolExecutor.Companion.wrapRunnableWithFail(runnable, runnable2);
+                }
+
+                @Override // java.lang.Comparable
+                public int compareTo(Object other) {
+                    Intrinsics.checkNotNullParameter(other, "other");
+                    Runnable runnable3 = runnable;
+                    if (runnable3 instanceof PriorityRunnable) {
+                        return ((PriorityRunnable) runnable3).compareTo(other);
+                    }
+                    return 0;
+                }
+            };
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public final <T> Callable<T> getWrappedCallableWithFallback(final Callable<T> callable, final Function0 function0) {
+            return new Callable() { // from class: com.vungle.ads.internal.executor.VungleThreadPoolExecutor$Companion$$ExternalSyntheticLambda0
+                @Override // java.util.concurrent.Callable
+                public final Object call() {
+                    Object m3889getWrappedCallableWithFallback$lambda0;
+                    m3889getWrappedCallableWithFallback$lambda0 = VungleThreadPoolExecutor.Companion.m3889getWrappedCallableWithFallback$lambda0(callable, function0);
+                    return m3889getWrappedCallableWithFallback$lambda0;
+                }
+            };
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        /* renamed from: getWrappedCallableWithFallback$lambda-0, reason: not valid java name */
+        public static final Object m3889getWrappedCallableWithFallback$lambda0(Callable command, Function0 failFallback) {
+            Intrinsics.checkNotNullParameter(command, "$command");
+            Intrinsics.checkNotNullParameter(failFallback, "$failFallback");
+            try {
+                return command.call();
+            } catch (OutOfMemoryError unused) {
+                failFallback.invoke();
+                return null;
+            }
+        }
+    }
+
+    @Override // java.util.concurrent.ThreadPoolExecutor, java.util.concurrent.Executor
+    public void execute(Runnable command) {
+        Intrinsics.checkNotNullParameter(command, "command");
+        try {
+            super.execute(Companion.getWrappedRunnableWithFail(command, new Runnable() { // from class: com.vungle.ads.internal.executor.VungleThreadPoolExecutor$$ExternalSyntheticLambda0
+                @Override // java.lang.Runnable
+                public final void run() {
+                    VungleThreadPoolExecutor.m3886execute$lambda0();
+                }
+            }));
+        } catch (Exception e) {
+            Logger.Companion.e(TAG, "execute error: " + e);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: execute$lambda-0, reason: not valid java name */
+    public static final void m3886execute$lambda0() {
+        new OutOfMemory("execute error").logErrorNoReturnValue$vungle_ads_release();
+    }
+
+    public final void execute(Runnable command, Runnable fail) {
+        Intrinsics.checkNotNullParameter(command, "command");
+        Intrinsics.checkNotNullParameter(fail, "fail");
+        try {
+            super.execute(Companion.getWrappedRunnableWithFail(command, fail));
+        } catch (Exception e) {
+            Logger.Companion.e(TAG, "execute error with fail: " + e);
+            fail.run();
+        }
+    }
+
+    @Override // java.util.concurrent.AbstractExecutorService, java.util.concurrent.ExecutorService
+    public Future<?> submit(Runnable task) {
+        Intrinsics.checkNotNullParameter(task, "task");
+        try {
+            Future<?> submit = super.submit(Companion.getWrappedRunnableWithFail(task, new Runnable() { // from class: com.vungle.ads.internal.executor.VungleThreadPoolExecutor$$ExternalSyntheticLambda2
+                @Override // java.lang.Runnable
+                public final void run() {
+                    VungleThreadPoolExecutor.m3887submit$lambda1();
+                }
+            }));
+            Intrinsics.checkNotNullExpressionValue(submit, "{\n            super.subm…\n            })\n        }");
+            return submit;
+        } catch (Exception e) {
+            Logger.Companion.e(TAG, "submit error: " + e);
+            return new FutureResult(null);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: submit$lambda-1, reason: not valid java name */
+    public static final void m3887submit$lambda1() {
+        new OutOfMemory("submit error").logErrorNoReturnValue$vungle_ads_release();
+    }
+
+    @Override // java.util.concurrent.AbstractExecutorService, java.util.concurrent.ExecutorService
+    public <T> Future<T> submit(Runnable task, T t) {
+        Intrinsics.checkNotNullParameter(task, "task");
+        try {
+            Future<T> submit = super.submit((Runnable) Companion.getWrappedRunnableWithFail(task, new Runnable() { // from class: com.vungle.ads.internal.executor.VungleThreadPoolExecutor$$ExternalSyntheticLambda1
+                @Override // java.lang.Runnable
+                public final void run() {
+                    VungleThreadPoolExecutor.m3888submit$lambda2();
+                }
+            }), (ComparableRunnable) t);
+            Intrinsics.checkNotNullExpressionValue(submit, "{\n            super.subm…     }, result)\n        }");
+            return submit;
+        } catch (Exception e) {
+            Logger.Companion.e(TAG, "submit error with result: " + e);
+            return new FutureResult(null);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    /* renamed from: submit$lambda-2, reason: not valid java name */
+    public static final void m3888submit$lambda2() {
+        new OutOfMemory("submit error with error").logErrorNoReturnValue$vungle_ads_release();
+    }
+
+    public final Future<?> submit(Runnable task, Runnable fail) {
+        Intrinsics.checkNotNullParameter(task, "task");
+        Intrinsics.checkNotNullParameter(fail, "fail");
+        try {
+            Future<?> submit = super.submit(Companion.getWrappedRunnableWithFail(task, fail));
+            Intrinsics.checkNotNullExpressionValue(submit, "{\n            super.subm…il(task, fail))\n        }");
+            return submit;
+        } catch (Exception e) {
+            Logger.Companion.e(TAG, "submit error with fail: " + e);
+            fail.run();
+            return new FutureResult(null);
+        }
+    }
+
+    @Override // java.util.concurrent.AbstractExecutorService, java.util.concurrent.ExecutorService
+    public <T> Future<T> submit(Callable<T> task) {
+        Intrinsics.checkNotNullParameter(task, "task");
+        try {
+            Future<T> submit = super.submit(Companion.getWrappedCallableWithFallback(task, new Function0() { // from class: com.vungle.ads.internal.executor.VungleThreadPoolExecutor$submit$3
+                @Override // kotlin.jvm.functions.Function0
+                public /* bridge */ /* synthetic */ Object invoke() {
+                    m3890invoke();
+                    return Unit.INSTANCE;
+                }
+
+                /* renamed from: invoke, reason: collision with other method in class */
+                public final void m3890invoke() {
+                    new OutOfMemory("submit callable error").logErrorNoReturnValue$vungle_ads_release();
+                }
+            }));
+            Intrinsics.checkNotNullExpressionValue(submit, "{\n            super.subm…\n            })\n        }");
+            return submit;
+        } catch (Exception e) {
+            Logger.Companion.e(TAG, "submit callable: " + e);
+            return new FutureResult(null);
+        }
+    }
+}