package f.a.w.g;

import f.a.o;
import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ScheduledExecutorService;
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 n extends f.a.o {

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final i f4015b;

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final ScheduledExecutorService f4016c;

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

    /* JADX INFO: compiled from: SingleScheduler.java */
    public static final class a extends o.c {

        /* JADX INFO: renamed from: b, reason: collision with root package name */
        public final ScheduledExecutorService f4018b;

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

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

        public a(ScheduledExecutorService scheduledExecutorService) {
            this.f4018b = scheduledExecutorService;
        }

        @Override // f.a.o.c
        public f.a.t.b c(Runnable runnable, long j2, TimeUnit timeUnit) {
            if (this.f4020f) {
                return f.a.w.a.c.INSTANCE;
            }
            Objects.requireNonNull(runnable, "run is null");
            l lVar = new l(runnable, this.f4019e);
            this.f4019e.b(lVar);
            try {
                lVar.a(j2 <= 0 ? this.f4018b.submit((Callable) lVar) : this.f4018b.schedule((Callable) lVar, j2, timeUnit));
                return lVar;
            } catch (RejectedExecutionException e2) {
                dispose();
                f.a.y.a.C0(e2);
                return f.a.w.a.c.INSTANCE;
            }
        }

        @Override // f.a.t.b
        public void dispose() {
            if (this.f4020f) {
                return;
            }
            this.f4020f = true;
            this.f4019e.dispose();
        }
    }

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

    public n() {
        i iVar = f4015b;
        AtomicReference<ScheduledExecutorService> atomicReference = new AtomicReference<>();
        this.f4017d = atomicReference;
        atomicReference.lazySet(m.a(iVar));
    }

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

    @Override // f.a.o
    public f.a.t.b c(Runnable runnable, long j2, TimeUnit timeUnit) {
        Objects.requireNonNull(runnable, "run is null");
        k kVar = new k(runnable);
        try {
            kVar.a(j2 <= 0 ? this.f4017d.get().submit(kVar) : this.f4017d.get().schedule(kVar, j2, timeUnit));
            return kVar;
        } catch (RejectedExecutionException e2) {
            f.a.y.a.C0(e2);
            return f.a.w.a.c.INSTANCE;
        }
    }

    @Override // f.a.o
    public f.a.t.b d(Runnable runnable, long j2, long j3, TimeUnit timeUnit) {
        if (j3 > 0) {
            j jVar = new j(runnable);
            try {
                jVar.a(this.f4017d.get().scheduleAtFixedRate(jVar, j2, j3, timeUnit));
                return jVar;
            } catch (RejectedExecutionException e2) {
                f.a.y.a.C0(e2);
                return f.a.w.a.c.INSTANCE;
            }
        }
        ScheduledExecutorService scheduledExecutorService = this.f4017d.get();
        e eVar = new e(runnable, scheduledExecutorService);
        try {
            eVar.a(j2 <= 0 ? scheduledExecutorService.submit(eVar) : scheduledExecutorService.schedule(eVar, j2, timeUnit));
            return eVar;
        } catch (RejectedExecutionException e3) {
            f.a.y.a.C0(e3);
            return f.a.w.a.c.INSTANCE;
        }
    }
}