package i.a.n.g;

import i.a.h;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/* JADX INFO: compiled from: SingleScheduler.java */
/* JADX INFO: loaded from: classes.dex */
public final class l extends i.a.h {
    static final g c;
    static final ScheduledExecutorService d;
    final AtomicReference<ScheduledExecutorService> b;

    /* JADX INFO: compiled from: SingleScheduler.java */
    static final class a extends h.c {
        final ScheduledExecutorService b;
        final i.a.k.a d = new i.a.k.a();
        volatile boolean e;

        a(ScheduledExecutorService scheduledExecutorService) {
            this.b = scheduledExecutorService;
        }

        @Override // i.a.h.c
        public i.a.k.b c(Runnable runnable, long j2, TimeUnit timeUnit) {
            if (this.e) {
                return i.a.n.a.c.INSTANCE;
            }
            j jVar = new j(i.a.p.a.o(runnable), this.d);
            this.d.c(jVar);
            try {
                jVar.a(j2 <= 0 ? this.b.submit((Callable) jVar) : this.b.schedule((Callable) jVar, j2, timeUnit));
                return jVar;
            } catch (RejectedExecutionException e) {
                dispose();
                i.a.p.a.l(e);
                return i.a.n.a.c.INSTANCE;
            }
        }

        @Override // i.a.k.b
        public void dispose() {
            if (this.e) {
                return;
            }
            this.e = true;
            this.d.dispose();
        }

        @Override // i.a.k.b
        public boolean isDisposed() {
            return this.e;
        }
    }

    static {
        ScheduledExecutorService scheduledExecutorServiceNewScheduledThreadPool = Executors.newScheduledThreadPool(0);
        d = scheduledExecutorServiceNewScheduledThreadPool;
        scheduledExecutorServiceNewScheduledThreadPool.shutdown();
        c = new g("RxSingleScheduler", Math.max(1, Math.min(10, Integer.getInteger("rx2.single-priority", 5).intValue())), true);
    }

    public l() {
        this(c);
    }

    static ScheduledExecutorService e(ThreadFactory threadFactory) {
        return k.a(threadFactory);
    }

    @Override // i.a.h
    public h.c a() {
        return new a(this.b.get());
    }

    @Override // i.a.h
    public i.a.k.b c(Runnable runnable, long j2, TimeUnit timeUnit) {
        i iVar = new i(i.a.p.a.o(runnable));
        try {
            iVar.a(j2 <= 0 ? this.b.get().submit(iVar) : this.b.get().schedule(iVar, j2, timeUnit));
            return iVar;
        } catch (RejectedExecutionException e) {
            i.a.p.a.l(e);
            return i.a.n.a.c.INSTANCE;
        }
    }

    @Override // i.a.h
    public i.a.k.b d(Runnable runnable, long j2, long j3, TimeUnit timeUnit) {
        Runnable runnableO = i.a.p.a.o(runnable);
        if (j3 > 0) {
            h hVar = new h(runnableO);
            try {
                hVar.a(this.b.get().scheduleAtFixedRate(hVar, j2, j3, timeUnit));
                return hVar;
            } catch (RejectedExecutionException e) {
                i.a.p.a.l(e);
                return i.a.n.a.c.INSTANCE;
            }
        }
        ScheduledExecutorService scheduledExecutorService = this.b.get();
        c cVar = new c(runnableO, scheduledExecutorService);
        try {
            cVar.b(j2 <= 0 ? scheduledExecutorService.submit(cVar) : scheduledExecutorService.schedule(cVar, j2, timeUnit));
            return cVar;
        } catch (RejectedExecutionException e2) {
            i.a.p.a.l(e2);
            return i.a.n.a.c.INSTANCE;
        }
    }

    public l(ThreadFactory threadFactory) {
        AtomicReference<ScheduledExecutorService> atomicReference = new AtomicReference<>();
        this.b = atomicReference;
        atomicReference.lazySet(e(threadFactory));
    }
}