Mabilis Cash v1.19.4 - DNSParseOPT.java 源代码

package com.loans.mabiliscash.net.dns;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.Application;
import android.text.TextUtils;
import androidx.annotation.Keep;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.WorkerThread;
import com.fintopia.libCommon.common.CommonLifecycleCallback;
import com.fintopia.sentryconfig.SentryConfig;
import com.fintopia.sentryconfig.network.DNSParseType;
import com.fintopia.sentryconfig.network.WrapDnsParse;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.lingyue.supertoolkit.tools.customtools.CollectionUtils;
import com.lingyue.supertoolkit.tools.customtools.SharedPreferenceUtils;
import com.lingyue.supertoolkit.tools.rxjavatools.RxUtil;
import com.loans.mabiliscash.net.ECServerApiConfig;
import com.loans.mabiliscash.net.dns.DNSParseOPT;
import com.loans.mabiliscash.net.dns.NetWorkOPTConfig;
import com.loans.mabiliscash.utils.GsonUtil;
import com.veda.android.bananalibrary.common.BananaBaseApplication;
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;
import r.v;

public class DNSParseOPT {
    private boolean a;
    private final Application 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.v().Z(str, new WrapDnsParse() {
                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();

        private SingletonHolder() {
        }
    }

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

    public static PreLoadDNS B(ITransaction iTransaction, NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig, String str) throws Exception {
        List list = null;
        ISpan z2 = !iTransaction.f() ? iTransaction.z(str, "dns.parse.preParse") : null;
        long j = -1;
        try {
            list = Dns.SYSTEM.lookup(str);
            j = TimeUnit.SECONDS.toMillis(30L) + System.currentTimeMillis() + TimeUnit.MINUTES.toMillis(preLoadDnsConfig.refreshInterval);
            if (z2 != null) {
                String str2 = "";
                if (!CollectionUtils.a(list)) {
                    str2 = GsonUtil.a().t(list) + "";
                }
                z2.e("result", str2);
                SpanStatus spanStatus = SpanStatus.OK;
                z2.i(spanStatus);
                iTransaction.a(str, spanStatus.name());
            }
        } catch (Exception e) {
            if (z2 != null) {
                iTransaction.a(str, e.getClass().getSimpleName());
                z2.i(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.w(str).z(Schedulers.c()).x(new Function() {
            public final Object apply(Object obj) {
                DNSParseOPT.PreLoadDNS B;
                B = DNSParseOPT.B(iTransaction, preLoadDnsConfig, (String) obj);
                return B;
            }
        }).F(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.l(this.b, "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 B = Sentry.B("DNSParseOPT_loadConfigFromCache", "DNSParseOPT");
        Flowable.r(new Callable() {
            @Override
            public final Object call() {
                Triple v2;
                v2 = DNSParseOPT.this.v(B);
                return v2;
            }
        }).Q(Schedulers.b()).M(new Consumer() {
            public final void accept(Object obj) {
                DNSParseOPT.this.w((Triple) obj);
            }
        }, new Consumer() {
            public final void accept(Object obj) {
                DNSParseOPT.this.x(B, (Throwable) obj);
            }
        });
    }

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

    @WorkerThread
    private NetWorkOPTConfig.PreLoadDnsConfig K(NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig) {
        String f = SharedPreferenceUtils.f(this.b, "dns_pre_parse_config", null);
        if (TextUtils.isEmpty(f)) {
            return preLoadDnsConfig;
        }
        try {
            return (NetWorkOPTConfig.PreLoadDnsConfig) new Gson().k(f, NetWorkOPTConfig.PreLoadDnsConfig.class);
        } catch (Exception unused) {
            SharedPreferenceUtils.l(this.b, "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.c, preLoadDNS.preLoadAddress);
        }
        try {
            return new Pair<>(DNSParseType.a, Dns.SYSTEM.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.b, arrayList);
        }
    }

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

    private Set<String> N(List<String> list) {
        HashSet hashSet = new HashSet();
        hashSet.add(M(ECServerApiConfig.e().c(), "pa-api.mabiliscash.ph"));
        hashSet.add("event-tracking-api.mabiliscash.ph");
        hashSet.add("www.mabiliscash.ph");
        hashSet.add("mabiliscash.ph");
        if (!CollectionUtils.a(list)) {
            hashSet.addAll(list);
        }
        return hashSet;
    }

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

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

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

    @SuppressLint({"CheckResult"})
    private void R(@NonNull final NetWorkOPTConfig.PreLoadDnsConfig preLoadDnsConfig) {
        Flowable.w(preLoadDnsConfig).Q(Schedulers.b()).M(new Consumer() {
            public final void accept(Object obj) {
                DNSParseOPT.this.F(preLoadDnsConfig, (NetWorkOPTConfig.PreLoadDnsConfig) obj);
            }
        }, new v());
    }

    private void T(final boolean z2, boolean z3) {
        if (!z3) {
            SharedPreferenceUtils.h(this.b, "dns_fallback_switch", z2);
        }
        this.f = z2;
        SentryConfig.v().t(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.v().t(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.d()) {
            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.g(e);
            }
        }
        return hashMap;
    }

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

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

    public void w(Triple triple) throws Exception {
        if (!CollectionUtils.b((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.i(SpanStatus.INTERNAL_ERROR);
        Sentry.g(new RuntimeException("DNSParseOPT loadConfigFromCache error", th));
    }

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

    public static void z(ITransaction iTransaction, Throwable th) throws Exception {
        if (iTransaction.f()) {
            return;
        }
        iTransaction.i(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();
        CommonLifecycleCallback.a.c(new CommonLifecycleCallback.AppVisibilityListener() {
            boolean a = true;

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

            public void b(@NonNull 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("pa-api.mabiliscash.ph", new byte[]{8, -44, -99, -79}), new HostIpAddress("event-tracking-api.mabiliscash.ph", new byte[]{8, -44, -125, -16})));
        this.j = new AnonymousClass1();
        this.b = BananaBaseApplication.getApplication();
        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.a(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;
        }
    }
}