Daniel Elliott
c080f0d97f
- Added realracing3-community.apk (71.57 MB) - Removed 32-bit support (armeabi-v7a) - Only includes arm64-v8a libraries - Decompiled source code included - Added README-community.md with analysis
486 lines
20 KiB
Java
486 lines
20 KiB
Java
package kotlinx.coroutines;
|
|
|
|
import androidx.concurrent.futures.AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0;
|
|
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
|
|
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
|
|
import kotlin.Unit;
|
|
import kotlin.coroutines.CoroutineContext;
|
|
import kotlin.jvm.internal.Intrinsics;
|
|
import kotlin.ranges.RangesKt___RangesKt;
|
|
import kotlinx.coroutines.Delay;
|
|
import kotlinx.coroutines.internal.LockFreeTaskQueueCore;
|
|
import kotlinx.coroutines.internal.Symbol;
|
|
import kotlinx.coroutines.internal.ThreadSafeHeap;
|
|
import kotlinx.coroutines.internal.ThreadSafeHeapNode;
|
|
|
|
/* loaded from: classes5.dex */
|
|
public abstract class EventLoopImplBase extends EventLoopImplPlatform implements Delay {
|
|
private volatile Object _delayed;
|
|
private volatile int _isCompleted = 0;
|
|
private volatile Object _queue;
|
|
public static final AtomicReferenceFieldUpdater _queue$FU = AtomicReferenceFieldUpdater.newUpdater(EventLoopImplBase.class, Object.class, "_queue");
|
|
public static final AtomicReferenceFieldUpdater _delayed$FU = AtomicReferenceFieldUpdater.newUpdater(EventLoopImplBase.class, Object.class, "_delayed");
|
|
public static final AtomicIntegerFieldUpdater _isCompleted$FU = AtomicIntegerFieldUpdater.newUpdater(EventLoopImplBase.class, "_isCompleted");
|
|
|
|
public static abstract class DelayedTask implements Runnable, Comparable, DisposableHandle, ThreadSafeHeapNode {
|
|
private volatile Object _heap;
|
|
public int index = -1;
|
|
public long nanoTime;
|
|
|
|
@Override // kotlinx.coroutines.internal.ThreadSafeHeapNode
|
|
public int getIndex() {
|
|
return this.index;
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.internal.ThreadSafeHeapNode
|
|
public void setIndex(int i) {
|
|
this.index = i;
|
|
}
|
|
|
|
public final boolean timeToExecute(long j) {
|
|
return j - this.nanoTime >= 0;
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.DisposableHandle
|
|
public final void dispose() {
|
|
Symbol symbol;
|
|
Symbol symbol2;
|
|
synchronized (this) {
|
|
try {
|
|
Object obj = this._heap;
|
|
symbol = EventLoop_commonKt.DISPOSED_TASK;
|
|
if (obj == symbol) {
|
|
return;
|
|
}
|
|
DelayedTaskQueue delayedTaskQueue = obj instanceof DelayedTaskQueue ? (DelayedTaskQueue) obj : null;
|
|
if (delayedTaskQueue != null) {
|
|
delayedTaskQueue.remove(this);
|
|
}
|
|
symbol2 = EventLoop_commonKt.DISPOSED_TASK;
|
|
this._heap = symbol2;
|
|
Unit unit = Unit.INSTANCE;
|
|
} catch (Throwable th) {
|
|
throw th;
|
|
}
|
|
}
|
|
}
|
|
|
|
public final int scheduleTask(long j, DelayedTaskQueue delayedTaskQueue, EventLoopImplBase eventLoopImplBase) {
|
|
Symbol symbol;
|
|
synchronized (this) {
|
|
Object obj = this._heap;
|
|
symbol = EventLoop_commonKt.DISPOSED_TASK;
|
|
if (obj == symbol) {
|
|
return 2;
|
|
}
|
|
synchronized (delayedTaskQueue) {
|
|
try {
|
|
DelayedTask delayedTask = (DelayedTask) delayedTaskQueue.firstImpl();
|
|
if (eventLoopImplBase.isCompleted()) {
|
|
return 1;
|
|
}
|
|
if (delayedTask == null) {
|
|
delayedTaskQueue.timeNow = j;
|
|
} else {
|
|
long j2 = delayedTask.nanoTime;
|
|
if (j2 - j < 0) {
|
|
j = j2;
|
|
}
|
|
if (j - delayedTaskQueue.timeNow > 0) {
|
|
delayedTaskQueue.timeNow = j;
|
|
}
|
|
}
|
|
long j3 = this.nanoTime;
|
|
long j4 = delayedTaskQueue.timeNow;
|
|
if (j3 - j4 < 0) {
|
|
this.nanoTime = j4;
|
|
}
|
|
delayedTaskQueue.addImpl(this);
|
|
return 0;
|
|
} catch (Throwable th) {
|
|
throw th;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public DelayedTask(long j) {
|
|
this.nanoTime = j;
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.internal.ThreadSafeHeapNode
|
|
public ThreadSafeHeap getHeap() {
|
|
Object obj = this._heap;
|
|
if (obj instanceof ThreadSafeHeap) {
|
|
return (ThreadSafeHeap) obj;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.internal.ThreadSafeHeapNode
|
|
public void setHeap(ThreadSafeHeap threadSafeHeap) {
|
|
Symbol symbol;
|
|
Object obj = this._heap;
|
|
symbol = EventLoop_commonKt.DISPOSED_TASK;
|
|
if (obj == symbol) {
|
|
throw new IllegalArgumentException("Failed requirement.".toString());
|
|
}
|
|
this._heap = threadSafeHeap;
|
|
}
|
|
|
|
@Override // java.lang.Comparable
|
|
public int compareTo(DelayedTask delayedTask) {
|
|
long j = this.nanoTime - delayedTask.nanoTime;
|
|
if (j > 0) {
|
|
return 1;
|
|
}
|
|
return j < 0 ? -1 : 0;
|
|
}
|
|
|
|
public String toString() {
|
|
return "Delayed[nanos=" + this.nanoTime + ']';
|
|
}
|
|
}
|
|
|
|
public DisposableHandle invokeOnTimeout(long j, Runnable runnable, CoroutineContext coroutineContext) {
|
|
return Delay.DefaultImpls.invokeOnTimeout(this, j, runnable, coroutineContext);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public final boolean isCompleted() {
|
|
return _isCompleted$FU.get(this) != 0;
|
|
}
|
|
|
|
public final void setCompleted(boolean z) {
|
|
_isCompleted$FU.set(this, z ? 1 : 0);
|
|
}
|
|
|
|
public boolean isEmpty() {
|
|
Symbol symbol;
|
|
if (!isUnconfinedQueueEmpty()) {
|
|
return false;
|
|
}
|
|
DelayedTaskQueue delayedTaskQueue = (DelayedTaskQueue) _delayed$FU.get(this);
|
|
if (delayedTaskQueue != null && !delayedTaskQueue.isEmpty()) {
|
|
return false;
|
|
}
|
|
Object obj = _queue$FU.get(this);
|
|
if (obj != null) {
|
|
if (obj instanceof LockFreeTaskQueueCore) {
|
|
return ((LockFreeTaskQueueCore) obj).isEmpty();
|
|
}
|
|
symbol = EventLoop_commonKt.CLOSED_EMPTY;
|
|
if (obj != symbol) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.EventLoop
|
|
public long getNextTime() {
|
|
DelayedTask delayedTask;
|
|
long coerceAtLeast;
|
|
Symbol symbol;
|
|
if (super.getNextTime() == 0) {
|
|
return 0L;
|
|
}
|
|
Object obj = _queue$FU.get(this);
|
|
if (obj != null) {
|
|
if (!(obj instanceof LockFreeTaskQueueCore)) {
|
|
symbol = EventLoop_commonKt.CLOSED_EMPTY;
|
|
return obj == symbol ? Long.MAX_VALUE : 0L;
|
|
}
|
|
if (!((LockFreeTaskQueueCore) obj).isEmpty()) {
|
|
return 0L;
|
|
}
|
|
}
|
|
DelayedTaskQueue delayedTaskQueue = (DelayedTaskQueue) _delayed$FU.get(this);
|
|
if (delayedTaskQueue == null || (delayedTask = (DelayedTask) delayedTaskQueue.peek()) == null) {
|
|
return Long.MAX_VALUE;
|
|
}
|
|
long j = delayedTask.nanoTime;
|
|
AbstractTimeSourceKt.getTimeSource();
|
|
coerceAtLeast = RangesKt___RangesKt.coerceAtLeast(j - System.nanoTime(), 0L);
|
|
return coerceAtLeast;
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.EventLoop
|
|
public void shutdown() {
|
|
ThreadLocalEventLoop.INSTANCE.resetEventLoop$kotlinx_coroutines_core();
|
|
setCompleted(true);
|
|
closeQueue();
|
|
while (processNextEvent() <= 0) {
|
|
}
|
|
rescheduleAllDelayed();
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.Delay
|
|
/* renamed from: scheduleResumeAfterDelay */
|
|
public void mo4149scheduleResumeAfterDelay(long j, CancellableContinuation cancellableContinuation) {
|
|
long delayToNanos = EventLoop_commonKt.delayToNanos(j);
|
|
if (delayToNanos < 4611686018427387903L) {
|
|
AbstractTimeSourceKt.getTimeSource();
|
|
long nanoTime = System.nanoTime();
|
|
DelayedResumeTask delayedResumeTask = new DelayedResumeTask(delayToNanos + nanoTime, cancellableContinuation);
|
|
schedule(nanoTime, delayedResumeTask);
|
|
CancellableContinuationKt.disposeOnCancellation(cancellableContinuation, delayedResumeTask);
|
|
}
|
|
}
|
|
|
|
public final DisposableHandle scheduleInvokeOnTimeout(long j, Runnable runnable) {
|
|
long delayToNanos = EventLoop_commonKt.delayToNanos(j);
|
|
if (delayToNanos < 4611686018427387903L) {
|
|
AbstractTimeSourceKt.getTimeSource();
|
|
long nanoTime = System.nanoTime();
|
|
DelayedRunnableTask delayedRunnableTask = new DelayedRunnableTask(delayToNanos + nanoTime, runnable);
|
|
schedule(nanoTime, delayedRunnableTask);
|
|
return delayedRunnableTask;
|
|
}
|
|
return NonDisposableHandle.INSTANCE;
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.EventLoop
|
|
public long processNextEvent() {
|
|
ThreadSafeHeapNode threadSafeHeapNode;
|
|
if (processUnconfinedEvent()) {
|
|
return 0L;
|
|
}
|
|
DelayedTaskQueue delayedTaskQueue = (DelayedTaskQueue) _delayed$FU.get(this);
|
|
if (delayedTaskQueue != null && !delayedTaskQueue.isEmpty()) {
|
|
AbstractTimeSourceKt.getTimeSource();
|
|
long nanoTime = System.nanoTime();
|
|
do {
|
|
synchronized (delayedTaskQueue) {
|
|
ThreadSafeHeapNode firstImpl = delayedTaskQueue.firstImpl();
|
|
threadSafeHeapNode = null;
|
|
if (firstImpl != null) {
|
|
DelayedTask delayedTask = (DelayedTask) firstImpl;
|
|
if (delayedTask.timeToExecute(nanoTime) && enqueueImpl(delayedTask)) {
|
|
threadSafeHeapNode = delayedTaskQueue.removeAtImpl(0);
|
|
}
|
|
}
|
|
}
|
|
} while (((DelayedTask) threadSafeHeapNode) != null);
|
|
}
|
|
Runnable dequeue = dequeue();
|
|
if (dequeue != null) {
|
|
dequeue.run();
|
|
return 0L;
|
|
}
|
|
return getNextTime();
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.CoroutineDispatcher
|
|
/* renamed from: dispatch */
|
|
public final void mo4148dispatch(CoroutineContext coroutineContext, Runnable runnable) {
|
|
enqueue(runnable);
|
|
}
|
|
|
|
public void enqueue(Runnable runnable) {
|
|
if (enqueueImpl(runnable)) {
|
|
unpark();
|
|
} else {
|
|
DefaultExecutor.INSTANCE.enqueue(runnable);
|
|
}
|
|
}
|
|
|
|
public final boolean enqueueImpl(Runnable runnable) {
|
|
Symbol symbol;
|
|
AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = _queue$FU;
|
|
while (true) {
|
|
Object obj = atomicReferenceFieldUpdater.get(this);
|
|
if (isCompleted()) {
|
|
return false;
|
|
}
|
|
if (obj == null) {
|
|
if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(_queue$FU, this, null, runnable)) {
|
|
return true;
|
|
}
|
|
} else if (obj instanceof LockFreeTaskQueueCore) {
|
|
Intrinsics.checkNotNull(obj, "null cannot be cast to non-null type kotlinx.coroutines.internal.LockFreeTaskQueueCore<java.lang.Runnable{ kotlinx.coroutines.RunnableKt.Runnable }>{ kotlinx.coroutines.EventLoop_commonKt.Queue<java.lang.Runnable{ kotlinx.coroutines.RunnableKt.Runnable }> }");
|
|
LockFreeTaskQueueCore lockFreeTaskQueueCore = (LockFreeTaskQueueCore) obj;
|
|
int addLast = lockFreeTaskQueueCore.addLast(runnable);
|
|
if (addLast == 0) {
|
|
return true;
|
|
}
|
|
if (addLast == 1) {
|
|
AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(_queue$FU, this, obj, lockFreeTaskQueueCore.next());
|
|
} else if (addLast == 2) {
|
|
return false;
|
|
}
|
|
} else {
|
|
symbol = EventLoop_commonKt.CLOSED_EMPTY;
|
|
if (obj == symbol) {
|
|
return false;
|
|
}
|
|
LockFreeTaskQueueCore lockFreeTaskQueueCore2 = new LockFreeTaskQueueCore(8, true);
|
|
Intrinsics.checkNotNull(obj, "null cannot be cast to non-null type java.lang.Runnable{ kotlinx.coroutines.RunnableKt.Runnable }");
|
|
lockFreeTaskQueueCore2.addLast((Runnable) obj);
|
|
lockFreeTaskQueueCore2.addLast(runnable);
|
|
if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(_queue$FU, this, obj, lockFreeTaskQueueCore2)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public final Runnable dequeue() {
|
|
Symbol symbol;
|
|
AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = _queue$FU;
|
|
while (true) {
|
|
Object obj = atomicReferenceFieldUpdater.get(this);
|
|
if (obj == null) {
|
|
return null;
|
|
}
|
|
if (obj instanceof LockFreeTaskQueueCore) {
|
|
Intrinsics.checkNotNull(obj, "null cannot be cast to non-null type kotlinx.coroutines.internal.LockFreeTaskQueueCore<java.lang.Runnable{ kotlinx.coroutines.RunnableKt.Runnable }>{ kotlinx.coroutines.EventLoop_commonKt.Queue<java.lang.Runnable{ kotlinx.coroutines.RunnableKt.Runnable }> }");
|
|
LockFreeTaskQueueCore lockFreeTaskQueueCore = (LockFreeTaskQueueCore) obj;
|
|
Object removeFirstOrNull = lockFreeTaskQueueCore.removeFirstOrNull();
|
|
if (removeFirstOrNull != LockFreeTaskQueueCore.REMOVE_FROZEN) {
|
|
return (Runnable) removeFirstOrNull;
|
|
}
|
|
AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(_queue$FU, this, obj, lockFreeTaskQueueCore.next());
|
|
} else {
|
|
symbol = EventLoop_commonKt.CLOSED_EMPTY;
|
|
if (obj == symbol) {
|
|
return null;
|
|
}
|
|
if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(_queue$FU, this, obj, null)) {
|
|
Intrinsics.checkNotNull(obj, "null cannot be cast to non-null type java.lang.Runnable{ kotlinx.coroutines.RunnableKt.Runnable }");
|
|
return (Runnable) obj;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public final void closeQueue() {
|
|
Symbol symbol;
|
|
Symbol symbol2;
|
|
AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = _queue$FU;
|
|
while (true) {
|
|
Object obj = atomicReferenceFieldUpdater.get(this);
|
|
if (obj == null) {
|
|
AtomicReferenceFieldUpdater atomicReferenceFieldUpdater2 = _queue$FU;
|
|
symbol = EventLoop_commonKt.CLOSED_EMPTY;
|
|
if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(atomicReferenceFieldUpdater2, this, null, symbol)) {
|
|
return;
|
|
}
|
|
} else {
|
|
if (obj instanceof LockFreeTaskQueueCore) {
|
|
((LockFreeTaskQueueCore) obj).close();
|
|
return;
|
|
}
|
|
symbol2 = EventLoop_commonKt.CLOSED_EMPTY;
|
|
if (obj == symbol2) {
|
|
return;
|
|
}
|
|
LockFreeTaskQueueCore lockFreeTaskQueueCore = new LockFreeTaskQueueCore(8, true);
|
|
Intrinsics.checkNotNull(obj, "null cannot be cast to non-null type java.lang.Runnable{ kotlinx.coroutines.RunnableKt.Runnable }");
|
|
lockFreeTaskQueueCore.addLast((Runnable) obj);
|
|
if (AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(_queue$FU, this, obj, lockFreeTaskQueueCore)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public final void schedule(long j, DelayedTask delayedTask) {
|
|
int scheduleImpl = scheduleImpl(j, delayedTask);
|
|
if (scheduleImpl == 0) {
|
|
if (shouldUnpark(delayedTask)) {
|
|
unpark();
|
|
}
|
|
} else if (scheduleImpl == 1) {
|
|
reschedule(j, delayedTask);
|
|
} else if (scheduleImpl != 2) {
|
|
throw new IllegalStateException("unexpected result".toString());
|
|
}
|
|
}
|
|
|
|
public final boolean shouldUnpark(DelayedTask delayedTask) {
|
|
DelayedTaskQueue delayedTaskQueue = (DelayedTaskQueue) _delayed$FU.get(this);
|
|
return (delayedTaskQueue != null ? (DelayedTask) delayedTaskQueue.peek() : null) == delayedTask;
|
|
}
|
|
|
|
public final int scheduleImpl(long j, DelayedTask delayedTask) {
|
|
if (isCompleted()) {
|
|
return 1;
|
|
}
|
|
AtomicReferenceFieldUpdater atomicReferenceFieldUpdater = _delayed$FU;
|
|
DelayedTaskQueue delayedTaskQueue = (DelayedTaskQueue) atomicReferenceFieldUpdater.get(this);
|
|
if (delayedTaskQueue == null) {
|
|
AbstractResolvableFuture$SafeAtomicHelper$$ExternalSyntheticBackportWithForwarding0.m(atomicReferenceFieldUpdater, this, null, new DelayedTaskQueue(j));
|
|
Object obj = atomicReferenceFieldUpdater.get(this);
|
|
Intrinsics.checkNotNull(obj);
|
|
delayedTaskQueue = (DelayedTaskQueue) obj;
|
|
}
|
|
return delayedTask.scheduleTask(j, delayedTaskQueue, this);
|
|
}
|
|
|
|
public final void resetAll() {
|
|
_queue$FU.set(this, null);
|
|
_delayed$FU.set(this, null);
|
|
}
|
|
|
|
public final void rescheduleAllDelayed() {
|
|
DelayedTask delayedTask;
|
|
AbstractTimeSourceKt.getTimeSource();
|
|
long nanoTime = System.nanoTime();
|
|
while (true) {
|
|
DelayedTaskQueue delayedTaskQueue = (DelayedTaskQueue) _delayed$FU.get(this);
|
|
if (delayedTaskQueue == null || (delayedTask = (DelayedTask) delayedTaskQueue.removeFirstOrNull()) == null) {
|
|
return;
|
|
} else {
|
|
reschedule(nanoTime, delayedTask);
|
|
}
|
|
}
|
|
}
|
|
|
|
public final class DelayedResumeTask extends DelayedTask {
|
|
public final CancellableContinuation cont;
|
|
|
|
public DelayedResumeTask(long j, CancellableContinuation cancellableContinuation) {
|
|
super(j);
|
|
this.cont = cancellableContinuation;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
this.cont.resumeUndispatched(EventLoopImplBase.this, Unit.INSTANCE);
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.EventLoopImplBase.DelayedTask
|
|
public String toString() {
|
|
return super.toString() + this.cont;
|
|
}
|
|
}
|
|
|
|
public static final class DelayedRunnableTask extends DelayedTask {
|
|
public final Runnable block;
|
|
|
|
public DelayedRunnableTask(long j, Runnable runnable) {
|
|
super(j);
|
|
this.block = runnable;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
this.block.run();
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.EventLoopImplBase.DelayedTask
|
|
public String toString() {
|
|
return super.toString() + this.block;
|
|
}
|
|
}
|
|
|
|
public static final class DelayedTaskQueue extends ThreadSafeHeap {
|
|
public long timeNow;
|
|
|
|
public DelayedTaskQueue(long j) {
|
|
this.timeNow = j;
|
|
}
|
|
}
|
|
}
|