package p138.p145.p146.p151.p154.p157;

import android.os.Process;
import android.os.StrictMode;
import android.text.TextUtils;
import android.util.Log;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import p138.p139.p143.p144.C2803;

/* JADX INFO: renamed from: ދ.ؠ.֏.ތ.ފ.ޛ.֏, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
public final class ExecutorServiceC2982 implements ExecutorService {

    /* JADX INFO: renamed from: ބ, reason: contains not printable characters */
    public static final long f9147 = TimeUnit.SECONDS.toMillis(10);

    /* JADX INFO: renamed from: ޅ, reason: contains not printable characters */
    public static volatile int f9148;

    /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
    public final ExecutorService f9149;

    /* JADX INFO: renamed from: ދ.ؠ.֏.ތ.ފ.ޛ.֏$֏, reason: contains not printable characters */
    public static final class ThreadFactoryC2983 implements ThreadFactory {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public final String f9150;

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public final InterfaceC2985 f9151;

        /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
        public final boolean f9152;

        /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
        public int f9153;

        /* JADX INFO: renamed from: ދ.ؠ.֏.ތ.ފ.ޛ.֏$֏$֏, reason: contains not printable characters */
        public class C2984 extends Thread {
            public C2984(Runnable runnable, String str) {
                super(runnable, str);
            }

            @Override // java.lang.Thread, java.lang.Runnable
            public void run() {
                Process.setThreadPriority(9);
                if (ThreadFactoryC2983.this.f9152) {
                    StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder().detectNetwork().penaltyDeath().build());
                }
                try {
                    super.run();
                } catch (Throwable th) {
                    ThreadFactoryC2983.this.f9151.mo5132(th);
                }
            }
        }

        public ThreadFactoryC2983(String str, InterfaceC2985 interfaceC2985, boolean z) {
            this.f9150 = str;
            this.f9151 = interfaceC2985;
            this.f9152 = z;
        }

        @Override // java.util.concurrent.ThreadFactory
        public synchronized Thread newThread(Runnable runnable) {
            C2984 c2984;
            c2984 = new C2984(runnable, "glide-" + this.f9150 + "-thread-" + this.f9153);
            this.f9153 = this.f9153 + 1;
            return c2984;
        }
    }

    /* JADX INFO: renamed from: ދ.ؠ.֏.ތ.ފ.ޛ.֏$ؠ, reason: contains not printable characters */
    public interface InterfaceC2985 {

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        public static final InterfaceC2985 f9155 = new C2986();

        /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
        public static final InterfaceC2985 f9156 = f9155;

        /* JADX INFO: renamed from: ދ.ؠ.֏.ތ.ފ.ޛ.֏$ؠ$֏, reason: contains not printable characters */
        public class C2986 implements InterfaceC2985 {
            @Override // p138.p145.p146.p151.p154.p157.ExecutorServiceC2982.InterfaceC2985
            /* JADX INFO: renamed from: ֏ */
            public void mo5132(Throwable th) {
                if (th == null || !Log.isLoggable("GlideExecutor", 6)) {
                    return;
                }
                Log.e("GlideExecutor", "Request threw uncaught throwable", th);
            }
        }

        /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
        void mo5132(Throwable th);
    }

    public ExecutorServiceC2982(ExecutorService executorService) {
        this.f9149 = executorService;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static int m5129() {
        if (f9148 == 0) {
            f9148 = Math.min(4, Runtime.getRuntime().availableProcessors());
        }
        return f9148;
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public static ExecutorServiceC2982 m5130() {
        InterfaceC2985 interfaceC2985 = InterfaceC2985.f9156;
        if (TextUtils.isEmpty("disk-cache")) {
            throw new IllegalArgumentException(C2803.m4879("Name must be non-null and non-empty, but given: ", "disk-cache"));
        }
        return new ExecutorServiceC2982(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new PriorityBlockingQueue(), new ThreadFactoryC2983("disk-cache", interfaceC2985, true)));
    }

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public static ExecutorServiceC2982 m5131() {
        InterfaceC2985 interfaceC2985 = InterfaceC2985.f9156;
        int iM5129 = m5129();
        if (TextUtils.isEmpty("source")) {
            throw new IllegalArgumentException(C2803.m4879("Name must be non-null and non-empty, but given: ", "source"));
        }
        return new ExecutorServiceC2982(new ThreadPoolExecutor(iM5129, iM5129, 0L, TimeUnit.MILLISECONDS, new PriorityBlockingQueue(), new ThreadFactoryC2983("source", interfaceC2985, false)));
    }

    @Override // java.util.concurrent.ExecutorService
    public boolean awaitTermination(long j, TimeUnit timeUnit) {
        return this.f9149.awaitTermination(j, timeUnit);
    }

    @Override // java.util.concurrent.Executor
    public void execute(Runnable runnable) {
        this.f9149.execute(runnable);
    }

    @Override // java.util.concurrent.ExecutorService
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> collection) {
        return this.f9149.invokeAll(collection);
    }

    @Override // java.util.concurrent.ExecutorService
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> collection, long j, TimeUnit timeUnit) {
        return this.f9149.invokeAll(collection, j, timeUnit);
    }

    @Override // java.util.concurrent.ExecutorService
    public <T> T invokeAny(Collection<? extends Callable<T>> collection) {
        return (T) this.f9149.invokeAny(collection);
    }

    @Override // java.util.concurrent.ExecutorService
    public <T> T invokeAny(Collection<? extends Callable<T>> collection, long j, TimeUnit timeUnit) {
        return (T) this.f9149.invokeAny(collection, j, timeUnit);
    }

    @Override // java.util.concurrent.ExecutorService
    public boolean isShutdown() {
        return this.f9149.isShutdown();
    }

    @Override // java.util.concurrent.ExecutorService
    public boolean isTerminated() {
        return this.f9149.isTerminated();
    }

    @Override // java.util.concurrent.ExecutorService
    public void shutdown() {
        this.f9149.shutdown();
    }

    @Override // java.util.concurrent.ExecutorService
    public List<Runnable> shutdownNow() {
        return this.f9149.shutdownNow();
    }

    @Override // java.util.concurrent.ExecutorService
    public Future<?> submit(Runnable runnable) {
        return this.f9149.submit(runnable);
    }

    @Override // java.util.concurrent.ExecutorService
    public <T> Future<T> submit(Runnable runnable, T t) {
        return this.f9149.submit(runnable, t);
    }

    @Override // java.util.concurrent.ExecutorService
    public <T> Future<T> submit(Callable<T> callable) {
        return this.f9149.submit(callable);
    }

    public String toString() {
        return this.f9149.toString();
    }
}