Easycash v3.75.13 - DNSParseOPT.java 源代码

package com.lingyue.easycash.net.dns;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.text.TextUtils;
import androidx.annotation.Keep;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.WorkerThread;
import com.fintopia.lender.module.network.ServerApiConfig;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.lingyue.easycash.ECServerApiConfig;
import com.lingyue.easycash.EasyCashApplication;
import com.lingyue.easycash.activity.o2;
import com.lingyue.easycash.net.dns.DNSParseOPT;
import com.lingyue.easycash.net.dns.NetWorkOPTConfig;
import com.lingyue.idnbaselib.utils.EcActivityLifecycleCallback;
import com.lingyue.idnbaselib.utils.GsonUtil;
import com.lingyue.supertoolkit.customtools.CollectionUtils;
import com.lingyue.supertoolkit.resourcetools.ContextProvider;
import com.lingyue.supertoolkit.resourcetools.SharedPreferenceUtils;
import com.lingyue.supertoolkit.rxjavatools.RxUtil;
import com.open.sentryconfig.SentryConfig;
import com.open.sentryconfig.network.DNSParseType;
import com.open.sentryconfig.network.WrapDnsParse;
import io.reactivex.Flowable;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.schedulers.Schedulers;
import io.sentry.ISpan;
import io.sentry.ITransaction;
import io.sentry.Scope;
import io.sentry.ScopeCallback;
import io.sentry.Sentry;
import io.sentry.SpanStatus;
import java.io.Serializable;
import java.net.InetAddress;
import java.net.URL;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import kotlin.Pair;
import kotlin.Triple;
import okhttp3.Dns;
import org.reactivestreams.Publisher;

public class DNSParseOPT {
    private boolean a;
    private final Context b;
    private final Gson c;
    private final Map<String, PreLoadDNS> d;
    private final Map<String, InetAddress> e;
    private volatile boolean f;
    private volatile NetWorkOPTConfig.PreLoadDnsConfig g;
    final List<HostIpAddress> h;
    private Disposable i;
    private final Dns j;

    class AnonymousClass1 implements Dns {
        AnonymousClass1() {
        }

        public Pair b(String str, ITransaction iTransaction) throws UnknownHostException {
            return DNSParseOPT.this.L(str);
        }

        @NonNull
        public List<InetAddress> lookup(@NonNull final String str) throws UnknownHostException {
            return SentryConfig.x().l0(str, new WrapDnsParse() {
                @Override
                public final Pair a(ITransaction iTransaction) {
                    Pair b;
                    b = DNSParseOPT.AnonymousClass1.this.b(str, iTransaction);
                    return b;
                }
            });
        }
    }

    private static class HostIpAddress {
        String a;
        byte[] b;

        public HostIpAddress(@NonNull String str, @NonNull byte[] bArr) {
            this.a = str;
            this.b = bArr;
        }
    }

    private static class SingletonHolder {
        private static final DNSParseOPT a = new DNSParseOPT(null);

        private SingletonHolder() {
        }
    }

    DNSParseOPT(AnonymousClass1 anonymousClass1) {
        this();
    }

    public static Publisher A(Set set, Long l) throws Exception {
        return Flowable.I(set);
    }

    public static PreLoadDNS B(ITransaction iTransaction, NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig, String str) throws Exception {
        List list = null;
        ISpan y2 = !iTransaction.isFinished() ? iTransaction.y(str, "dns.parse.preParse") : null;
        long j = -1;
        try {
            list = Dns.a.lookup(str);
            j = TimeUnit.SECONDS.toMillis(30L) + System.currentTimeMillis() + TimeUnit.MINUTES.toMillis(preLoadDnsConfig.refreshInterval);
            if (y2 != null) {
                String str2 = "";
                if (!CollectionUtils.f(list)) {
                    str2 = GsonUtil.b().t(list) + "";
                }
                y2.l("result", str2);
                SpanStatus spanStatus = SpanStatus.OK;
                y2.o(spanStatus);
                iTransaction.a(str, spanStatus.name());
            }
        } catch (Exception e) {
            if (y2 != null) {
                iTransaction.a(str, e.getClass().getSimpleName());
                y2.o(SpanStatus.INTERNAL_ERROR);
            }
        }
        return new PreLoadDNS(str, list, j);
    }

    public static PreLoadDNS C(Throwable th) throws Exception {
        return new PreLoadDNS();
    }

    public static Publisher D(final ITransaction iTransaction, final NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig, String str) throws Exception {
        return Flowable.M(str).Q(Schedulers.d()).N(new Function() {
            public final Object apply(Object obj) {
                DNSParseOPT.PreLoadDNS B;
                B = DNSParseOPT.B(iTransaction, preLoadDnsConfig, (String) obj);
                return B;
            }
        }).W(new Function() {
            public final Object apply(Object obj) {
                DNSParseOPT.PreLoadDNS C;
                C = DNSParseOPT.C((Throwable) obj);
                return C;
            }
        });
    }

    public void E(PreLoadDNS preLoadDNS) throws Exception {
        if (preLoadDNS.isValid()) {
            this.d.put(preLoadDNS.host, preLoadDNS);
            this.e.put(preLoadDNS.host, preLoadDNS.preLoadAddress.get(0));
        }
    }

    public void F(NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig, NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig2) throws Exception {
        SharedPreferenceUtils.J(EasyCashApplication.getInstance(), "easy_cash_dns_pre_parse_config", this.c.t(preLoadDnsConfig));
    }

    public static void G(boolean z2, Scope scope) {
        scope.A("fallbackDNSEnable", z2 + "");
    }

    public static void H(NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig, Scope scope) {
        scope.A("preParseDNSEnable", preLoadDnsConfig.enable + "");
    }

    @SuppressLint({"CheckResult"})
    private void I() {
        this.e.putAll(r());
        final ITransaction C = Sentry.C("DNSParseOPT_loadConfigFromCache", "DNSParseOPT");
        Flowable.H(new Callable() {
            @Override
            public final Object call() {
                Triple v;
                v = DNSParseOPT.this.v(C);
                return v;
            }
        }).l0(Schedulers.c()).g0(new Consumer() {
            public final void accept(Object obj) {
                DNSParseOPT.this.w((Triple) obj);
            }
        }, new Consumer() {
            public final void accept(Object obj) {
                DNSParseOPT.this.x(C, (Throwable) obj);
            }
        });
    }

    @Nullable
    @WorkerThread
    private HashMap<String, InetAddress> J() {
        String s = SharedPreferenceUtils.s(this.b, "easy_cash_fall_back_dns", null);
        if (TextUtils.isEmpty(s)) {
            return null;
        }
        try {
            return (HashMap) new Gson().l(s, new TypeToken<HashMap<String, InetAddress>>() {
            }.e());
        } catch (Exception unused) {
            SharedPreferenceUtils.k(this.b, "easy_cash_fall_back_dns");
            return null;
        }
    }

    @WorkerThread
    private NetWorkOPTConfig.PreLoadDnsConfig K(NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig) {
        String s = SharedPreferenceUtils.s(this.b, "easy_cash_dns_pre_parse_config", null);
        if (TextUtils.isEmpty(s)) {
            return preLoadDnsConfig;
        }
        try {
            return (NetWorkOPTConfig.PreLoadDnsConfig) new Gson().k(s, NetWorkOPTConfig.PreLoadDnsConfig.class);
        } catch (Exception unused) {
            SharedPreferenceUtils.J(this.b, "easy_cash_dns_pre_parse_config", null);
            return preLoadDnsConfig;
        }
    }

    public Pair<DNSParseType, List<InetAddress>> L(@NonNull String str) throws UnknownHostException {
        PreLoadDNS preLoadDNS = this.d.get(str);
        if (this.g.enable && preLoadDNS != null && preLoadDNS.isValid()) {
            return new Pair<>(DNSParseType.HIT_CACHE, preLoadDNS.preLoadAddress);
        }
        try {
            return new Pair<>(DNSParseType.SYSTEM, Dns.a.lookup(str));
        } catch (UnknownHostException e) {
            if (!this.f || !this.e.containsKey(str)) {
                throw e;
            }
            ArrayList arrayList = new ArrayList();
            arrayList.add(this.e.get(str));
            return new Pair<>(DNSParseType.FALLBACK, arrayList);
        }
    }

    private String M(String str, String str2) {
        if (TextUtils.isEmpty(str)) {
            return str2;
        }
        try {
            return new URL(str).getHost();
        } catch (Exception e) {
            Sentry.h(e);
            return str2;
        }
    }

    private Set<String> N(List<String> list) {
        HashSet hashSet = new HashSet();
        hashSet.add(M(ECServerApiConfig.e().c(), "api.easycash.id"));
        hashSet.add(M(ServerApiConfig.d().c(), "finapi.easycash.id"));
        hashSet.add("event-tracking-api.easycash.id");
        hashSet.add("indoi18n-web-cdn.easycash.id");
        hashSet.add("www.easycash.id");
        hashSet.add("web.easycash.id");
        hashSet.add("indo-infra-config-admin-gray-service.easycash.id");
        if (!CollectionUtils.f(list)) {
            Iterator<String> it = list.iterator();
            while (it.hasNext()) {
                hashSet.add(it.next());
            }
        }
        return hashSet;
    }

    @SuppressLint({"CheckResult"})
    public void O(final NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig) {
        P();
        final Set<String> N = N(preLoadDnsConfig.preloadHosts);
        final ITransaction C = Sentry.C("DNSParsePREParse", "dns.parse.preParse");
        this.i = Flowable.K(0L, preLoadDnsConfig.getRefreshInterval(), TimeUnit.MINUTES).l0(Schedulers.c()).D(new Function() {
            public final Object apply(Object obj) {
                Publisher A;
                A = DNSParseOPT.A(N, (Long) obj);
                return A;
            }
        }).D(new Function() {
            public final Object apply(Object obj) {
                Publisher D;
                D = DNSParseOPT.D(C, preLoadDnsConfig, (String) obj);
                return D;
            }
        }).z(new Consumer() {
            public final void accept(Object obj) {
                DNSParseOPT.this.E((DNSParseOPT.PreLoadDNS) obj);
            }
        }).e(N.size()).Q(Schedulers.c()).g0(new Consumer() {
            public final void accept(Object obj) {
                DNSParseOPT.this.y(C, (List) obj);
            }
        }, new Consumer() {
            public final void accept(Object obj) {
                DNSParseOPT.z(C, (Throwable) obj);
            }
        });
    }

    public void P() {
        RxUtil.b(this.i);
        this.i = null;
    }

    @WorkerThread
    private void Q(Map<String, InetAddress> map) {
        if (CollectionUtils.g(map)) {
            return;
        }
        SharedPreferenceUtils.J(this.b, "easy_cash_fall_back_dns", new Gson().t(new HashMap(map)));
    }

    @SuppressLint({"CheckResult"})
    private void R(@NonNull final NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig) {
        Flowable.M(preLoadDnsConfig).l0(Schedulers.c()).g0(new Consumer() {
            public final void accept(Object obj) {
                DNSParseOPT.this.F(preLoadDnsConfig, (NetWorkOPTConfig.PreLoadDnsConfig) obj);
            }
        }, new o2());
    }

    private void T(final boolean z2, boolean z3) {
        if (!z3) {
            SharedPreferenceUtils.E(this.b, "easy_cash_dns_fallback_switch", z2);
        }
        this.f = z2;
        SentryConfig.x().v(new ScopeCallback() {
            public final void a(Scope scope) {
                DNSParseOPT.G(z2, scope);
            }
        });
    }

    private void U(final NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig, boolean z2) {
        Disposable disposable;
        if (preLoadDnsConfig == null) {
            return;
        }
        if (!z2) {
            R(preLoadDnsConfig);
        }
        SentryConfig.x().v(new ScopeCallback() {
            public final void a(Scope scope) {
                DNSParseOPT.H(NetWorkOPTConfig.PreLoadDnsConfig.this, scope);
            }
        });
        this.g = preLoadDnsConfig;
        if (!preLoadDnsConfig.enable) {
            P();
        } else if (!z2 || (disposable = this.i) == null || disposable.c()) {
            O(preLoadDnsConfig);
        }
    }

    private HashMap<String, InetAddress> r() {
        HashMap<String, InetAddress> hashMap = new HashMap<>();
        Iterator it = new ArrayList(this.h).iterator();
        while (it.hasNext()) {
            HostIpAddress hostIpAddress = (HostIpAddress) it.next();
            try {
                String str = hostIpAddress.a;
                hashMap.put(str, InetAddress.getByAddress(str, hostIpAddress.b));
            } catch (Exception e) {
                Sentry.h(e);
            }
        }
        return hashMap;
    }

    public static DNSParseOPT t() {
        return SingletonHolder.a;
    }

    public Triple v(ITransaction iTransaction) throws Exception {
        ISpan y2 = iTransaction.y("loadFallBackDNS", "loadFallBackDNS");
        boolean m = SharedPreferenceUtils.m(this.b, "easy_cash_dns_fallback_switch", true);
        HashMap<String, InetAddress> J = J();
        SpanStatus spanStatus = SpanStatus.OK;
        y2.o(spanStatus);
        ISpan y3 = iTransaction.y("loadPreDNSConfig", "loadPreDNSConfig");
        NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig = new NetWorkOPTConfig.PreLoadDnsConfig();
        NetWorkOPTConfig.PreLoadDnsConfig K = K(preLoadDnsConfig);
        if (K == preLoadDnsConfig) {
            y3.o(SpanStatus.INTERNAL_ERROR);
        } else {
            y3.o(spanStatus);
        }
        iTransaction.o(spanStatus);
        return new Triple(Boolean.valueOf(m), K, J);
    }

    public void w(Triple triple) throws Exception {
        if (!CollectionUtils.g((Map) triple.c())) {
            this.e.putAll((Map) triple.c());
        }
        T(((Boolean) triple.a()).booleanValue(), true);
        U((NetWorkOPTConfig.PreLoadDnsConfig) triple.b(), true);
    }

    public void x(ITransaction iTransaction, Throwable th) throws Exception {
        T(this.f, true);
        U(this.g, true);
        iTransaction.o(SpanStatus.INTERNAL_ERROR);
        Sentry.h(new RuntimeException("DNSParseOPT loadConfigFromCache error", th));
    }

    public void y(ITransaction iTransaction, List list) throws Exception {
        if (!iTransaction.isFinished()) {
            iTransaction.o(SpanStatus.OK);
        }
        Q(this.e);
    }

    public static void z(ITransaction iTransaction, Throwable th) throws Exception {
        if (iTransaction.isFinished()) {
            return;
        }
        iTransaction.o(SpanStatus.INTERNAL_ERROR);
    }

    @SuppressLint({"CheckResult"})
    public void S(NetWorkOPTConfig netWorkOPTConfig) {
        if (netWorkOPTConfig == null) {
            return;
        }
        T(netWorkOPTConfig.fallbackDnsIp, false);
        U(netWorkOPTConfig.preLoadDNS, false);
    }

    public Dns s() {
        return this.j;
    }

    public synchronized void u() {
        if (this.a) {
            return;
        }
        I();
        EcActivityLifecycleCallback.f.g(new EcActivityLifecycleCallback.AppVisibilityListener() {
            boolean a = true;

            @Override
            public void a(Activity activity) {
                if (DNSParseOPT.this.g.enable) {
                    DNSParseOPT.this.P();
                }
            }

            @Override
            public void b(Activity activity) {
                if (this.a) {
                    this.a = false;
                } else if (DNSParseOPT.this.g.enable) {
                    DNSParseOPT dNSParseOPT = DNSParseOPT.this;
                    dNSParseOPT.O(dNSParseOPT.g);
                }
            }
        });
        this.a = true;
    }

    @SuppressLint({"CheckResult"})
    private DNSParseOPT() {
        this.a = false;
        this.c = new Gson();
        this.d = new ConcurrentHashMap();
        this.e = new ConcurrentHashMap();
        this.f = true;
        this.g = new NetWorkOPTConfig.PreLoadDnsConfig();
        this.h = new ArrayList(Arrays.asList(new HostIpAddress("api.easycash.id", new byte[]{-109, -117, -116, -66}), new HostIpAddress("finapi.easycash.id", new byte[]{-109, -117, -116, -66}), new HostIpAddress("event-tracking-api.easycash.id", new byte[]{-109, -117, -116, -66})));
        this.j = new AnonymousClass1();
        this.b = ContextProvider.c();
        u();
    }

    @Keep
    static class PreLoadDNS implements Serializable {
        public String host;
        public List<InetAddress> preLoadAddress;
        public long validTime;

        public PreLoadDNS() {
            this.preLoadAddress = new ArrayList();
            this.host = "";
            this.validTime = -1L;
        }

        public boolean isValid() {
            return !CollectionUtils.f(this.preLoadAddress) && System.currentTimeMillis() < this.validTime;
        }

        public PreLoadDNS(String str, List<InetAddress> list, long j) {
            new ArrayList();
            this.preLoadAddress = list;
            this.host = str;
            this.validTime = j;
        }
    }
}