Initial commit

sources/io/reactivex/schedulers/SchedulerRunnableIntrospection.java

@@ -0,0 +1,5 @@
+package io.reactivex.schedulers;
+
+/* loaded from: classes2.dex */
+public interface SchedulerRunnableIntrospection {
+}

sources/io/reactivex/schedulers/Schedulers.java

@@ -0,0 +1,102 @@
+package io.reactivex.schedulers;
+
+import io.reactivex.Scheduler;
+import io.reactivex.internal.schedulers.ComputationScheduler;
+import io.reactivex.internal.schedulers.IoScheduler;
+import io.reactivex.internal.schedulers.NewThreadScheduler;
+import io.reactivex.internal.schedulers.SingleScheduler;
+import io.reactivex.internal.schedulers.TrampolineScheduler;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.Callable;
+
+/* loaded from: classes2.dex */
+public final class Schedulers {
+    static final Scheduler a;
+    static final Scheduler b;
+    static final Scheduler c;
+    static final Scheduler d;
+
+    static final class ComputationHolder {
+        static final Scheduler a = new ComputationScheduler();
+    }
+
+    static final class ComputationTask implements Callable<Scheduler> {
+        ComputationTask() {
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // java.util.concurrent.Callable
+        public Scheduler call() throws Exception {
+            return ComputationHolder.a;
+        }
+    }
+
+    static final class IOTask implements Callable<Scheduler> {
+        IOTask() {
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // java.util.concurrent.Callable
+        public Scheduler call() throws Exception {
+            return IoHolder.a;
+        }
+    }
+
+    static final class IoHolder {
+        static final Scheduler a = new IoScheduler();
+    }
+
+    static final class NewThreadHolder {
+        static final Scheduler a = new NewThreadScheduler();
+    }
+
+    static final class NewThreadTask implements Callable<Scheduler> {
+        NewThreadTask() {
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // java.util.concurrent.Callable
+        public Scheduler call() throws Exception {
+            return NewThreadHolder.a;
+        }
+    }
+
+    static final class SingleHolder {
+        static final Scheduler a = new SingleScheduler();
+    }
+
+    static final class SingleTask implements Callable<Scheduler> {
+        SingleTask() {
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // java.util.concurrent.Callable
+        public Scheduler call() throws Exception {
+            return SingleHolder.a;
+        }
+    }
+
+    static {
+        RxJavaPlugins.e(new SingleTask());
+        a = RxJavaPlugins.b(new ComputationTask());
+        b = RxJavaPlugins.c(new IOTask());
+        c = TrampolineScheduler.b();
+        d = RxJavaPlugins.d(new NewThreadTask());
+    }
+
+    public static Scheduler a() {
+        return RxJavaPlugins.a(a);
+    }
+
+    public static Scheduler b() {
+        return RxJavaPlugins.b(b);
+    }
+
+    public static Scheduler c() {
+        return RxJavaPlugins.c(d);
+    }
+
+    public static Scheduler d() {
+        return c;
+    }
+}

sources/io/reactivex/schedulers/Timed.java

@@ -0,0 +1,45 @@
+package io.reactivex.schedulers;
+
+import io.reactivex.internal.functions.ObjectHelper;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+public final class Timed<T> {
+    final T a;
+    final long b;
+    final TimeUnit c;
+
+    public Timed(T t, long j, TimeUnit timeUnit) {
+        this.a = t;
+        this.b = j;
+        ObjectHelper.a(timeUnit, "unit is null");
+        this.c = timeUnit;
+    }
+
+    public long a() {
+        return this.b;
+    }
+
+    public T b() {
+        return this.a;
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Timed)) {
+            return false;
+        }
+        Timed timed = (Timed) obj;
+        return ObjectHelper.a(this.a, timed.a) && this.b == timed.b && ObjectHelper.a(this.c, timed.c);
+    }
+
+    public int hashCode() {
+        T t = this.a;
+        int hashCode = t != null ? t.hashCode() : 0;
+        long j = this.b;
+        return (((hashCode * 31) + ((int) (j ^ (j >>> 31)))) * 31) + this.c.hashCode();
+    }
+
+    public String toString() {
+        return "Timed[time=" + this.b + ", unit=" + this.c + ", value=" + this.a + "]";
+    }
+}