Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/n3/a.java

@@ -0,0 +1,49 @@
+package n3;
+
+import android.net.ssl.SSLSockets;
+import f0.C0338b;
+import java.io.IOException;
+import java.util.List;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class a implements m {
+    @Override // n3.m
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return SSLSockets.isSupportedSocket(sslSocket);
+    }
+
+    @Override // n3.m
+    public final String b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        String applicationProtocol = sslSocket.getApplicationProtocol();
+        if (applicationProtocol == null ? true : Intrinsics.areEqual(applicationProtocol, "")) {
+            return null;
+        }
+        return applicationProtocol;
+    }
+
+    @Override // n3.m
+    public final boolean c() {
+        m3.n nVar = m3.n.f7829a;
+        return C0338b.s();
+    }
+
+    @Override // n3.m
+    public final void d(SSLSocket sslSocket, String str, List protocols) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        Intrinsics.checkNotNullParameter(protocols, "protocols");
+        try {
+            SSLSockets.setUseSessionTickets(sslSocket, true);
+            SSLParameters sSLParameters = sslSocket.getSSLParameters();
+            m3.n nVar = m3.n.f7829a;
+            sSLParameters.setApplicationProtocols((String[]) C0338b.g(protocols).toArray(new String[0]));
+            sslSocket.setSSLParameters(sSLParameters);
+        } catch (IllegalArgumentException e4) {
+            throw new IOException("Android internal error", e4);
+        }
+    }
+}

apk_decompiled/sources/n3/b.java

@@ -0,0 +1,50 @@
+package n3;
+
+import a.AbstractC0105a;
+import android.net.http.X509TrustManagerExtensions;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.List;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.X509TrustManager;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class b extends AbstractC0105a {
+
+    /* renamed from: c, reason: collision with root package name */
+    public final X509TrustManager f7867c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final X509TrustManagerExtensions f7868d;
+
+    public b(X509TrustManager trustManager, X509TrustManagerExtensions x509TrustManagerExtensions) {
+        Intrinsics.checkNotNullParameter(trustManager, "trustManager");
+        Intrinsics.checkNotNullParameter(x509TrustManagerExtensions, "x509TrustManagerExtensions");
+        this.f7867c = trustManager;
+        this.f7868d = x509TrustManagerExtensions;
+    }
+
+    public final boolean equals(Object obj) {
+        return (obj instanceof b) && ((b) obj).f7867c == this.f7867c;
+    }
+
+    public final int hashCode() {
+        return System.identityHashCode(this.f7867c);
+    }
+
+    @Override // a.AbstractC0105a
+    public final List i(String hostname, List chain) {
+        Intrinsics.checkNotNullParameter(chain, "chain");
+        Intrinsics.checkNotNullParameter(hostname, "hostname");
+        try {
+            List<X509Certificate> checkServerTrusted = this.f7868d.checkServerTrusted((X509Certificate[]) chain.toArray(new X509Certificate[0]), "RSA", hostname);
+            Intrinsics.checkNotNullExpressionValue(checkServerTrusted, "x509TrustManagerExtensio…ficates, \"RSA\", hostname)");
+            return checkServerTrusted;
+        } catch (CertificateException e4) {
+            SSLPeerUnverifiedException sSLPeerUnverifiedException = new SSLPeerUnverifiedException(e4.getMessage());
+            sSLPeerUnverifiedException.initCause(e4);
+            throw sSLPeerUnverifiedException;
+        }
+    }
+}

apk_decompiled/sources/n3/c.java

@@ -0,0 +1,38 @@
+package n3;
+
+import e3.F;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArraySet;
+import kotlin.collections.MapsKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public abstract class c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final CopyOnWriteArraySet f7869a = new CopyOnWriteArraySet();
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final Map f7870b;
+
+    static {
+        LinkedHashMap linkedHashMap = new LinkedHashMap();
+        Package r22 = F.class.getPackage();
+        String name = r22 != null ? r22.getName() : null;
+        if (name != null) {
+            linkedHashMap.put(name, "OkHttp");
+        }
+        String name2 = F.class.getName();
+        Intrinsics.checkNotNullExpressionValue(name2, "OkHttpClient::class.java.name");
+        linkedHashMap.put(name2, "okhttp.OkHttpClient");
+        String name3 = l3.g.class.getName();
+        Intrinsics.checkNotNullExpressionValue(name3, "Http2::class.java.name");
+        linkedHashMap.put(name3, "okhttp.Http2");
+        String name4 = h3.e.class.getName();
+        Intrinsics.checkNotNullExpressionValue(name4, "TaskRunner::class.java.name");
+        linkedHashMap.put(name4, "okhttp.TaskRunner");
+        linkedHashMap.put("okhttp3.mockwebserver.MockWebServer", "okhttp.MockWebServer");
+        f7870b = MapsKt.toMap(linkedHashMap);
+    }
+}

apk_decompiled/sources/n3/d.java

@@ -0,0 +1,72 @@
+package n3;
+
+import android.util.Log;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt;
+import kotlin.text.StringsKt__StringsKt;
+
+/* loaded from: classes3.dex */
+public final class d extends Handler {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final d f7871a = new Handler();
+
+    @Override // java.util.logging.Handler
+    public final void close() {
+    }
+
+    @Override // java.util.logging.Handler
+    public final void flush() {
+    }
+
+    @Override // java.util.logging.Handler
+    public final void publish(LogRecord record) {
+        int indexOf$default;
+        int min;
+        Intrinsics.checkNotNullParameter(record, "record");
+        CopyOnWriteArraySet copyOnWriteArraySet = c.f7869a;
+        String loggerName = record.getLoggerName();
+        Intrinsics.checkNotNullExpressionValue(loggerName, "record.loggerName");
+        int intValue = record.getLevel().intValue();
+        Level level = Level.INFO;
+        int i = intValue > level.intValue() ? 5 : record.getLevel().intValue() == level.intValue() ? 4 : 3;
+        String message = record.getMessage();
+        Intrinsics.checkNotNullExpressionValue(message, "record.message");
+        Throwable thrown = record.getThrown();
+        Intrinsics.checkNotNullParameter(loggerName, "loggerName");
+        Intrinsics.checkNotNullParameter(message, "message");
+        String str = (String) c.f7870b.get(loggerName);
+        if (str == null) {
+            str = StringsKt.take(loggerName, 23);
+        }
+        if (Log.isLoggable(str, i)) {
+            if (thrown != null) {
+                message = message + '\n' + Log.getStackTraceString(thrown);
+            }
+            int length = message.length();
+            int i4 = 0;
+            while (i4 < length) {
+                indexOf$default = StringsKt__StringsKt.indexOf$default((CharSequence) message, '\n', i4, false, 4, (Object) null);
+                if (indexOf$default == -1) {
+                    indexOf$default = length;
+                }
+                while (true) {
+                    min = Math.min(indexOf$default, i4 + 4000);
+                    String substring = message.substring(i4, min);
+                    Intrinsics.checkNotNullExpressionValue(substring, "this as java.lang.String…ing(startIndex, endIndex)");
+                    Log.println(i, str, substring);
+                    if (min >= indexOf$default) {
+                        break;
+                    } else {
+                        i4 = min;
+                    }
+                }
+                i4 = min + 1;
+            }
+        }
+    }
+}

apk_decompiled/sources/n3/e.java

@@ -0,0 +1,34 @@
+package n3;
+
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsJVMKt;
+
+/* loaded from: classes3.dex */
+public final class e implements k {
+    @Override // n3.k
+    public final boolean a(SSLSocket sslSocket) {
+        boolean startsWith$default;
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        String name = sslSocket.getClass().getName();
+        Intrinsics.checkNotNullExpressionValue(name, "sslSocket.javaClass.name");
+        startsWith$default = StringsKt__StringsJVMKt.startsWith$default(name, "com.google.android.gms.org.conscrypt.", false, 2, null);
+        return startsWith$default;
+    }
+
+    @Override // n3.k
+    public final m b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        e eVar = f.f7872f;
+        Class<?> cls = sslSocket.getClass();
+        Class<?> cls2 = cls;
+        while (!Intrinsics.areEqual(cls2.getSimpleName(), "OpenSSLSocketImpl")) {
+            cls2 = cls2.getSuperclass();
+            if (cls2 == null) {
+                throw new AssertionError("No OpenSSLSocketImpl superclass of socket of type " + cls);
+            }
+        }
+        Intrinsics.checkNotNull(cls2);
+        return new f(cls2);
+    }
+}

apk_decompiled/sources/n3/f.java

@@ -0,0 +1,105 @@
+package n3;
+
+import com.google.firebase.remoteconfig.RemoteConfigConstants;
+import f0.C0338b;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.Charsets;
+
+/* loaded from: classes3.dex */
+public class f implements m {
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final e f7872f;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Class f7873a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Method f7874b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final Method f7875c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final Method f7876d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final Method f7877e;
+
+    /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Object, n3.e] */
+    static {
+        Intrinsics.checkNotNullParameter("com.google.android.gms.org.conscrypt", RemoteConfigConstants.RequestFieldKey.PACKAGE_NAME);
+        f7872f = new Object();
+    }
+
+    public f(Class sslSocketClass) {
+        Intrinsics.checkNotNullParameter(sslSocketClass, "sslSocketClass");
+        this.f7873a = sslSocketClass;
+        Method declaredMethod = sslSocketClass.getDeclaredMethod("setUseSessionTickets", Boolean.TYPE);
+        Intrinsics.checkNotNullExpressionValue(declaredMethod, "sslSocketClass.getDeclar…:class.javaPrimitiveType)");
+        this.f7874b = declaredMethod;
+        this.f7875c = sslSocketClass.getMethod("setHostname", String.class);
+        this.f7876d = sslSocketClass.getMethod("getAlpnSelectedProtocol", new Class[0]);
+        this.f7877e = sslSocketClass.getMethod("setAlpnProtocols", byte[].class);
+    }
+
+    @Override // n3.m
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return this.f7873a.isInstance(sslSocket);
+    }
+
+    @Override // n3.m
+    public final String b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        if (!a(sslSocket)) {
+            return null;
+        }
+        try {
+            byte[] bArr = (byte[]) this.f7876d.invoke(sslSocket, new Object[0]);
+            if (bArr != null) {
+                return new String(bArr, Charsets.UTF_8);
+            }
+            return null;
+        } catch (IllegalAccessException e4) {
+            throw new AssertionError(e4);
+        } catch (InvocationTargetException e5) {
+            Throwable cause = e5.getCause();
+            if ((cause instanceof NullPointerException) && Intrinsics.areEqual(((NullPointerException) cause).getMessage(), "ssl == null")) {
+                return null;
+            }
+            throw new AssertionError(e5);
+        }
+    }
+
+    @Override // n3.m
+    public final boolean c() {
+        boolean z3 = m3.c.f7810e;
+        return m3.c.f7810e;
+    }
+
+    @Override // n3.m
+    public final void d(SSLSocket sslSocket, String str, List protocols) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        Intrinsics.checkNotNullParameter(protocols, "protocols");
+        if (a(sslSocket)) {
+            try {
+                this.f7874b.invoke(sslSocket, Boolean.TRUE);
+                if (str != null) {
+                    this.f7875c.invoke(sslSocket, str);
+                }
+                Method method = this.f7877e;
+                m3.n nVar = m3.n.f7829a;
+                method.invoke(sslSocket, C0338b.j(protocols));
+            } catch (IllegalAccessException e4) {
+                throw new AssertionError(e4);
+            } catch (InvocationTargetException e5) {
+                throw new AssertionError(e5);
+            }
+        }
+    }
+}

apk_decompiled/sources/n3/g.java

@@ -0,0 +1,21 @@
+package n3;
+
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class g implements k {
+    @Override // n3.k
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        boolean z3 = m3.e.f7813d;
+        return false;
+    }
+
+    /* JADX WARN: Type inference failed for: r0v2, types: [n3.m, java.lang.Object] */
+    @Override // n3.k
+    public final m b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return new Object();
+    }
+}

apk_decompiled/sources/n3/h.java

@@ -0,0 +1,50 @@
+package n3;
+
+import f0.C0338b;
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+import org.bouncycastle.jsse.BCSSLParameters;
+import org.bouncycastle.jsse.BCSSLSocket;
+
+/* loaded from: classes3.dex */
+public final class h implements m {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final g f7878a = new Object();
+
+    @Override // n3.m
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return false;
+    }
+
+    @Override // n3.m
+    public final String b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        String applicationProtocol = ((BCSSLSocket) sslSocket).getApplicationProtocol();
+        if (applicationProtocol == null ? true : Intrinsics.areEqual(applicationProtocol, "")) {
+            return null;
+        }
+        return applicationProtocol;
+    }
+
+    @Override // n3.m
+    public final boolean c() {
+        boolean z3 = m3.e.f7813d;
+        return m3.e.f7813d;
+    }
+
+    @Override // n3.m
+    public final void d(SSLSocket sslSocket, String str, List protocols) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        Intrinsics.checkNotNullParameter(protocols, "protocols");
+        if (a(sslSocket)) {
+            BCSSLSocket bCSSLSocket = (BCSSLSocket) sslSocket;
+            BCSSLParameters parameters = bCSSLSocket.getParameters();
+            m3.n nVar = m3.n.f7829a;
+            parameters.setApplicationProtocols((String[]) C0338b.g(protocols).toArray(new String[0]));
+            bCSSLSocket.setParameters(parameters);
+        }
+    }
+}

apk_decompiled/sources/n3/i.java

@@ -0,0 +1,21 @@
+package n3;
+
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+import org.conscrypt.Conscrypt;
+
+/* loaded from: classes3.dex */
+public final class i implements k {
+    @Override // n3.k
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return m3.h.f7816d && Conscrypt.isConscrypt(sslSocket);
+    }
+
+    /* JADX WARN: Type inference failed for: r0v2, types: [n3.m, java.lang.Object] */
+    @Override // n3.k
+    public final m b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return new Object();
+    }
+}

apk_decompiled/sources/n3/j.java

@@ -0,0 +1,46 @@
+package n3;
+
+import f0.C0338b;
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+import org.conscrypt.Conscrypt;
+
+/* loaded from: classes3.dex */
+public final class j implements m {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final i f7879a = new Object();
+
+    @Override // n3.m
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return Conscrypt.isConscrypt(sslSocket);
+    }
+
+    @Override // n3.m
+    public final String b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        if (a(sslSocket)) {
+            return Conscrypt.getApplicationProtocol(sslSocket);
+        }
+        return null;
+    }
+
+    @Override // n3.m
+    public final boolean c() {
+        boolean z3 = m3.h.f7816d;
+        return m3.h.f7816d;
+    }
+
+    @Override // n3.m
+    public final void d(SSLSocket sslSocket, String str, List protocols) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        Intrinsics.checkNotNullParameter(protocols, "protocols");
+        if (a(sslSocket)) {
+            Conscrypt.setUseSessionTickets(sslSocket, true);
+            m3.n nVar = m3.n.f7829a;
+            Conscrypt.setApplicationProtocols(sslSocket, (String[]) C0338b.g(protocols).toArray(new String[0]));
+        }
+    }
+}

apk_decompiled/sources/n3/k.java

@@ -0,0 +1,10 @@
+package n3;
+
+import javax.net.ssl.SSLSocket;
+
+/* loaded from: classes3.dex */
+public interface k {
+    boolean a(SSLSocket sSLSocket);
+
+    m b(SSLSocket sSLSocket);
+}

apk_decompiled/sources/n3/l.java

@@ -0,0 +1,62 @@
+package n3;
+
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class l implements m {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final k f7880a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public m f7881b;
+
+    public l(k socketAdapterFactory) {
+        Intrinsics.checkNotNullParameter(socketAdapterFactory, "socketAdapterFactory");
+        this.f7880a = socketAdapterFactory;
+    }
+
+    @Override // n3.m
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return this.f7880a.a(sslSocket);
+    }
+
+    @Override // n3.m
+    public final String b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        m e4 = e(sslSocket);
+        if (e4 != null) {
+            return e4.b(sslSocket);
+        }
+        return null;
+    }
+
+    @Override // n3.m
+    public final boolean c() {
+        return true;
+    }
+
+    @Override // n3.m
+    public final void d(SSLSocket sslSocket, String str, List protocols) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        Intrinsics.checkNotNullParameter(protocols, "protocols");
+        m e4 = e(sslSocket);
+        if (e4 != null) {
+            e4.d(sslSocket, str, protocols);
+        }
+    }
+
+    public final synchronized m e(SSLSocket sSLSocket) {
+        try {
+            if (this.f7881b == null && this.f7880a.a(sSLSocket)) {
+                this.f7881b = this.f7880a.b(sSLSocket);
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return this.f7881b;
+    }
+}

apk_decompiled/sources/n3/m.java

@@ -0,0 +1,15 @@
+package n3;
+
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+
+/* loaded from: classes3.dex */
+public interface m {
+    boolean a(SSLSocket sSLSocket);
+
+    String b(SSLSocket sSLSocket);
+
+    boolean c();
+
+    void d(SSLSocket sSLSocket, String str, List list);
+}

apk_decompiled/sources/n3/n.java

@@ -0,0 +1,8 @@
+package n3;
+
+/* loaded from: classes3.dex */
+public final class n extends f {
+
+    /* renamed from: g, reason: collision with root package name */
+    public static final /* synthetic */ int f7882g = 0;
+}