449 lines
14 KiB
Java
449 lines
14 KiB
Java
package s.a;
|
|
|
|
import d0.d0.f;
|
|
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
|
|
import java.util.concurrent.locks.LockSupport;
|
|
import kotlin.Unit;
|
|
import kotlin.coroutines.CoroutineContext;
|
|
import kotlinx.coroutines.CancellableContinuation;
|
|
import s.a.a.m;
|
|
import s.a.a.t;
|
|
import s.a.a.v;
|
|
import s.a.a.w;
|
|
/* compiled from: EventLoop.common.kt */
|
|
public abstract class q0 extends r0 implements g0 {
|
|
public static final AtomicReferenceFieldUpdater l = AtomicReferenceFieldUpdater.newUpdater(q0.class, Object.class, "_queue");
|
|
public static final AtomicReferenceFieldUpdater m = AtomicReferenceFieldUpdater.newUpdater(q0.class, Object.class, "_delayed");
|
|
public volatile Object _delayed = null;
|
|
public volatile int _isCompleted = 0;
|
|
public volatile Object _queue = null;
|
|
|
|
/* compiled from: EventLoop.common.kt */
|
|
public final class a extends c {
|
|
public final CancellableContinuation<Unit> l;
|
|
|
|
/* JADX DEBUG: Multi-variable search result rejected for r4v0, resolved type: kotlinx.coroutines.CancellableContinuation<? super kotlin.Unit> */
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
public a(long j, CancellableContinuation<? super Unit> cancellableContinuation) {
|
|
super(j);
|
|
this.l = cancellableContinuation;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
this.l.i(q0.this, Unit.a);
|
|
}
|
|
|
|
@Override // s.a.q0.c, java.lang.Object
|
|
public String toString() {
|
|
return super.toString() + this.l.toString();
|
|
}
|
|
}
|
|
|
|
/* compiled from: EventLoop.common.kt */
|
|
public static final class b extends c {
|
|
public final Runnable l;
|
|
|
|
public b(long j, Runnable runnable) {
|
|
super(j);
|
|
this.l = runnable;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
this.l.run();
|
|
}
|
|
|
|
@Override // s.a.q0.c, java.lang.Object
|
|
public String toString() {
|
|
return super.toString() + this.l.toString();
|
|
}
|
|
}
|
|
|
|
/* compiled from: EventLoop.common.kt */
|
|
public static abstract class c implements Runnable, Comparable<c>, l0, w {
|
|
public Object i;
|
|
public int j = -1;
|
|
public long k;
|
|
|
|
public c(long j) {
|
|
this.k = j;
|
|
}
|
|
|
|
/* JADX DEBUG: Method arguments types fixed to match base method, original types: [java.lang.Object] */
|
|
@Override // java.lang.Comparable
|
|
public int compareTo(c cVar) {
|
|
int i = ((this.k - cVar.k) > 0 ? 1 : ((this.k - cVar.k) == 0 ? 0 : -1));
|
|
if (i > 0) {
|
|
return 1;
|
|
}
|
|
return i < 0 ? -1 : 0;
|
|
}
|
|
|
|
@Override // s.a.l0
|
|
public final synchronized void dispose() {
|
|
Object obj = this.i;
|
|
t tVar = s0.a;
|
|
if (obj != tVar) {
|
|
if (!(obj instanceof d)) {
|
|
obj = null;
|
|
}
|
|
d dVar = (d) obj;
|
|
if (dVar != null) {
|
|
synchronized (dVar) {
|
|
if (i() != null) {
|
|
dVar.c(getIndex());
|
|
}
|
|
}
|
|
}
|
|
this.i = tVar;
|
|
}
|
|
}
|
|
|
|
@Override // s.a.a.w
|
|
public void f(int i) {
|
|
this.j = i;
|
|
}
|
|
|
|
@Override // s.a.a.w
|
|
public void g(v<?> vVar) {
|
|
if (this.i != s0.a) {
|
|
this.i = vVar;
|
|
return;
|
|
}
|
|
throw new IllegalArgumentException("Failed requirement.".toString());
|
|
}
|
|
|
|
@Override // s.a.a.w
|
|
public int getIndex() {
|
|
return this.j;
|
|
}
|
|
|
|
@Override // s.a.a.w
|
|
public v<?> i() {
|
|
Object obj = this.i;
|
|
if (!(obj instanceof v)) {
|
|
obj = null;
|
|
}
|
|
return (v) obj;
|
|
}
|
|
|
|
@Override // java.lang.Object
|
|
public String toString() {
|
|
StringBuilder L = c.d.b.a.a.L("Delayed[nanos=");
|
|
L.append(this.k);
|
|
L.append(']');
|
|
return L.toString();
|
|
}
|
|
}
|
|
|
|
/* compiled from: EventLoop.common.kt */
|
|
public static final class d extends v<c> {
|
|
public long b;
|
|
|
|
public d(long j) {
|
|
this.b = j;
|
|
}
|
|
}
|
|
|
|
public final void S(Runnable runnable) {
|
|
if (T(runnable)) {
|
|
Thread R = R();
|
|
if (Thread.currentThread() != R) {
|
|
LockSupport.unpark(R);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
c0.o.S(runnable);
|
|
}
|
|
|
|
public final boolean T(Runnable runnable) {
|
|
while (true) {
|
|
Object obj = this._queue;
|
|
if (this._isCompleted != 0) {
|
|
return false;
|
|
}
|
|
if (obj == null) {
|
|
if (l.compareAndSet(this, null, runnable)) {
|
|
return true;
|
|
}
|
|
} else if (obj instanceof m) {
|
|
m mVar = (m) obj;
|
|
int a2 = mVar.a(runnable);
|
|
if (a2 == 0) {
|
|
return true;
|
|
}
|
|
if (a2 == 1) {
|
|
l.compareAndSet(this, obj, mVar.d());
|
|
} else if (a2 == 2) {
|
|
return false;
|
|
}
|
|
} else if (obj == s0.b) {
|
|
return false;
|
|
} else {
|
|
m mVar2 = new m(8, true);
|
|
mVar2.a((Runnable) obj);
|
|
mVar2.a(runnable);
|
|
if (l.compareAndSet(this, obj, mVar2)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean U() {
|
|
s.a.a.b<i0<?>> bVar = this.k;
|
|
if (!(bVar == null || bVar.b == bVar.f2864c)) {
|
|
return false;
|
|
}
|
|
d dVar = (d) this._delayed;
|
|
if (dVar != null) {
|
|
if (!(dVar._size == 0)) {
|
|
return false;
|
|
}
|
|
}
|
|
Object obj = this._queue;
|
|
if (obj == null) {
|
|
return true;
|
|
}
|
|
return obj instanceof m ? ((m) obj).c() : obj == s0.b;
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:59:0x00a3 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:94:? A[RETURN, SYNTHETIC] */
|
|
public long V() {
|
|
long j;
|
|
c b2;
|
|
c cVar;
|
|
if (Q()) {
|
|
return 0;
|
|
}
|
|
d dVar = (d) this._delayed;
|
|
Runnable runnable = null;
|
|
boolean z2 = true;
|
|
if (dVar != null) {
|
|
if (!(dVar._size == 0)) {
|
|
long nanoTime = System.nanoTime();
|
|
do {
|
|
synchronized (dVar) {
|
|
c b3 = dVar.b();
|
|
if (b3 != null) {
|
|
c cVar2 = b3;
|
|
cVar = ((nanoTime - cVar2.k) > 0 ? 1 : ((nanoTime - cVar2.k) == 0 ? 0 : -1)) >= 0 ? T(cVar2) : false ? dVar.c(0) : null;
|
|
} else {
|
|
cVar = null;
|
|
}
|
|
}
|
|
} while (cVar != null);
|
|
}
|
|
}
|
|
while (true) {
|
|
Object obj = this._queue;
|
|
if (obj != null) {
|
|
if (!(obj instanceof m)) {
|
|
if (obj == s0.b) {
|
|
break;
|
|
} else if (l.compareAndSet(this, obj, null)) {
|
|
runnable = (Runnable) obj;
|
|
break;
|
|
}
|
|
} else {
|
|
m mVar = (m) obj;
|
|
Object e = mVar.e();
|
|
if (e != m.f2866c) {
|
|
runnable = (Runnable) e;
|
|
break;
|
|
}
|
|
l.compareAndSet(this, obj, mVar.d());
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (runnable != null) {
|
|
runnable.run();
|
|
return 0;
|
|
}
|
|
s.a.a.b<i0<?>> bVar = this.k;
|
|
if (bVar != null) {
|
|
if (bVar.b != bVar.f2864c) {
|
|
z2 = false;
|
|
}
|
|
if (!z2) {
|
|
j = 0;
|
|
if (j != 0) {
|
|
return 0;
|
|
}
|
|
Object obj2 = this._queue;
|
|
if (obj2 != null) {
|
|
if (!(obj2 instanceof m)) {
|
|
if (obj2 != s0.b) {
|
|
return 0;
|
|
}
|
|
return Long.MAX_VALUE;
|
|
} else if (!((m) obj2).c()) {
|
|
return 0;
|
|
}
|
|
}
|
|
d dVar2 = (d) this._delayed;
|
|
if (dVar2 != null) {
|
|
synchronized (dVar2) {
|
|
b2 = dVar2.b();
|
|
}
|
|
c cVar3 = b2;
|
|
if (cVar3 != null) {
|
|
return f.coerceAtLeast(cVar3.k - System.nanoTime(), 0);
|
|
}
|
|
}
|
|
return Long.MAX_VALUE;
|
|
}
|
|
}
|
|
j = Long.MAX_VALUE;
|
|
if (j != 0) {
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:35:0x0067 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:40:0x007e */
|
|
public final void W(long j, c cVar) {
|
|
char c2;
|
|
Thread R;
|
|
c b2;
|
|
boolean z2 = false;
|
|
c cVar2 = null;
|
|
if (this._isCompleted == 0) {
|
|
d dVar = (d) this._delayed;
|
|
if (dVar == null) {
|
|
m.compareAndSet(this, null, new d(j));
|
|
Object obj = this._delayed;
|
|
d0.z.d.m.checkNotNull(obj);
|
|
dVar = (d) obj;
|
|
}
|
|
synchronized (cVar) {
|
|
if (cVar.i == s0.a) {
|
|
c2 = 2;
|
|
} else {
|
|
synchronized (dVar) {
|
|
c b3 = dVar.b();
|
|
if (this._isCompleted == 0) {
|
|
if (b3 == null) {
|
|
dVar.b = j;
|
|
} else {
|
|
long j2 = b3.k;
|
|
if (j2 - j >= 0) {
|
|
j2 = j;
|
|
}
|
|
if (j2 - dVar.b > 0) {
|
|
dVar.b = j2;
|
|
}
|
|
}
|
|
long j3 = cVar.k;
|
|
long j4 = dVar.b;
|
|
if (j3 - j4 < 0) {
|
|
cVar.k = j4;
|
|
}
|
|
dVar.a(cVar);
|
|
c2 = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (c2 != 0) {
|
|
d dVar2 = (d) this._delayed;
|
|
if (dVar2 != null) {
|
|
synchronized (dVar2) {
|
|
b2 = dVar2.b();
|
|
}
|
|
cVar2 = b2;
|
|
}
|
|
if (cVar2 == cVar) {
|
|
z2 = true;
|
|
}
|
|
if (z2 && Thread.currentThread() != (R = R())) {
|
|
LockSupport.unpark(R);
|
|
return;
|
|
}
|
|
return;
|
|
} else if (c2 == 1) {
|
|
c0.o.W(j, cVar);
|
|
return;
|
|
} else if (c2 != 2) {
|
|
throw new IllegalStateException("unexpected result".toString());
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
c2 = 1;
|
|
if (c2 != 0) {
|
|
}
|
|
}
|
|
|
|
@Override // s.a.g0
|
|
public void b(long j, CancellableContinuation<? super Unit> cancellableContinuation) {
|
|
long a2 = s0.a(j);
|
|
if (a2 < 4611686018427387903L) {
|
|
long nanoTime = System.nanoTime();
|
|
a aVar = new a(a2 + nanoTime, cancellableContinuation);
|
|
cancellableContinuation.e(new m0(aVar));
|
|
W(nanoTime, aVar);
|
|
}
|
|
}
|
|
|
|
@Override // kotlinx.coroutines.CoroutineDispatcher
|
|
public final void dispatch(CoroutineContext coroutineContext, Runnable runnable) {
|
|
S(runnable);
|
|
}
|
|
|
|
@Override // s.a.p0
|
|
public void shutdown() {
|
|
c c2;
|
|
t1 t1Var = t1.b;
|
|
t1.a.set(null);
|
|
this._isCompleted = 1;
|
|
while (true) {
|
|
Object obj = this._queue;
|
|
if (obj == null) {
|
|
if (l.compareAndSet(this, null, s0.b)) {
|
|
break;
|
|
}
|
|
} else if (obj instanceof m) {
|
|
((m) obj).b();
|
|
break;
|
|
} else if (obj == s0.b) {
|
|
break;
|
|
} else {
|
|
m mVar = new m(8, true);
|
|
mVar.a((Runnable) obj);
|
|
if (l.compareAndSet(this, obj, mVar)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
do {
|
|
} while (V() <= 0);
|
|
long nanoTime = System.nanoTime();
|
|
while (true) {
|
|
d dVar = (d) this._delayed;
|
|
if (dVar != null) {
|
|
synchronized (dVar) {
|
|
c2 = dVar._size > 0 ? dVar.c(0) : null;
|
|
}
|
|
c cVar = c2;
|
|
if (cVar != null) {
|
|
c0.o.W(nanoTime, cVar);
|
|
} else {
|
|
return;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // s.a.g0
|
|
public l0 w(long j, Runnable runnable, CoroutineContext coroutineContext) {
|
|
return d0.a.w(j, runnable, coroutineContext);
|
|
}
|
|
}
|