jsgt v4.8.1 - x.java 源代码

package qh;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.os.Build;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;

public final class x {

    public static final class a extends FilterInputStream {
        public boolean a;

        public a(InputStream inputStream) {
            super(inputStream);
        }

        @Override
        public final int read(byte[] bArr, int i, int i2) {
            int read;
            if (!this.a && (read = super.read(bArr, i, i2)) != -1) {
                return read;
            }
            this.a = true;
            return -1;
        }
    }

    static {
        Pattern.compile("([^\\s;]+)(.*)");
        Pattern.compile("(.*?charset\\s*=[^a-zA-Z0-9]*)([-a-zA-Z0-9]+)(.*)", 2);
        Pattern.compile("(\\<\\?xml\\s+.*?encoding\\s*=[^a-zA-Z0-9]*)([-a-zA-Z0-9]+)(.*)", 2);
    }

    public static NetworkInfo a(Context context) {
        try {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
            if (connectivityManager == null) {
                return null;
            }
            return connectivityManager.getActiveNetworkInfo();
        } catch (Exception unused) {
            return null;
        }
    }

    public static String b(Context context) {
        if (k(context)) {
            return "wifi";
        }
        try {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
            if (connectivityManager == null) {
                return "";
            }
            NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
            if (activeNetworkInfo == null) {
                return "";
            }
            return (activeNetworkInfo.getTypeName() + "-" + activeNetworkInfo.getSubtypeName() + "-" + activeNetworkInfo.getExtraInfo()).toLowerCase();
        } catch (Exception unused) {
            return "";
        }
    }

    public static String c(Context context, URL url) {
        a aVar;
        try {
            aVar = f(context, url);
        } catch (Throwable th2) {
            th = th2;
            aVar = null;
        }
        try {
            StringBuilder sb = new StringBuilder(1024);
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(aVar, "UTF-8"));
            char[] cArr = new char[4096];
            while (true) {
                int read = bufferedReader.read(cArr);
                if (-1 == read) {
                    v0.q(aVar);
                    return sb.toString();
                }
                sb.append(cArr, 0, read);
            }
        } catch (Throwable th3) {
            th = th3;
            v0.q(aVar);
            throw th;
        }
    }

    public static HttpURLConnection d(Context context, URL url) {
        URLConnection openConnection;
        if ("http".equals(url.getProtocol())) {
            boolean z = false;
            if ("CN".equalsIgnoreCase(((TelephonyManager) context.getSystemService("phone")).getSimCountryIso())) {
                try {
                    ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
                    if (connectivityManager != null) {
                        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
                        if (activeNetworkInfo != null) {
                            String extraInfo = activeNetworkInfo.getExtraInfo();
                            if (!TextUtils.isEmpty(extraInfo) && extraInfo.length() >= 3 && extraInfo.contains("ctwap")) {
                                z = true;
                            }
                        }
                    }
                } catch (Exception unused) {
                }
            }
            if (z) {
                openConnection = url.openConnection(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("10.0.0.200", 80)));
                return (HttpURLConnection) openConnection;
            }
        }
        openConnection = url.openConnection();
        return (HttpURLConnection) openConnection;
    }

    public static qh.v e(android.content.Context r6, java.lang.String r7, java.util.TreeMap r8) {
        throw new UnsupportedOperationException("Method not decompiled: qh.x.e(android.content.Context, java.lang.String, java.util.TreeMap):qh.v");
    }

    public static a f(Context context, URL url) {
        String str;
        if (context == null) {
            throw new IllegalArgumentException("context");
        }
        String url2 = url.toString();
        if (TextUtils.isEmpty(url2)) {
            str = null;
        } else {
            new String();
            str = String.format("%s&key=%s", url2, b7.b.j(String.format("%sbe988a6134bc8254465424e5a70ef037", url2)));
        }
        URL url3 = new URL(str);
        try {
            HttpURLConnection.setFollowRedirects(true);
            HttpURLConnection d = d(context, url3);
            d.setConnectTimeout(10000);
            d.setReadTimeout(15000);
            if (!TextUtils.isEmpty(null)) {
                d.setRequestProperty("User-Agent", null);
            }
            return new a(d.getInputStream());
        } catch (IOException e) {
            throw new IOException("IOException:".concat(e.getClass().getSimpleName()));
        } catch (Throwable th2) {
            throw new IOException(th2.getMessage());
        }
    }

    public static void g(String str, HashMap hashMap, File file) {
        if (!file.exists()) {
            return;
        }
        String name = file.getName();
        BufferedReader bufferedReader = null;
        try {
            try {
                HttpURLConnection httpURLConnection = (HttpURLConnection) new URL(str).openConnection();
                httpURLConnection.setReadTimeout(15000);
                httpURLConnection.setConnectTimeout(10000);
                httpURLConnection.setDoInput(true);
                httpURLConnection.setDoOutput(true);
                httpURLConnection.setUseCaches(false);
                httpURLConnection.setRequestMethod("POST");
                httpURLConnection.setRequestProperty("Connection", "Keep-Alive");
                httpURLConnection.setRequestProperty("Content-Type", "multipart/form-data;boundary=*****");
                for (Map.Entry entry : hashMap.entrySet()) {
                    httpURLConnection.setRequestProperty((String) entry.getKey(), (String) entry.getValue());
                }
                httpURLConnection.setFixedLengthStreamingMode(name.length() + 77 + ((int) file.length()) + 4);
                DataOutputStream dataOutputStream = new DataOutputStream(httpURLConnection.getOutputStream());
                dataOutputStream.writeBytes("--*****\r\n");
                dataOutputStream.writeBytes("Content-Disposition: form-data; name=\"file\";filename=\"" + file.getName() + "\"\r\n");
                dataOutputStream.writeBytes("\r\n");
                FileInputStream fileInputStream = new FileInputStream(file);
                try {
                    byte[] bArr = new byte[1024];
                    while (true) {
                        int read = fileInputStream.read(bArr);
                        if (read == -1) {
                            break;
                        }
                        dataOutputStream.write(bArr, 0, read);
                        dataOutputStream.flush();
                    }
                    dataOutputStream.writeBytes("\r\n");
                    dataOutputStream.writeBytes("--");
                    dataOutputStream.writeBytes("*****");
                    dataOutputStream.writeBytes("--");
                    dataOutputStream.writeBytes("\r\n");
                    dataOutputStream.flush();
                    StringBuffer stringBuffer = new StringBuffer();
                    BufferedReader bufferedReader2 = new BufferedReader(new InputStreamReader(new a(httpURLConnection.getInputStream())));
                    while (true) {
                        try {
                            String readLine = bufferedReader2.readLine();
                            if (readLine == null) {
                                v0.q(fileInputStream);
                                v0.q(bufferedReader2);
                                return;
                            }
                            stringBuffer.append(readLine);
                        } catch (IOException e) {
                            e = e;
                            bufferedReader = bufferedReader2;
                            throw new IOException("IOException:" + e.getClass().getSimpleName());
                        } catch (Throwable th2) {
                            th = th2;
                            bufferedReader = bufferedReader2;
                            throw new IOException(th.getMessage());
                        }
                    }
                } catch (IOException e2) {
                    e = e2;
                } catch (Throwable th3) {
                    th = th3;
                }
            } catch (Throwable th4) {
                v0.q(null);
                v0.q(hashMap);
                throw th4;
            }
        } catch (IOException e3) {
            e = e3;
        } catch (Throwable th5) {
            th = th5;
        }
    }

    public static boolean h(Context context) {
        int i = -1;
        try {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
            if (connectivityManager != null) {
                NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
                if (activeNetworkInfo != null) {
                    i = activeNetworkInfo.getType();
                }
            }
        } catch (Exception unused) {
        }
        return i >= 0;
    }

    public static boolean i(Context context) {
        boolean z;
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
        if (connectivityManager != null) {
            if (Build.VERSION.SDK_INT >= 23) {
                try {
                    NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(androidx.databinding.adapters.a.d(connectivityManager));
                    if (networkCapabilities != null) {
                        z = networkCapabilities.hasCapability(16);
                    }
                } catch (Exception unused) {
                }
            } else {
                z = h(context);
            }
            return z && j(context);
        }
        z = false;
        if (z) {
            return false;
        }
    }

    public static boolean j(Context context) {
        NetworkInfo networkInfo;
        try {
            networkInfo = ((ConnectivityManager) context.getSystemService("connectivity")).getActiveNetworkInfo();
        } catch (Exception unused) {
            networkInfo = null;
        }
        return networkInfo != null && networkInfo.isConnected();
    }

    public static boolean k(Context context) {
        try {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
            if (connectivityManager == null) {
                return false;
            }
            NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
            return activeNetworkInfo != null && 1 == activeNetworkInfo.getType();
        } catch (Exception unused) {
            return false;
        }
    }
}