f.java 源代码

package o2;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.res.AssetManager;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Point;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.os.StatFs;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.view.WindowManager;
import android.view.inputmethod.InputMethodManager;
import androidx.core.content.FileProvider;
import androidx.exifinterface.media.ExifInterface;
import com.blankj.utilcode.util.Utils;
import com.blankj.utilcode.util.i;
import com.mbridge.msdk.playercommon.exoplayer2.source.chunk.ChunkedTrackBlacklistUtil;
import com.umeng.analytics.pro.bx;
import com.x8zs.ds2.R;
import com.x8zs.model.ServerApi;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.UnknownHostException;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.UUID;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import org.json.JSONArray;
import org.json.JSONException;

public class f {

    private static ServerApi.h0 f24613a;

    public static String A(Context context, String str) {
        try {
            return context.getPackageManager().getPackageInfo(str, 0).versionName;
        } catch (PackageManager.NameNotFoundException unused) {
            return "";
        }
    }

    public static synchronized ServerApi.h0 B(Context context) {
        ServerApi.h0 h0Var;
        String str;
        synchronized (f.class) {
            SharedPreferences sharedPreferences = context.getSharedPreferences("uuid", 0);
            String string = sharedPreferences.getString("uuid", "");
            if (TextUtils.isEmpty(string)) {
                string = UUID.randomUUID().toString();
                sharedPreferences.edit().putString("uuid", string).commit();
            }
            if (f24613a == null) {
                ServerApi.h0 h0Var2 = new ServerApi.h0();
                f24613a = h0Var2;
                h0Var2.f21626a = string;
                h0Var2.f21627b = "Android " + Build.VERSION.RELEASE + " " + Build.DISPLAY + " " + Build.VERSION.SDK_INT;
                f24613a.f21628c = Build.BRAND;
                f24613a.f21629d = Build.MODEL;
                f24613a.f21630e = Build.FINGERPRINT;
                f24613a.f21631f = C();
                f24613a.f21632g = K(context);
                f24613a.f21633h = L(context);
                ServerApi.h0 h0Var3 = f24613a;
                if (Q()) {
                    str = "64";
                } else {
                    str = "32";
                }
                h0Var3.f21634i = str;
                f24613a.f21639n = com.x8zs.app.a.b().f21547a;
                try {
                    f24613a.f21635j = i.b();
                    f24613a.f21636k = i.c();
                    f24613a.f21638m = i.a();
                    f24613a.f21637l = com.blankj.utilcode.util.b.b();
                } catch (Throwable th) {
                    th.printStackTrace();
                    ServerApi.h0 h0Var4 = f24613a;
                    h0Var4.f21635j = "";
                    h0Var4.f21636k = "";
                    h0Var4.f21638m = "";
                    h0Var4.f21637l = "";
                }
            }
            h0Var = f24613a;
        }
        return h0Var;
    }

    public static String C() {
        BufferedReader bufferedReader;
        Throwable th;
        FileReader fileReader;
        String readLine;
        try {
            fileReader = new FileReader("/proc/cpuinfo");
            try {
                bufferedReader = new BufferedReader(fileReader);
            } catch (Throwable th2) {
                bufferedReader = null;
                th = th2;
            }
        } catch (Throwable th3) {
            bufferedReader = null;
            th = th3;
            fileReader = null;
        }
        do {
            try {
                readLine = bufferedReader.readLine();
            } catch (Throwable th4) {
                th = th4;
                try {
                    th.printStackTrace();
                    c(bufferedReader);
                    c(fileReader);
                    return "";
                } finally {
                    c(bufferedReader);
                    c(fileReader);
                }
            }
            if (readLine == null) {
                bufferedReader.close();
                c(bufferedReader);
                c(fileReader);
                return "";
            }
        } while (!readLine.contains("Hardware"));
        return readLine.split(":")[1];
    }

    public static String D(String str) {
        try {
            return M(MessageDigest.getInstance("MD5").digest(str.getBytes()));
        } catch (Throwable th) {
            th.printStackTrace();
            return "";
        }
    }

    public static String E(byte[] bArr) {
        try {
            return M(MessageDigest.getInstance("MD5").digest(bArr));
        } catch (Throwable th) {
            th.printStackTrace();
            return "";
        }
    }

    public static double F(double d6) {
        return Math.round(d6 * 100.0d) / 100.0d;
    }

    public static long G() {
        try {
            StatFs statFs = new StatFs(Environment.getExternalStorageDirectory().getPath());
            return statFs.getAvailableBlocks() * statFs.getBlockSize();
        } catch (Throwable th) {
            th.printStackTrace();
            return -1L;
        }
    }

    public static int H() {
        WindowManager windowManager = (WindowManager) Utils.c().getSystemService("window");
        if (windowManager == null) {
            return -1;
        }
        Point point = new Point();
        windowManager.getDefaultDisplay().getRealSize(point);
        return point.x;
    }

    public static String I(String str) {
        Random random = new Random(System.currentTimeMillis());
        StringBuilder sb = new StringBuilder("com.x8zs.");
        for (int i6 = 0; i6 < 4; i6++) {
            sb.append((char) (random.nextInt(26) + 97));
        }
        return sb.toString();
    }

    public static String J(String str, String str2) {
        try {
            return (String) Class.forName("android.os.SystemProperties").getMethod("get", String.class, String.class).invoke(null, str, str2);
        } catch (Exception e6) {
            e6.printStackTrace();
            return str2;
        }
    }

    public static String K(Context context) {
        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionCode + "";
        } catch (PackageManager.NameNotFoundException e6) {
            e6.printStackTrace();
            return "";
        }
    }

    public static String L(Context context) {
        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
        } catch (PackageManager.NameNotFoundException e6) {
            e6.printStackTrace();
            return "";
        }
    }

    public static String M(byte[] bArr) {
        char[] cArr = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        char[] cArr2 = new char[bArr.length * 2];
        for (int i6 = 0; i6 < bArr.length; i6++) {
            byte b6 = bArr[i6];
            int i7 = i6 * 2;
            cArr2[i7] = cArr[(b6 >> 4) & 15];
            cArr2[i7 + 1] = cArr[b6 & bx.f20591m];
        }
        return new String(cArr2);
    }

    public static void N(Context context, View view) {
        ((InputMethodManager) context.getSystemService("input_method")).hideSoftInputFromWindow(view.getWindowToken(), 0);
    }

    public static boolean O(Activity activity) {
        if (activity == null || activity.isFinishing() || activity.isDestroyed()) {
            return true;
        }
        return false;
    }

    public static boolean P(PackageInfo packageInfo) {
        if (!"com.x8zs.shell.ProxyApplication".equals(packageInfo.applicationInfo.className) && !"com.x8zs.sandbox.app.SandboxApplication".equals(packageInfo.applicationInfo.className)) {
            return "08C424D49777D5A45AFB89A06DA6F798".equals(w(packageInfo));
        }
        return true;
    }

    private static boolean Q() {
        FileInputStream fileInputStream;
        BufferedReader bufferedReader;
        File file = new File("/proc/cpuinfo");
        if (file.exists()) {
            BufferedReader bufferedReader2 = null;
            try {
                fileInputStream = new FileInputStream(file);
                try {
                    bufferedReader = new BufferedReader(new InputStreamReader(fileInputStream), 512);
                } catch (Throwable unused) {
                }
                try {
                    String readLine = bufferedReader.readLine();
                    if (readLine != null && readLine.length() > 0) {
                        if (readLine.toLowerCase(Locale.US).contains("arch64")) {
                            try {
                                bufferedReader.close();
                            } catch (Exception e6) {
                                e6.printStackTrace();
                            }
                            try {
                                fileInputStream.close();
                                return true;
                            } catch (Exception e7) {
                                e7.printStackTrace();
                                return true;
                            }
                        }
                    }
                    try {
                        bufferedReader.close();
                    } catch (Exception e8) {
                        e8.printStackTrace();
                    }
                    try {
                        fileInputStream.close();
                    } catch (Exception e9) {
                        e9.printStackTrace();
                    }
                    return false;
                } catch (Throwable unused2) {
                    bufferedReader2 = bufferedReader;
                    if (bufferedReader2 != null) {
                        try {
                            bufferedReader2.close();
                        } catch (Exception e10) {
                            e10.printStackTrace();
                        }
                    }
                    if (fileInputStream != null) {
                        try {
                            fileInputStream.close();
                        } catch (Exception e11) {
                            e11.printStackTrace();
                        }
                    }
                    return false;
                }
            } catch (Throwable unused3) {
                fileInputStream = null;
            }
        }
        return false;
    }

    public static boolean R(Context context) {
        try {
            TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService("phone");
            String networkCountryIso = telephonyManager.getNetworkCountryIso();
            String simCountryIso = telephonyManager.getSimCountryIso();
            if (!TextUtils.isEmpty(networkCountryIso) || !TextUtils.isEmpty(simCountryIso)) {
                if (!"cn".equalsIgnoreCase(networkCountryIso)) {
                    if (!"cn".equalsIgnoreCase(simCountryIso)) {
                        return false;
                    }
                }
                return true;
            }
        } catch (Throwable th) {
            th.printStackTrace();
        }
        return "cn".equalsIgnoreCase(Locale.getDefault().getCountry());
    }

    public static boolean S(String str) {
        return Pattern.compile("^([a-zA-Z0-9_\\-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([a-zA-Z0-9\\-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$").matcher(str).matches();
    }

    public static boolean T(List<?> list) {
        if (list != null && list.size() != 0) {
            return false;
        }
        return true;
    }

    public static boolean U(List<?> list, List<?> list2) {
        if (list == null) {
            if (list2 == null) {
                return true;
            }
            return false;
        }
        if (list2 == null || list.size() != list2.size()) {
            return false;
        }
        int size = list.size();
        for (int i6 = 0; i6 < size; i6++) {
            Object obj = list.get(i6);
            Object obj2 = list2.get(i6);
            if (obj != null || obj2 != null) {
                if (obj == null && obj2 != null) {
                    return false;
                }
                if ((obj != null && obj2 == null) || !obj.equals(obj2)) {
                    return false;
                }
            }
        }
        return true;
    }

    public static boolean V(Context context, String str) {
        try {
            context.getPackageManager().getPackageInfo(str, 0);
            return true;
        } catch (Throwable unused) {
            return false;
        }
    }

    public static boolean W(Context context) {
        try {
            PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
            if (Math.abs(packageInfo.firstInstallTime - packageInfo.lastUpdateTime) <= ChunkedTrackBlacklistUtil.DEFAULT_TRACK_BLACKLIST_MS) {
                return false;
            }
            return true;
        } catch (Exception e6) {
            e6.printStackTrace();
            return false;
        }
    }

    public static boolean X(Context context) {
        NetworkInfo activeNetworkInfo;
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
        if (connectivityManager == null || (activeNetworkInfo = connectivityManager.getActiveNetworkInfo()) == null || activeNetworkInfo.getType() != 1) {
            return false;
        }
        return true;
    }

    public static String Y(List<String> list, String str) {
        StringBuilder sb = new StringBuilder();
        for (int i6 = 0; i6 < list.size(); i6++) {
            sb.append(list.get(i6));
            if (i6 != list.size() - 1) {
                sb.append(str);
            }
        }
        return sb.toString();
    }

    public static boolean Z(Context context) {
        Intent intent = new Intent();
        intent.setData(Uri.parse("mqqopensdkapi://bizAgent/qm/qr?url=http%3A%2F%2Fqm.qq.com%2Fcgi-bin%2Fqm%2Fqr%3Ffrom%3Dapp%26p%3Dandroid%26k%3DuBu4kcrLUHUdPw-hIiCbWSeDb8HMQ2s4"));
        try {
            if (!(context instanceof Activity)) {
                intent.addFlags(268435456);
            }
            context.startActivity(intent);
            return true;
        } catch (Throwable unused) {
            e.a(context, R.string.no_qq_installed, 0);
            return false;
        }
    }

    public static String a(File file) {
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            FileInputStream fileInputStream = new FileInputStream(file);
            byte[] bArr = new byte[8192];
            while (true) {
                try {
                    try {
                        int read = fileInputStream.read(bArr);
                        if (read <= 0) {
                            break;
                        }
                        messageDigest.update(bArr, 0, read);
                    } catch (IOException e6) {
                        throw new RuntimeException("Unable to process file for MD5", e6);
                    }
                } catch (Throwable th) {
                    try {
                        fileInputStream.close();
                    } catch (IOException unused) {
                    }
                    throw th;
                }
            }
            String replace = String.format("%32s", new BigInteger(1, messageDigest.digest()).toString(16)).replace(' ', '0');
            try {
                fileInputStream.close();
            } catch (IOException unused2) {
            }
            return replace;
        } catch (FileNotFoundException | NoSuchAlgorithmException unused3) {
            return null;
        }
    }

    public static void a0(JSONArray jSONArray, List<String> list) throws JSONException {
        if (jSONArray == null) {
            return;
        }
        for (int i6 = 0; i6 < jSONArray.length(); i6++) {
            list.add(jSONArray.getString(i6));
        }
    }

    public static boolean b() {
        String J = J("ro.dalvik.vm.native.bridge", "0");
        if ((!TextUtils.isEmpty(J) && J.startsWith("libnb")) || new File("/data/dalvik-cache/x86/system@framework@boot.oat").exists()) {
            return true;
        }
        return new File("/x8").exists();
    }

    public static void b0(List<String> list, JSONArray jSONArray) throws JSONException {
        if (T(list)) {
            return;
        }
        for (int i6 = 0; i6 < list.size(); i6++) {
            jSONArray.put(i6, list.get(i6));
        }
    }

    public static void c(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (Throwable unused) {
            }
        }
    }

    public static byte[] c0(String str) throws IOException {
        FileInputStream fileInputStream = null;
        try {
            FileInputStream fileInputStream2 = new FileInputStream(str);
            try {
                byte[] bArr = new byte[1024];
                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                while (true) {
                    int read = fileInputStream2.read(bArr);
                    if (read != -1) {
                        byteArrayOutputStream.write(bArr, 0, read);
                    } else {
                        byte[] byteArray = byteArrayOutputStream.toByteArray();
                        c(fileInputStream2);
                        return byteArray;
                    }
                }
            } catch (Throwable th) {
                th = th;
                fileInputStream = fileInputStream2;
                c(fileInputStream);
                throw th;
            }
        } catch (Throwable th2) {
            th = th2;
        }
    }

    public static int d(Throwable th) {
        if (th instanceof UnknownHostException) {
            return 2;
        }
        String message = th.getMessage();
        if (TextUtils.isEmpty(message)) {
            return 255;
        }
        if (message.contains("open failed: EACCES (Permission denied)")) {
            return 7;
        }
        if (message.contains("No space left on device")) {
            return 8;
        }
        if (!message.contains("open failed: EBUSY (Device or resource busy)")) {
            return 255;
        }
        return 10;
    }

    public static byte[] d0(InputStream inputStream, boolean z6) throws IOException {
        try {
            byte[] bArr = new byte[1024];
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            while (true) {
                int read = inputStream.read(bArr);
                if (read == -1) {
                    break;
                }
                byteArrayOutputStream.write(bArr, 0, read);
            }
            return byteArrayOutputStream.toByteArray();
        } finally {
            if (z6) {
                c(inputStream);
            }
        }
    }

    public static float e(String str) {
        if (TextUtils.isEmpty(str)) {
            return 0.0f;
        }
        String upperCase = str.toUpperCase();
        if (!upperCase.endsWith("GB") && !upperCase.endsWith("G")) {
            if (!upperCase.endsWith("MB") && !upperCase.endsWith("M")) {
                if (!upperCase.endsWith("KB") && !upperCase.endsWith("K")) {
                    if (upperCase.endsWith("B")) {
                        return Float.parseFloat(upperCase.replace("B", ""));
                    }
                    return Float.parseFloat(upperCase);
                }
                return Float.parseFloat(upperCase.replace("KB", "").replace("K", "")) * 1024.0f;
            }
            return Float.parseFloat(upperCase.replace("MB", "").replace("M", "")) * 1024.0f * 1024.0f;
        }
        return Float.parseFloat(upperCase.replace("GB", "").replace("G", "")) * 1024.0f * 1024.0f * 1024.0f;
    }

    public static void e0(Context context, String str) {
        try {
            context.startActivity(context.getPackageManager().getLaunchIntentForPackage(str));
        } catch (Throwable th) {
            th.printStackTrace();
        }
    }

    public static boolean f(File file, File file2) {
        FileOutputStream fileOutputStream;
        FileInputStream fileInputStream = null;
        try {
            FileInputStream fileInputStream2 = new FileInputStream(file);
            try {
                File file3 = new File(file2.getAbsolutePath() + ".tmp");
                fileOutputStream = new FileOutputStream(file3);
                try {
                    FileChannel channel = fileInputStream2.getChannel();
                    FileChannel channel2 = fileOutputStream.getChannel();
                    long size = channel.size();
                    long j6 = 0;
                    while (size > 0) {
                        long transferTo = channel.transferTo(j6, size, channel2);
                        j6 += transferTo;
                        size -= transferTo;
                    }
                    if (channel2.size() != channel.size()) {
                        Log.e("Utils", "[copy] size not match");
                    } else if (!file3.renameTo(file2)) {
                        Log.e("Utils", "[copy] rename failed");
                    } else {
                        c(fileInputStream2);
                        c(fileOutputStream);
                        return true;
                    }
                    c(fileInputStream2);
                } catch (Exception e6) {
                    e = e6;
                    fileInputStream = fileInputStream2;
                    try {
                        e.printStackTrace();
                        c(fileInputStream);
                        c(fileOutputStream);
                        return false;
                    } catch (Throwable th) {
                        th = th;
                        c(fileInputStream);
                        c(fileOutputStream);
                        throw th;
                    }
                } catch (Throwable th2) {
                    th = th2;
                    fileInputStream = fileInputStream2;
                    c(fileInputStream);
                    c(fileOutputStream);
                    throw th;
                }
            } catch (Exception e7) {
                e = e7;
                fileOutputStream = null;
            } catch (Throwable th3) {
                th = th3;
                fileOutputStream = null;
            }
        } catch (Exception e8) {
            e = e8;
            fileOutputStream = null;
        } catch (Throwable th4) {
            th = th4;
            fileOutputStream = null;
        }
        c(fileOutputStream);
        return false;
    }

    public static void f0(Activity activity, int i6) {
        try {
            Intent intent = new Intent();
            intent.setAction("android.settings.APPLICATION_DETAILS_SETTINGS");
            intent.addCategory("android.intent.category.DEFAULT");
            intent.setData(Uri.parse("package:" + activity.getPackageName()));
            intent.addFlags(268435456);
            intent.addFlags(1073741824);
            intent.addFlags(8388608);
            activity.startActivityForResult(intent, i6);
        } catch (Throwable th) {
            th.printStackTrace();
        }
    }

    public static void g(File file, File file2) throws IOException {
        if (file.isDirectory()) {
            h(file, file2);
        } else {
            i(file, file2);
        }
    }

    public static boolean g0(Activity activity, String str, int i6) {
        try {
            if (Build.VERSION.SDK_INT >= 24) {
                Intent intent = new Intent("android.intent.action.VIEW");
                intent.setDataAndType(FileProvider.getUriForFile(activity, activity.getPackageName() + ".fileprovider", new File(str)), "application/vnd.android.package-archive");
                intent.addFlags(1);
                activity.startActivityForResult(intent, i6);
            } else {
                Intent intent2 = new Intent("android.intent.action.VIEW");
                intent2.setDataAndType(Uri.fromFile(new File(str)), "application/vnd.android.package-archive");
                activity.startActivityForResult(intent2, i6);
            }
            return true;
        } catch (Throwable th) {
            th.printStackTrace();
            return false;
        }
    }

    public static void h(File file, File file2) throws IOException {
        if (!file2.exists()) {
            file2.mkdir();
        }
        for (String str : file.list()) {
            g(new File(file, str), new File(file2, str));
        }
    }

    public static void h0(Activity activity, int i6) {
        try {
            Intent intent = new Intent("android.settings.INTERNAL_STORAGE_SETTINGS");
            activity.startActivity(intent);
            activity.startActivityForResult(intent, i6);
        } catch (Throwable th) {
            th.printStackTrace();
        }
    }

    private static void i(File file, File file2) throws IOException {
        f(file, file2);
    }

    public static void i0(Activity activity, String str, int i6) {
        try {
            activity.startActivityForResult(new Intent("android.intent.action.DELETE", Uri.parse("package:" + str)), i6);
        } catch (Throwable th) {
            th.printStackTrace();
        }
    }

    public static void j(String str) {
        if (str != null) {
            File file = new File(str);
            if (file.exists()) {
                file.delete();
            }
        }
    }

    public static byte[] j0(String str) {
        byte[] bArr = null;
        try {
            FileInputStream fileInputStream = new FileInputStream(str);
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] bArr2 = new byte[8192];
            while (true) {
                int read = fileInputStream.read(bArr2);
                if (read != -1) {
                    byteArrayOutputStream.write(bArr2, 0, read);
                } else {
                    bArr = byteArrayOutputStream.toByteArray();
                    fileInputStream.close();
                    return bArr;
                }
            }
        } catch (IOException e6) {
            e6.printStackTrace();
            return bArr;
        }
    }

    public static boolean k(File file) {
        if (!file.exists()) {
            return false;
        }
        if (file.isFile()) {
            return file.delete();
        }
        for (File file2 : file.listFiles()) {
            k(file2);
        }
        return file.delete();
    }

    public static int k0(File file) {
        if (file.isDirectory()) {
            File[] listFiles = file.listFiles();
            if (listFiles.length == 0) {
                if (file.delete()) {
                    return 1;
                }
            } else if (listFiles.length > 0) {
                int i6 = 0;
                do {
                    File[] listFiles2 = file.listFiles();
                    File file2 = file;
                    do {
                        int length = listFiles2.length;
                        int i7 = 0;
                        while (true) {
                            if (i7 >= length) {
                                break;
                            }
                            File file3 = listFiles2[i7];
                            if (file3.isDirectory()) {
                                listFiles2 = file3.listFiles();
                                file2 = file3;
                                break;
                            }
                            if (!file3.delete()) {
                                break;
                            }
                            i6++;
                            i7++;
                        }
                    } while (!file2.delete());
                    i6++;
                    if (!file.exists()) {
                        return i6;
                    }
                } while (file.exists());
            }
            return 0;
        }
        return -1;
    }

    public static float l(Context context, float f6) {
        return context.getResources().getDisplayMetrics().density * f6;
    }

    public static Uri l0(Context context, int i6) {
        return Uri.parse("android.resource://" + context.getPackageName() + "/" + i6);
    }

    public static boolean m(String str, String str2) {
        try {
            Class<?> cls = Class.forName("android.content.res.AssetManager");
            Object newInstance = cls.getConstructor(null).newInstance(null);
            cls.getDeclaredMethod("addAssetPath", String.class).invoke(newInstance, str);
            c(((AssetManager) newInstance).open(str2));
            return true;
        } catch (Throwable unused) {
            return false;
        }
    }

    public static boolean m0(File file, Bitmap bitmap) {
        FileOutputStream fileOutputStream;
        FileOutputStream fileOutputStream2 = null;
        try {
            try {
                fileOutputStream = new FileOutputStream(file);
            } catch (Exception e6) {
                e = e6;
            }
        } catch (Throwable th) {
            th = th;
        }
        try {
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
            c(fileOutputStream);
            return true;
        } catch (Exception e7) {
            e = e7;
            fileOutputStream2 = fileOutputStream;
            e.printStackTrace();
            c(fileOutputStream2);
            return false;
        } catch (Throwable th2) {
            th = th2;
            fileOutputStream2 = fileOutputStream;
            c(fileOutputStream2);
            throw th;
        }
    }

    public static boolean n(String str, String str2, String str3) throws IOException {
        HttpURLConnection httpURLConnection = (HttpURLConnection) new URL(str).openConnection();
        if (httpURLConnection.getResponseCode() != 200) {
            return false;
        }
        httpURLConnection.getHeaderField("Content-Disposition");
        httpURLConnection.getContentType();
        httpURLConnection.getContentLength();
        InputStream inputStream = httpURLConnection.getInputStream();
        String str4 = str2 + ".tmp";
        FileOutputStream fileOutputStream = new FileOutputStream(str4);
        byte[] bArr = new byte[4096];
        while (true) {
            int read = inputStream.read(bArr);
            if (read == -1) {
                break;
            }
            fileOutputStream.write(bArr, 0, read);
        }
        fileOutputStream.close();
        inputStream.close();
        httpURLConnection.disconnect();
        File file = new File(str4);
        if (!TextUtils.isEmpty(str3) && !str3.equalsIgnoreCase(a(file))) {
            file.delete();
            return false;
        }
        return file.renameTo(new File(str2));
    }

    public static void n0(String str, byte[] bArr) throws IOException {
        FileOutputStream fileOutputStream;
        FileOutputStream fileOutputStream2 = null;
        try {
            fileOutputStream = new FileOutputStream(str);
        } catch (Throwable th) {
            th = th;
        }
        try {
            fileOutputStream.write(bArr);
            c(fileOutputStream);
        } catch (Throwable th2) {
            th = th2;
            fileOutputStream2 = fileOutputStream;
            c(fileOutputStream2);
            throw th;
        }
    }

    public static void o() {
        try {
            Method declaredMethod = Class.class.getDeclaredMethod("forName", String.class);
            Method declaredMethod2 = Class.class.getDeclaredMethod("getDeclaredMethod", String.class, Class[].class);
            Class cls = (Class) declaredMethod.invoke(null, "dalvik.system.VMRuntime");
            ((Method) declaredMethod2.invoke(cls, "setHiddenApiExemptions", new Class[]{String[].class})).invoke(((Method) declaredMethod2.invoke(cls, "getRuntime", null)).invoke(null, new Object[0]), new String[]{"L"});
        } catch (Throwable th) {
            Log.e("[error]", "reflect bootstrap failed:", th);
        }
    }

    public static void o0(Context context, View view) {
        ((InputMethodManager) context.getSystemService("input_method")).showSoftInput(view, 2);
    }

    public static void p(Activity activity) {
        String str;
        try {
            if (activity.getPackageManager().getPackageInfo("com.facebook.katana", 0).versionCode >= 3002850) {
                str = "fb://facewebmodal/f?href=https://www.facebook.com/x8speeder";
            } else {
                str = "fb://page/415580488848418";
            }
        } catch (Throwable unused) {
            str = "https://www.facebook.com/x8speeder";
        }
        try {
            activity.startActivity(new Intent("android.intent.action.VIEW", Uri.parse(str)));
        } catch (Throwable th) {
            th.printStackTrace();
        }
    }

    public static List<String> p0(String str, String str2) {
        if (TextUtils.isEmpty(str)) {
            return new ArrayList();
        }
        return Arrays.asList(str.split(str2));
    }

    public static String q(long j6) {
        if (j6 == 0) {
            return "0B";
        }
        String[] strArr = {"B", "K", "M", "G", ExifInterface.GPS_DIRECTION_TRUE, "P", ExifInterface.LONGITUDE_EAST, "Z", "Y"};
        double d6 = j6;
        double d7 = 1024;
        int floor = (int) Math.floor(Math.log(d6) / Math.log(d7));
        return String.format("%.2f%s", Double.valueOf(d6 / Math.pow(d7, floor)), strArr[floor]);
    }

    public static byte[] q0(Serializable serializable) {
        if (serializable == null) {
            return null;
        }
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(serializable);
            objectOutputStream.flush();
            return byteArrayOutputStream.toByteArray();
        } catch (IOException e6) {
            e6.printStackTrace();
            return null;
        } finally {
            c(byteArrayOutputStream);
        }
    }

    public static Serializable r(byte[] bArr) {
        ByteArrayInputStream byteArrayInputStream;
        ByteArrayInputStream byteArrayInputStream2 = null;
        try {
            byteArrayInputStream = new ByteArrayInputStream(bArr);
            try {
                Serializable serializable = (Serializable) new ObjectInputStream(byteArrayInputStream).readObject();
                c(byteArrayInputStream);
                return serializable;
            } catch (Exception unused) {
                c(byteArrayInputStream);
                return null;
            } catch (Throwable th) {
                th = th;
                byteArrayInputStream2 = byteArrayInputStream;
                c(byteArrayInputStream2);
                throw th;
            }
        } catch (Exception unused2) {
            byteArrayInputStream = null;
        } catch (Throwable th2) {
            th = th2;
        }
    }

    public static boolean r0(String str, String str2) {
        try {
            ZipInputStream zipInputStream = new ZipInputStream(new BufferedInputStream(new FileInputStream(str2)));
            byte[] bArr = new byte[1024];
            while (true) {
                ZipEntry nextEntry = zipInputStream.getNextEntry();
                if (nextEntry != null) {
                    String name = nextEntry.getName();
                    File file = new File(str + name);
                    if (nextEntry.isDirectory()) {
                        file.mkdirs();
                    } else {
                        file.getParentFile().mkdirs();
                        FileOutputStream fileOutputStream = new FileOutputStream(str + name);
                        while (true) {
                            int read = zipInputStream.read(bArr);
                            if (read == -1) {
                                break;
                            }
                            fileOutputStream.write(bArr, 0, read);
                        }
                        fileOutputStream.close();
                        zipInputStream.closeEntry();
                    }
                } else {
                    zipInputStream.close();
                    return true;
                }
            }
        } catch (IOException e6) {
            e6.printStackTrace();
            return false;
        }
    }

    public static String s(Context context, String str) {
        PackageInfo packageArchiveInfo = context.getPackageManager().getPackageArchiveInfo(str, 0);
        if (packageArchiveInfo != null) {
            return packageArchiveInfo.packageName;
        }
        return "";
    }

    public static void s0(String str, byte[] bArr) {
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(str);
            fileOutputStream.write(bArr);
            fileOutputStream.close();
        } catch (IOException e6) {
            e6.printStackTrace();
        }
    }

    public static PackageInfo t(Context context, String str) {
        PackageInfo packageArchiveInfo = context.getPackageManager().getPackageArchiveInfo(str, 0);
        if (packageArchiveInfo != null) {
            return packageArchiveInfo;
        }
        return null;
    }

    private static Resources u(Context context, String str) {
        try {
            Class<?> cls = Class.forName("android.content.res.AssetManager");
            Object newInstance = cls.getConstructor(null).newInstance(null);
            cls.getDeclaredMethod("addAssetPath", String.class).invoke(newInstance, str);
            Resources resources = context.getResources();
            return new Resources((AssetManager) newInstance, resources.getDisplayMetrics(), resources.getConfiguration());
        } catch (Throwable unused) {
            return null;
        }
    }

    public static String v(Context context, String str) {
        try {
            return w(context.getPackageManager().getPackageInfo(str, 64));
        } catch (Throwable th) {
            th.printStackTrace();
            return "";
        }
    }

    public static String w(PackageInfo packageInfo) {
        try {
            return M(MessageDigest.getInstance("MD5").digest(packageInfo.signatures[0].toByteArray()));
        } catch (Throwable th) {
            th.printStackTrace();
            return "";
        }
    }

    public static Drawable x(Context context, ApplicationInfo applicationInfo, String str) {
        Bitmap decodeResource;
        Resources u6 = u(context, str);
        if (u6 != null && (decodeResource = BitmapFactory.decodeResource(u6, applicationInfo.icon)) != null) {
            return new BitmapDrawable(decodeResource);
        }
        try {
            PackageManager packageManager = context.getPackageManager();
            applicationInfo.sourceDir = str;
            applicationInfo.publicSourceDir = str;
            return applicationInfo.loadIcon(packageManager);
        } catch (Exception unused) {
            return null;
        }
    }

    public static String y(Context context, ApplicationInfo applicationInfo, String str) {
        PackageManager packageManager = context.getPackageManager();
        try {
            applicationInfo.sourceDir = str;
            applicationInfo.publicSourceDir = str;
            return (String) packageManager.getApplicationLabel(applicationInfo);
        } catch (Exception unused) {
            return "Unknown";
        }
    }

    public static long z(Context context, String str) {
        try {
            return new File(context.getPackageManager().getPackageInfo(str, 0).applicationInfo.sourceDir).length();
        } catch (Throwable unused) {
            return 0L;
        }
    }
}