Atlys v4.8.7 - f.java 源代码

package Aj;

import B0.A2;
import B0.d2;
import Bk.C0051t;
import Bk.f0;
import Bk.h0;
import Bk.q0;
import Bk.s0;
import C1.F;
import C1.k;
import D.P;
import D0.a1;
import D1.N;
import D1.O;
import Dk.A;
import Dk.C;
import Dk.C0124w;
import Dk.C0127x;
import Dk.C0130y;
import Dk.D;
import Dk.u2;
import F.m;
import Gh.r2;
import Ja.i;
import Oi.InterfaceC0347c1;
import Oi.j1;
import Oi.k1;
import Oi.l1;
import Oi.o1;
import On.K;
import On.z;
import R4.h;
import Sa.x;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.os.LocaleList;
import android.util.Log;
import android.util.LogPrinter;
import android.view.Choreographer;
import androidx.gridlayout.widget.GridLayout;
import bn.s;
import com.bumptech.glide.load.ImageHeaderParser;
import gh.C0807a;
import gn.m0;
import gn.x0;
import gn.z0;
import j$.util.concurrent.ConcurrentHashMap;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ConcurrentMap;
import kotlin.jvm.internal.l;
import w.q;
import xl.o;
import yp.j;

public final class f implements j, I.c, D, E1.c, InterfaceC0347c1, x, T4.a, Xa.a, T3.d, f5.b {
    public Object a;
    public Object b;
    public Object c;

    public f(Object obj, Object obj2, Object obj3) {
        this.a = obj;
        this.b = obj2;
        this.c = obj3;
    }

    public static Object[] A(Object[] objArr, int[] iArr) {
        int length = objArr.length;
        Class<?> componentType = objArr.getClass().getComponentType();
        LogPrinter logPrinter = GridLayout.i;
        int i = -1;
        for (int i2 : iArr) {
            i = Math.max(i, i2);
        }
        Object[] objArr2 = (Object[]) Array.newInstance(componentType, i + 1);
        for (int i3 = 0; i3 < length; i3++) {
            objArr2[iArr[i3]] = objArr[i3];
        }
        return objArr2;
    }

    public static Method M(Class cls, String str, Class[] clsArr) {
        if (cls == null) {
            return null;
        }
        try {
            if ((cls.getModifiers() & 1) == 0) {
                return M(cls.getSuperclass(), str, clsArr);
            }
            Method method = cls.getMethod(str, clsArr);
            try {
                if ((method.getModifiers() & 1) == 0) {
                    return null;
                }
            } catch (NoSuchMethodException unused) {
            }
            return method;
        } catch (NoSuchMethodException unused2) {
            return null;
        }
    }

    public static void R(f fVar, F f, C1.b bVar, Object obj) {
        k kVar = new k(f);
        synchronized (((tl.c) fVar.c)) {
            try {
                if (obj == null) {
                }
            } catch (Throwable th2) {
                throw th2;
            }
        }
    }

    public static final void x(f fVar, Network network, boolean z) {
        boolean z2;
        Network[] allNetworks = ((ConnectivityManager) fVar.b).getAllNetworks();
        l.g(allNetworks, "connectivityManager.allNetworks");
        int length = allNetworks.length;
        boolean z3 = false;
        int i = 0;
        while (true) {
            if (i >= length) {
                break;
            }
            Network it = allNetworks[i];
            if (l.c(it, network)) {
                z2 = z;
            } else {
                l.g(it, "it");
                NetworkCapabilities networkCapabilities = ((ConnectivityManager) fVar.b).getNetworkCapabilities(it);
                z2 = networkCapabilities != null && networkCapabilities.hasCapability(12);
            }
            if (z2) {
                z3 = true;
                break;
            }
            i++;
        }
        k5.e eVar = (k5.e) fVar.c;
        if (((X4.j) eVar.a.get()) == null) {
            eVar.a();
        } else {
            eVar.c = z3;
        }
    }

    public int B() {
        return ((long[]) this.c).length;
    }

    public void C() {
        Yc.a aVar = (Yc.a) this.c;
        aVar.v("Create eager instances ...");
        long nanoTime = System.nanoTime();
        fm.a aVar2 = (fm.a) this.b;
        HashMap hashMap = (HashMap) aVar2.b;
        Collection values = hashMap.values();
        l.g(values, "<get-values>(...)");
        fp.a[] aVarArr = (fp.a[]) values.toArray(new fp.a[0]);
        ArrayList<fp.a> s0 = o.s0(Arrays.copyOf(aVarArr, aVarArr.length));
        hashMap.clear();
        f fVar = (f) aVar2.a;
        f fVar2 = new f((Yc.a) fVar.c, ((kp.a) fVar.a).b, (ip.a) null);
        for (fp.a aVar3 : s0) {
            aVar3.getClass();
            V9.o oVar = new V9.o(aVar3, fVar2, 25);
            synchronized (aVar3) {
                oVar.invoke();
            }
            if (aVar3.b == null) {
                throw new IllegalStateException("Single instance created couldn't return value".toString());
            }
        }
        aVar.v("Created eager instances in " + Double.valueOf((System.nanoTime() - nanoTime) / 1000000.0d).doubleValue() + " ms");
    }

    public void D(Exception exc, String str, Object... objArr) {
        if (Q()) {
            String T = T(str, objArr);
            if (exc != null) {
                StringBuilder q = r2.q(T, "\n");
                StringWriter stringWriter = new StringWriter();
                exc.printStackTrace(new PrintWriter(stringWriter));
                q.append(stringWriter.toString());
                T = q.toString();
            }
            System.currentTimeMillis();
            ((Gg.b) this.a).l(1, (String) this.b, T);
        }
    }

    public Object E() {
        Object removeLast;
        synchronized (this.b) {
            removeLast = ((ArrayDeque) this.a).removeLast();
        }
        return removeLast;
    }

    public void F(P p) {
        J.b imageInfo = p.getImageInfo();
        m mVar = imageInfo instanceof J.b ? imageInfo.a : null;
        if ((mVar.e() == F.k.f || mVar.e() == F.k.d) && mVar.g() == F.j.e && mVar.f() == F.l.d) {
            G(p);
        } else {
            ((u.a) this.c).getClass();
            p.close();
        }
    }

    public void G(Object obj) {
        Object E;
        synchronized (this.b) {
            try {
                E = ((ArrayDeque) this.a).size() >= 3 ? E() : null;
                ((ArrayDeque) this.a).addFirst(obj);
            } catch (Throwable th2) {
                throw th2;
            }
        }
        if (((u.a) this.c) == null || E == null) {
            return;
        }
        ((P) E).close();
    }

    public void H(String str, Throwable th2) {
        StringBuilder sb = new StringBuilder();
        sb.append(T(str, new Object[0]));
        sb.append("\n");
        StringWriter stringWriter = new StringWriter();
        th2.printStackTrace(new PrintWriter(stringWriter));
        sb.append(stringWriter.toString());
        String sb2 = sb.toString();
        System.currentTimeMillis();
        ((Gg.b) this.a).l(4, (String) this.b, sb2);
    }

    public void I(Runnable runnable) {
        ((h) this.a).execute(runnable);
    }

    public C1.j J(F f, C1.b bVar) {
        C1.j jVar;
        bVar.getClass();
        k kVar = new k(f);
        synchronized (((tl.c) this.c)) {
            jVar = (C1.j) ((B1.b) this.a).a(kVar);
            if (jVar == null) {
                jVar = (C1.j) ((B1.c) this.b).a(kVar);
            }
        }
        return jVar;
    }

    public Method K(Class cls) {
        Class cls2;
        String str = (String) this.b;
        if (str == null) {
            return null;
        }
        Method M = M(cls, str, (Class[]) this.c);
        if (M == null || (cls2 = (Class) this.a) == null || cls2.isAssignableFrom(M.getReturnType())) {
            return M;
        }
        return null;
    }

    public List L(byte[] bArr) {
        List list = (List) ((ConcurrentMap) this.a).get(new Md.k(bArr));
        return list != null ? list : Collections.emptyList();
    }

    public Object N(Object[] objArr, Object obj) {
        Method K = K(obj.getClass());
        if (K == null) {
            throw new AssertionError("Method " + ((String) this.b) + " not supported for object " + obj);
        }
        try {
            return K.invoke(obj, objArr);
        } catch (IllegalAccessException e) {
            AssertionError assertionError = new AssertionError("Unexpectedly could not call: " + K);
            assertionError.initCause(e);
            throw assertionError;
        }
    }

    public void O(Object[] objArr, Object obj) {
        try {
            Method K = K(obj.getClass());
            if (K == null) {
                return;
            }
            try {
                K.invoke(obj, objArr);
            } catch (IllegalAccessException unused) {
            }
        } catch (InvocationTargetException e) {
            Throwable targetException = e.getTargetException();
            if (targetException instanceof RuntimeException) {
                throw ((RuntimeException) targetException);
            }
            AssertionError assertionError = new AssertionError("Unexpected exception");
            assertionError.initCause(targetException);
            throw assertionError;
        }
    }

    public Object P(Object[] objArr, Object obj) {
        try {
            return N(objArr, obj);
        } catch (InvocationTargetException e) {
            Throwable targetException = e.getTargetException();
            if (targetException instanceof RuntimeException) {
                throw ((RuntimeException) targetException);
            }
            AssertionError assertionError = new AssertionError("Unexpected exception");
            assertionError.initCause(targetException);
            throw assertionError;
        }
    }

    public boolean Q() {
        return q.n(((Gg.b) this.a).b) <= 0;
    }

    public java.lang.Object S(C1.F r6, C1.b r7, C1.f r8, Al.f r9) {
        throw new UnsupportedOperationException("Method not decompiled: Aj.f.S(C1.F, C1.b, C1.f, Al.f):java.lang.Object");
    }

    public String T(String str, Object... objArr) {
        if (objArr.length > 0) {
            str = String.format(str, objArr);
        }
        String str2 = (String) this.c;
        return str2 == null ? str : Ek.o.I(str2, " - ", str);
    }

    public void U(String str) {
        String T = T(str, new Object[0]);
        System.currentTimeMillis();
        ((Gg.b) this.a).l(3, (String) this.b, T);
    }

    @Override
    public z0 a() {
        return (z0) this.c;
    }

    @Override
    public x0 b() {
        return (z0) this.b;
    }

    @Override
    public D1.P c() {
        return (N) this.a;
    }

    public Object convert(Object obj) {
        Af.d dVar = (Af.d) this.c;
        dVar.getClass();
        z contentType = (z) this.a;
        l.h(contentType, "contentType");
        wn.a saver = (wn.a) this.b;
        l.h(saver, "saver");
        K create = K.create(contentType, ((wn.k) dVar.a).d(saver, obj));
        l.g(create, "create(...)");
        return create;
    }

    @Override
    public String d() {
        return "00012345";
    }

    @Override
    public String e(String rawValue) {
        l.h(rawValue, "rawValue");
        return rawValue;
    }

    @Override
    public void f(u2 u2Var) {
        A a = (A) this.c;
        tl.b.c();
        try {
            tl.c cVar = a.b;
            tl.b.a();
            tl.b.b();
            a.c.execute(new C0127x(this, u2Var));
            tl.b.a.getClass();
        } catch (Throwable th2) {
            try {
                tl.b.a.getClass();
            } catch (Throwable th3) {
                th2.addSuppressed(th3);
            }
            throw th2;
        }
    }

    @Override
    public int g() {
        return 0;
    }

    public E1.b getCurrent() {
        LocaleList g = A2.g();
        synchronized (((tl.c) this.c)) {
            try {
                E1.b bVar = (E1.b) this.b;
                if (bVar != null && g == ((LocaleList) this.a)) {
                    return bVar;
                }
                int a = A2.a(g);
                ArrayList arrayList = new ArrayList(a);
                for (int i = 0; i < a; i++) {
                    arrayList.add(new E1.a(A2.k(g, i)));
                }
                E1.b bVar2 = new E1.b(arrayList);
                this.a = g;
                this.b = bVar2;
                return bVar2;
            } catch (Throwable th2) {
                throw th2;
            }
        }
    }

    @Override
    public Integer getLabel() {
        return 2132018090;
    }

    public int h(long j) {
        long[] jArr = (long[]) this.c;
        int b = e3.z.b(jArr, j, false);
        if (b < jArr.length) {
            return b;
        }
        return -1;
    }

    public La.x i(La.x xVar, i iVar) {
        Drawable drawable = (Drawable) xVar.get();
        if (drawable instanceof BitmapDrawable) {
            return ((Xa.a) this.b).i(Sa.d.b((Ma.a) this.a, ((BitmapDrawable) drawable).getBitmap()), iVar);
        }
        if (drawable instanceof Wa.b) {
            return ((Xa.a) this.c).i(xVar, iVar);
        }
        return null;
    }

    @Override
    public void j(f0 f0Var) {
        A a = (A) this.c;
        tl.b.c();
        try {
            tl.c cVar = a.b;
            tl.b.a();
            tl.b.b();
            a.c.execute(new C0127x(this, f0Var));
            tl.b.a.getClass();
        } catch (Throwable th2) {
            try {
                tl.b.a.getClass();
            } catch (Throwable th3) {
                th2.addSuppressed(th3);
            }
            throw th2;
        }
    }

    @Override
    public String k(String userTyped) {
        l.h(userTyped, "userTyped");
        StringBuilder sb = new StringBuilder();
        int length = userTyped.length();
        for (int i = 0; i < length; i++) {
            char charAt = userTyped.charAt(i);
            if (Character.isDigit(charAt)) {
                sb.append(charAt);
            }
        }
        String sb2 = sb.toString();
        l.g(sb2, "filterTo(StringBuilder(), predicate).toString()");
        return bn.l.Y0(8, sb2);
    }

    public List l(long j) {
        ArrayList arrayList = new ArrayList();
        ArrayList arrayList2 = new ArrayList();
        int i = 0;
        while (true) {
            List list = (List) this.a;
            if (i >= list.size()) {
                break;
            }
            int i2 = i * 2;
            long[] jArr = (long[]) this.b;
            if (jArr[i2] <= j && j < jArr[i2 + 1]) {
                b4.d dVar = (b4.d) list.get(i);
                d3.b bVar = dVar.a;
                if (bVar.e == -3.4028235E38f) {
                    arrayList2.add(dVar);
                } else {
                    arrayList.add(bVar);
                }
            }
            i++;
        }
        Collections.sort(arrayList2, new Be.a(12));
        for (int i3 = 0; i3 < arrayList2.size(); i3++) {
            d3.a a = ((b4.d) arrayList2.get(i3)).a.a();
            a.e = (-1) - i3;
            a.f = 1;
            arrayList.add(a.a());
        }
        return arrayList;
    }

    public Bitmap m(BitmapFactory.Options options) {
        return BitmapFactory.decodeStream(new fb.a(fb.b.c((ByteBuffer) this.a)), null, options);
    }

    @Override
    public j1 o(String input) {
        l.h(input, "input");
        return bn.l.y0(input) ? k1.c : input.length() < 8 ? new l1(2132018091) : o1.b;
    }

    public void onFailure(Throwable th2) {
        boolean z = th2 instanceof CancellationException;
        P1.i iVar = (P1.i) this.c;
        if (z) {
            q2.g.g((String) null, iVar.b(new D.f0(d2.n(new StringBuilder(), (String) this.b, " cancelled."), th2)));
        } else {
            iVar.a((Object) null);
        }
    }

    public void onSuccess(Object obj) {
        I.f.e(true, (Ld.e) this.a, (P1.i) this.c, pp.h.I());
    }

    public Locale p(String str) {
        Locale forLanguageTag = Locale.forLanguageTag(str);
        if (l.c(forLanguageTag.toLanguageTag(), "und")) {
            Log.e("Locale", "The language tag " + str + " is not well-formed. Locale is resolved to Undetermined. Note that underscore '_' is not a valid subtag delimiter and must be replaced with '-'.");
        }
        return forLanguageTag;
    }

    @Override
    public String q(String displayName) {
        l.h(displayName, "displayName");
        return displayName;
    }

    public boolean r() {
        ConnectivityManager connectivityManager = (ConnectivityManager) this.b;
        Network[] allNetworks = connectivityManager.getAllNetworks();
        l.g(allNetworks, "connectivityManager.allNetworks");
        for (Network it : allNetworks) {
            l.g(it, "it");
            NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(it);
            if (networkCapabilities != null && networkCapabilities.hasCapability(12)) {
                return true;
            }
        }
        return false;
    }

    public int s() {
        ByteBuffer c = fb.b.c((ByteBuffer) this.a);
        Ma.f fVar = (Ma.f) this.c;
        if (c == null) {
            return -1;
        }
        List list = (List) this.b;
        int size = list.size();
        for (int i = 0; i < size; i++) {
            try {
                int a = ((Ja.e) list.get(i)).a(c, fVar);
                if (a != -1) {
                    return a;
                }
            } finally {
                fb.b.c(c);
            }
        }
        return -1;
    }

    public void shutdown() {
        ((ConnectivityManager) this.b).unregisterNetworkCallback((Ck.a) this.a);
    }

    @Override
    public int t() {
        return 8;
    }

    @Override
    public void u(s0 s0Var, C c, f0 f0Var) {
        tl.b.c();
        try {
            tl.c cVar = ((A) this.c).b;
            tl.b.a();
            y(s0Var, f0Var);
            tl.b.a.getClass();
        } catch (Throwable th2) {
            try {
                tl.b.a.getClass();
            } catch (Throwable th3) {
                th2.addSuppressed(th3);
            }
            throw th2;
        }
    }

    @Override
    public void v() {
        A a = (A) this.c;
        h0 h0Var = a.a.a;
        h0Var.getClass();
        if (h0Var == h0.a || h0Var == h0.b) {
            return;
        }
        tl.b.c();
        try {
            tl.b.a();
            tl.b.b();
            a.c.execute(new C0130y(this));
            tl.b.a.getClass();
        } catch (Throwable th2) {
            try {
                tl.b.a.getClass();
            } catch (Throwable th3) {
                th2.addSuppressed(th3);
            }
            throw th2;
        }
    }

    public ImageHeaderParser.ImageType w() {
        return Ag.g.G((List) this.b, fb.b.c((ByteBuffer) this.a));
    }

    public void y(s0 s0Var, f0 f0Var) {
        A a = (A) this.c;
        C0051t c0051t = a.i.a;
        a.f.getClass();
        if (c0051t == null) {
            c0051t = null;
        }
        if (s0Var.a == q0.CANCELLED && c0051t != null && c0051t.b()) {
            a1 a1Var = new a1(1);
            a.j.o(a1Var);
            s0Var = s0.h.a("ClientCall was cancelled at or after deadline. " + a1Var);
            f0Var = new f0();
        }
        tl.b.b();
        a.c.execute(new C0124w(this, s0Var, f0Var));
    }

    public long z(int i) {
        e3.b.f(i >= 0);
        long[] jArr = (long[]) this.c;
        e3.b.f(i < jArr.length);
        return jArr[i];
    }

    public f(String publishableKey, String str) {
        l.h(publishableKey, "publishableKey");
        this.b = str;
        if (!(!bn.l.y0(publishableKey))) {
            throw new IllegalArgumentException("Invalid Publishable Key: You must use a valid Stripe API key to make a Stripe API request. For more info, see https://stripe.com/docs/keys".toString());
        }
        if (!(!s.h0(publishableKey, "sk_", false))) {
            throw new IllegalArgumentException("Invalid Publishable Key: You are using a secret key instead of a publishable one. For more info, see https://stripe.com/docs/keys".toString());
        }
        this.a = publishableKey;
        this.c = C0807a.b.a();
    }

    public f(Yc.a logger, lp.a scope, ip.a aVar) {
        l.h(logger, "logger");
        l.h(scope, "scope");
        this.a = logger;
        this.b = scope;
        this.c = aVar;
    }

    public f(Ql.g argumentRange, Method[] methodArr, Method method) {
        l.h(argumentRange, "argumentRange");
        this.a = argumentRange;
        this.b = methodArr;
        this.c = method;
    }

    public f(I2.a aVar) {
        this.a = aVar;
        this.b = Choreographer.getInstance();
        this.c = new I2.b(this);
    }

    public void n() {
    }

    public f(int i) {
        switch (i) {
            case 7:
                this.c = new tl.c(8);
                break;
            case 9:
                this.a = O.a;
                this.b = m0.b((Object) null);
                this.c = m0.b(Boolean.FALSE);
                break;
            case 10:
                this.a = Collections.emptyList();
                this.b = Collections.emptyList();
                break;
            case 17:
                this.a = new LinkedHashSet();
                this.b = new LinkedHashMap();
                this.c = bn.a.a;
                break;
            case 25:
                this.a = new kp.a(this);
                this.b = new fm.a(this);
                new ConcurrentHashMap();
                new HashMap();
                gp.a aVar = gp.a.e;
                Yc.a aVar2 = new Yc.a(29);
                aVar2.b = aVar;
                this.c = aVar2;
                break;
            default:
                this.a = new B1.b();
                B1.c cVar = new B1.c();
                cVar.a = B1.a.a;
                cVar.b = B1.a.b;
                cVar.c = 0;
                this.b = cVar;
                this.c = new tl.c(8);
                break;
        }
    }
}