Kickcash v16.1 - c.java 源代码

package com.microsoft.clarity.tk;

import com.microsoft.clarity.nq.f1;
import com.microsoft.clarity.nq.v0;
import com.microsoft.clarity.nq.w0;
import com.microsoft.clarity.tk.c;
import com.microsoft.clarity.tk.p0;
import com.microsoft.clarity.uk.g;
import java.net.ConnectException;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Locale;
import java.util.concurrent.TimeUnit;

abstract class c<ReqT, RespT, CallbackT extends p0> {
    private static final long n;
    private static final long o;
    private static final long p;
    private static final long q;
    private static final long r;
    private g.b a;
    private g.b b;
    private final u c;
    private final w0<ReqT, RespT> d;
    private final com.microsoft.clarity.uk.g f;
    private final g.d g;
    private final g.d h;
    private com.microsoft.clarity.nq.g<ReqT, RespT> k;
    final com.microsoft.clarity.uk.r l;
    final CallbackT m;
    private o0 i = o0.Initial;
    private long j = 0;
    private final c<ReqT, RespT, CallbackT>.b e = new b();

    class a {
        private final long a;

        a(long j) {
            this.a = j;
        }

        void a(Runnable runnable) {
            c.this.f.w();
            if (c.this.j == this.a) {
                runnable.run();
            } else {
                com.microsoft.clarity.uk.x.a(c.this.getClass().getSimpleName(), "stream callback skipped by CloseGuardedRunner.", new Object[0]);
            }
        }
    }

    class b implements Runnable {
        b() {
        }

        @Override
        public void run() {
            c.this.j();
        }
    }

    class C0179c implements f0<RespT> {
        private final c<ReqT, RespT, CallbackT>.a a;

        C0179c(c<ReqT, RespT, CallbackT>.a aVar) {
            this.a = aVar;
        }

        public void i(f1 f1Var) {
            if (f1Var.o()) {
                com.microsoft.clarity.uk.x.a(c.this.getClass().getSimpleName(), "(%x) Stream closed.", Integer.valueOf(System.identityHashCode(c.this)));
            } else {
                com.microsoft.clarity.uk.x.e(c.this.getClass().getSimpleName(), "(%x) Stream closed with status: %s.", Integer.valueOf(System.identityHashCode(c.this)), f1Var);
            }
            c.this.k(f1Var);
        }

        public void j(com.microsoft.clarity.nq.v0 v0Var) {
            if (com.microsoft.clarity.uk.x.c()) {
                HashMap hashMap = new HashMap();
                for (String str : v0Var.j()) {
                    if (m.e.contains(str.toLowerCase(Locale.ENGLISH))) {
                        hashMap.put(str, (String) v0Var.g(v0.g.e(str, com.microsoft.clarity.nq.v0.e)));
                    }
                }
                if (hashMap.isEmpty()) {
                    return;
                }
                com.microsoft.clarity.uk.x.a(c.this.getClass().getSimpleName(), "(%x) Stream received headers: %s", Integer.valueOf(System.identityHashCode(c.this)), hashMap);
            }
        }

        public void k(Object obj) {
            if (com.microsoft.clarity.uk.x.c()) {
                com.microsoft.clarity.uk.x.a(c.this.getClass().getSimpleName(), "(%x) Stream received: %s", Integer.valueOf(System.identityHashCode(c.this)), obj);
            }
            c.this.r(obj);
        }

        public void l() {
            com.microsoft.clarity.uk.x.a(c.this.getClass().getSimpleName(), "(%x) Stream is open", Integer.valueOf(System.identityHashCode(c.this)));
            c.this.s();
        }

        @Override
        public void a() {
            this.a.a(new Runnable() {
                @Override
                public final void run() {
                    c.C0179c.this.l();
                }
            });
        }

        @Override
        public void b(final f1 f1Var) {
            this.a.a(new Runnable() {
                @Override
                public final void run() {
                    c.C0179c.this.i(f1Var);
                }
            });
        }

        @Override
        public void c(final com.microsoft.clarity.nq.v0 v0Var) {
            this.a.a(new Runnable() {
                @Override
                public final void run() {
                    c.C0179c.this.j(v0Var);
                }
            });
        }

        @Override
        public void d(final RespT respt) {
            this.a.a(new Runnable() {
                @Override
                public final void run() {
                    c.C0179c.this.k(respt);
                }
            });
        }
    }

    static {
        TimeUnit timeUnit = TimeUnit.SECONDS;
        n = timeUnit.toMillis(1L);
        TimeUnit timeUnit2 = TimeUnit.MINUTES;
        o = timeUnit2.toMillis(1L);
        p = timeUnit2.toMillis(1L);
        q = timeUnit.toMillis(10L);
        r = timeUnit.toMillis(10L);
    }

    c(u uVar, w0<ReqT, RespT> w0Var, com.microsoft.clarity.uk.g gVar, g.d dVar, g.d dVar2, g.d dVar3, CallbackT callbackt) {
        this.c = uVar;
        this.d = w0Var;
        this.f = gVar;
        this.g = dVar2;
        this.h = dVar3;
        this.m = callbackt;
        this.l = new com.microsoft.clarity.uk.r(gVar, dVar, n, 1.5d, o);
    }

    private void g() {
        g.b bVar = this.a;
        if (bVar != null) {
            bVar.c();
            this.a = null;
        }
    }

    private void h() {
        g.b bVar = this.b;
        if (bVar != null) {
            bVar.c();
            this.b = null;
        }
    }

    private void i(o0 o0Var, f1 f1Var) {
        com.microsoft.clarity.uk.b.d(n(), "Only started streams should be closed.", new Object[0]);
        o0 o0Var2 = o0.Error;
        com.microsoft.clarity.uk.b.d(o0Var == o0Var2 || f1Var.o(), "Can't provide an error when not in an error state.", new Object[0]);
        this.f.w();
        if (m.h(f1Var)) {
            com.microsoft.clarity.uk.i0.p(new IllegalStateException("The Cloud Firestore client failed to establish a secure connection. This is likely a problem with your app, rather than with Cloud Firestore itself. See https://bit.ly/2XFpdma for instructions on how to enable TLS on Android 4.x devices.", f1Var.l()));
        }
        h();
        g();
        this.l.c();
        this.j++;
        f1.b m = f1Var.m();
        if (m == f1.b.Z) {
            this.l.f();
        } else if (m == f1.b.L0) {
            com.microsoft.clarity.uk.x.a(getClass().getSimpleName(), "(%x) Using maximum backoff delay to prevent overloading the backend.", Integer.valueOf(System.identityHashCode(this)));
            this.l.g();
        } else if (m == f1.b.T0 && this.i != o0.Healthy) {
            this.c.h();
        } else if (m == f1.b.R0 && ((f1Var.l() instanceof UnknownHostException) || (f1Var.l() instanceof ConnectException))) {
            this.l.h(r);
        }
        if (o0Var != o0Var2) {
            com.microsoft.clarity.uk.x.a(getClass().getSimpleName(), "(%x) Performing stream teardown", Integer.valueOf(System.identityHashCode(this)));
            w();
        }
        if (this.k != null) {
            if (f1Var.o()) {
                com.microsoft.clarity.uk.x.a(getClass().getSimpleName(), "(%x) Closing stream client-side", Integer.valueOf(System.identityHashCode(this)));
                this.k.b();
            }
            this.k = null;
        }
        this.i = o0Var;
        this.m.b(f1Var);
    }

    public void j() {
        if (m()) {
            i(o0.Initial, f1.f);
        }
    }

    public void o() {
        if (m()) {
            this.i = o0.Healthy;
        }
    }

    public void p() {
        o0 o0Var = this.i;
        com.microsoft.clarity.uk.b.d(o0Var == o0.Backoff, "State should still be backoff but was %s", o0Var);
        this.i = o0.Initial;
        u();
        com.microsoft.clarity.uk.b.d(n(), "Stream should have started", new Object[0]);
    }

    public void s() {
        this.i = o0.Open;
        this.m.a();
        if (this.a == null) {
            this.a = this.f.k(this.h, q, new Runnable() {
                @Override
                public final void run() {
                    c.this.o();
                }
            });
        }
    }

    private void t() {
        com.microsoft.clarity.uk.b.d(this.i == o0.Error, "Should only perform backoff in an error state", new Object[0]);
        this.i = o0.Backoff;
        this.l.b(new Runnable() {
            @Override
            public final void run() {
                c.this.p();
            }
        });
    }

    void k(f1 f1Var) {
        com.microsoft.clarity.uk.b.d(n(), "Can't handle server close on non-started stream!", new Object[0]);
        i(o0.Error, f1Var);
    }

    public void l() {
        com.microsoft.clarity.uk.b.d(!n(), "Can only inhibit backoff after in a stopped state", new Object[0]);
        this.f.w();
        this.i = o0.Initial;
        this.l.f();
    }

    public boolean m() {
        this.f.w();
        o0 o0Var = this.i;
        return o0Var == o0.Open || o0Var == o0.Healthy;
    }

    public boolean n() {
        this.f.w();
        o0 o0Var = this.i;
        return o0Var == o0.Starting || o0Var == o0.Backoff || m();
    }

    void q() {
        if (m() && this.b == null) {
            this.b = this.f.k(this.g, p, this.e);
        }
    }

    public abstract void r(RespT respt);

    public void u() {
        this.f.w();
        com.microsoft.clarity.uk.b.d(this.k == null, "Last call still set", new Object[0]);
        com.microsoft.clarity.uk.b.d(this.b == null, "Idle timer still set", new Object[0]);
        o0 o0Var = this.i;
        if (o0Var == o0.Error) {
            t();
            return;
        }
        com.microsoft.clarity.uk.b.d(o0Var == o0.Initial, "Already started", new Object[0]);
        this.k = this.c.m(this.d, new C0179c(new a(this.j)));
        this.i = o0.Starting;
    }

    public void v() {
        if (n()) {
            i(o0.Initial, f1.f);
        }
    }

    protected void x(ReqT reqt) {
        this.f.w();
        com.microsoft.clarity.uk.x.a(getClass().getSimpleName(), "(%x) Stream sending: %s", Integer.valueOf(System.identityHashCode(this)), reqt);
        h();
        this.k.d(reqt);
    }

    protected void w() {
    }
}