Initial commit

sources/io/reactivex/internal/schedulers/TrampolineScheduler.java

@@ -0,0 +1,166 @@
+package io.reactivex.internal.schedulers;
+
+import io.reactivex.Scheduler;
+import io.reactivex.disposables.Disposable;
+import io.reactivex.disposables.Disposables;
+import io.reactivex.internal.disposables.EmptyDisposable;
+import io.reactivex.internal.functions.ObjectHelper;
+import io.reactivex.plugins.RxJavaPlugins;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/* loaded from: classes2.dex */
+public final class TrampolineScheduler extends Scheduler {
+    private static final TrampolineScheduler b = new TrampolineScheduler();
+
+    static final class SleepingRunnable implements Runnable {
+        private final Runnable a;
+        private final TrampolineWorker b;
+        private final long c;
+
+        SleepingRunnable(Runnable runnable, TrampolineWorker trampolineWorker, long j) {
+            this.a = runnable;
+            this.b = trampolineWorker;
+            this.c = j;
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            if (this.b.d) {
+                return;
+            }
+            long a = this.b.a(TimeUnit.MILLISECONDS);
+            long j = this.c;
+            if (j > a) {
+                try {
+                    Thread.sleep(j - a);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    RxJavaPlugins.b(e);
+                    return;
+                }
+            }
+            if (this.b.d) {
+                return;
+            }
+            this.a.run();
+        }
+    }
+
+    static final class TimedRunnable implements Comparable<TimedRunnable> {
+        final Runnable a;
+        final long b;
+        final int c;
+        volatile boolean d;
+
+        TimedRunnable(Runnable runnable, Long l, int i) {
+            this.a = runnable;
+            this.b = l.longValue();
+            this.c = i;
+        }
+
+        @Override // java.lang.Comparable
+        /* renamed from: a, reason: merged with bridge method [inline-methods] */
+        public int compareTo(TimedRunnable timedRunnable) {
+            int a = ObjectHelper.a(this.b, timedRunnable.b);
+            return a == 0 ? ObjectHelper.a(this.c, timedRunnable.c) : a;
+        }
+    }
+
+    static final class TrampolineWorker extends Scheduler.Worker implements Disposable {
+        final PriorityBlockingQueue<TimedRunnable> a = new PriorityBlockingQueue<>();
+        private final AtomicInteger b = new AtomicInteger();
+        final AtomicInteger c = new AtomicInteger();
+        volatile boolean d;
+
+        final class AppendToQueueTask implements Runnable {
+            final TimedRunnable a;
+
+            AppendToQueueTask(TimedRunnable timedRunnable) {
+                this.a = timedRunnable;
+            }
+
+            @Override // java.lang.Runnable
+            public void run() {
+                TimedRunnable timedRunnable = this.a;
+                timedRunnable.d = true;
+                TrampolineWorker.this.a.remove(timedRunnable);
+            }
+        }
+
+        TrampolineWorker() {
+        }
+
+        @Override // io.reactivex.Scheduler.Worker
+        public Disposable a(Runnable runnable) {
+            return a(runnable, a(TimeUnit.MILLISECONDS));
+        }
+
+        @Override // io.reactivex.disposables.Disposable
+        public void dispose() {
+            this.d = true;
+        }
+
+        @Override // io.reactivex.Scheduler.Worker
+        public Disposable a(Runnable runnable, long j, TimeUnit timeUnit) {
+            long a = a(TimeUnit.MILLISECONDS) + timeUnit.toMillis(j);
+            return a(new SleepingRunnable(runnable, this, a), a);
+        }
+
+        Disposable a(Runnable runnable, long j) {
+            if (this.d) {
+                return EmptyDisposable.INSTANCE;
+            }
+            TimedRunnable timedRunnable = new TimedRunnable(runnable, Long.valueOf(j), this.c.incrementAndGet());
+            this.a.add(timedRunnable);
+            if (this.b.getAndIncrement() == 0) {
+                int i = 1;
+                while (!this.d) {
+                    TimedRunnable poll = this.a.poll();
+                    if (poll == null) {
+                        i = this.b.addAndGet(-i);
+                        if (i == 0) {
+                            return EmptyDisposable.INSTANCE;
+                        }
+                    } else if (!poll.d) {
+                        poll.a.run();
+                    }
+                }
+                this.a.clear();
+                return EmptyDisposable.INSTANCE;
+            }
+            return Disposables.a(new AppendToQueueTask(timedRunnable));
+        }
+    }
+
+    TrampolineScheduler() {
+    }
+
+    public static TrampolineScheduler b() {
+        return b;
+    }
+
+    @Override // io.reactivex.Scheduler
+    public Scheduler.Worker a() {
+        return new TrampolineWorker();
+    }
+
+    @Override // io.reactivex.Scheduler
+    public Disposable a(Runnable runnable) {
+        RxJavaPlugins.a(runnable).run();
+        return EmptyDisposable.INSTANCE;
+    }
+
+    @Override // io.reactivex.Scheduler
+    public Disposable a(Runnable runnable, long j, TimeUnit timeUnit) {
+        try {
+            timeUnit.sleep(j);
+            RxJavaPlugins.a(runnable).run();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            RxJavaPlugins.b(e);
+        }
+        return EmptyDisposable.INSTANCE;
+    }
+}