package f.a.n.g;

import f.a.g;
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 f.a.g {

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    static final g f910c;

    /* JADX INFO: renamed from: d, reason: collision with root package name */
    static final ScheduledExecutorService f911d;
    final AtomicReference<ScheduledExecutorService> b;

    /* JADX INFO: compiled from: SingleScheduler.java */
    static final class a extends g.c {
        final ScheduledExecutorService b;

        /* JADX INFO: renamed from: e, reason: collision with root package name */
        final f.a.k.a f912e = new f.a.k.a();

        /* JADX INFO: renamed from: f, reason: collision with root package name */
        volatile boolean f913f;

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

        @Override // f.a.g.c
        public f.a.k.b c(Runnable runnable, long j2, TimeUnit timeUnit) {
            if (this.f913f) {
                return f.a.n.a.c.INSTANCE;
            }
            j jVar = new j(f.a.p.a.o(runnable), this.f912e);
            this.f912e.c(jVar);
            try {
                jVar.a(j2 <= 0 ? this.b.submit((Callable) jVar) : this.b.schedule((Callable) jVar, j2, timeUnit));
                return jVar;
            } catch (RejectedExecutionException e2) {
                dispose();
                f.a.p.a.m(e2);
                return f.a.n.a.c.INSTANCE;
            }
        }

        @Override // f.a.k.b
        public void dispose() {
            if (this.f913f) {
                return;
            }
            this.f913f = true;
            this.f912e.dispose();
        }
    }

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

    public l() {
        this(f910c);
    }

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

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

    @Override // f.a.g
    public f.a.k.b c(Runnable runnable, long j2, TimeUnit timeUnit) {
        i iVar = new i(f.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 e2) {
            f.a.p.a.m(e2);
            return f.a.n.a.c.INSTANCE;
        }
    }

    @Override // f.a.g
    public f.a.k.b d(Runnable runnable, long j2, long j3, TimeUnit timeUnit) {
        Runnable runnableO = f.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 e2) {
                f.a.p.a.m(e2);
                return f.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 e3) {
            f.a.p.a.m(e3);
            return f.a.n.a.c.INSTANCE;
        }
    }

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