package p138.p176.p291.p296.p297.p299;

import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.content.Context;
import android.content.SharedPreferences;
import android.content.res.Resources;
import android.hardware.SensorManager;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Build;
import android.os.Debug;
import android.os.StatFs;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.Log;
import java.io.BufferedReader;
import java.io.Closeable;
import java.io.File;
import java.io.FileReader;
import java.io.Flushable;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Scanner;
import java.util.regex.Pattern;
import p138.p176.p291.p296.p297.C5608;

/* JADX INFO: renamed from: ދ.ހ.ށ.ބ.ށ.އ.ބ, reason: contains not printable characters */
/* JADX INFO: loaded from: classes.dex */
public class C5627 {

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static final char[] f16109 = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public static long f16110 = -1;

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public static final Comparator<File> f16111 = new C5628();

    /* JADX INFO: renamed from: ދ.ހ.ށ.ބ.ށ.އ.ބ$֏, reason: contains not printable characters */
    public class C5628 implements Comparator<File> {
        @Override // java.util.Comparator
        public int compare(File file, File file2) {
            return (int) (file.lastModified() - file2.lastModified());
        }
    }

    /* JADX INFO: renamed from: ދ.ހ.ށ.ބ.ށ.އ.ބ$ؠ, reason: contains not printable characters */
    public enum EnumC5629 {
        X86_32,
        X86_64,
        ARM_UNKNOWN,
        PPC,
        PPC64,
        ARMV6,
        ARMV7,
        UNKNOWN,
        ARMV7S,
        ARM64;


        /* JADX INFO: renamed from: ލ, reason: contains not printable characters */
        public static final Map<String, EnumC5629> f16122;

        static {
            HashMap map = new HashMap(4);
            f16122 = map;
            map.put("armeabi-v7a", ARMV7);
            f16122.put("armeabi", ARMV6);
            f16122.put("arm64-v8a", ARM64);
            f16122.put("x86", X86_32);
        }

        /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
        public static EnumC5629 m9011() {
            String str = Build.CPU_ABI;
            if (TextUtils.isEmpty(str)) {
                C5608.f16066.m8972("Architecture#getValue()::Build.CPU_ABI returned null or empty");
                return UNKNOWN;
            }
            EnumC5629 enumC5629 = f16122.get(str.toLowerCase(Locale.US));
            return enumC5629 == null ? UNKNOWN : enumC5629;
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static int m8989() {
        return EnumC5629.m9011().ordinal();
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static int m8990(Context context, String str, String str2) {
        String packageName;
        Resources resources = context.getResources();
        int i = context.getApplicationContext().getApplicationInfo().icon;
        if (i > 0) {
            try {
                packageName = context.getResources().getResourcePackageName(i);
            } catch (Resources.NotFoundException unused) {
                packageName = context.getPackageName();
            }
        } else {
            packageName = context.getPackageName();
        }
        return resources.getIdentifier(str, str2, packageName);
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static long m8991(String str) {
        StatFs statFs = new StatFs(str);
        long blockSize = statFs.getBlockSize();
        return (((long) statFs.getBlockCount()) * blockSize) - (blockSize * ((long) statFs.getAvailableBlocks()));
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static long m8992(String str, String str2, int i) {
        return Long.parseLong(str.split(str2)[0].trim()) * ((long) i);
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static ActivityManager.RunningAppProcessInfo m8993(String str, Context context) {
        List<ActivityManager.RunningAppProcessInfo> runningAppProcesses = ((ActivityManager) context.getSystemService("activity")).getRunningAppProcesses();
        if (runningAppProcesses != null) {
            for (ActivityManager.RunningAppProcessInfo runningAppProcessInfo : runningAppProcesses) {
                if (runningAppProcessInfo.processName.equals(str)) {
                    return runningAppProcessInfo;
                }
            }
        }
        return null;
    }

    /* JADX WARN: Code restructure failed: missing block: B:12:0x0035, code lost:
    
        r2 = r3[1];
     */
    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static String m8994(File file, String str) throws Throwable {
        BufferedReader bufferedReader;
        String str2 = null;
        str2 = null;
        str2 = null;
        BufferedReader bufferedReader2 = null;
        if (file.exists()) {
            try {
                bufferedReader = new BufferedReader(new FileReader(file), 1024);
                while (true) {
                    try {
                        try {
                            String line = bufferedReader.readLine();
                            if (line == null) {
                                break;
                            }
                            String[] strArrSplit = Pattern.compile("\\s*:\\s*").split(line, 2);
                            if (strArrSplit.length > 1 && strArrSplit[0].equals(str)) {
                                break;
                            }
                        } catch (Exception e) {
                            e = e;
                            C5608.f16066.m8976("Error parsing " + file, e);
                        }
                    } catch (Throwable th) {
                        th = th;
                        bufferedReader2 = bufferedReader;
                        m8998(bufferedReader2, "Failed to close system file reader.");
                        throw th;
                    }
                }
            } catch (Exception e2) {
                e = e2;
                bufferedReader = null;
            } catch (Throwable th2) {
                th = th2;
                m8998(bufferedReader2, "Failed to close system file reader.");
                throw th;
            }
            m8998(bufferedReader, "Failed to close system file reader.");
        }
        return str2;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static String m8995(InputStream inputStream) {
        Scanner scannerUseDelimiter = new Scanner(inputStream).useDelimiter("\\A");
        return scannerUseDelimiter.hasNext() ? scannerUseDelimiter.next() : "";
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static String m8996(byte[] bArr) {
        char[] cArr = new char[bArr.length * 2];
        for (int i = 0; i < bArr.length; i++) {
            int i2 = bArr[i] & 255;
            int i3 = i * 2;
            char[] cArr2 = f16109;
            cArr[i3] = cArr2[i2 >>> 4];
            cArr[i3 + 1] = cArr2[i2 & 15];
        }
        return new String(cArr);
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static String m8997(String... strArr) {
        if (strArr == null || strArr.length == 0) {
            return null;
        }
        ArrayList arrayList = new ArrayList();
        for (String str : strArr) {
            if (str != null) {
                arrayList.add(str.replace("-", "").toLowerCase(Locale.US));
            }
        }
        Collections.sort(arrayList);
        StringBuilder sb = new StringBuilder();
        Iterator it = arrayList.iterator();
        while (it.hasNext()) {
            sb.append((String) it.next());
        }
        String string = sb.toString();
        if (string.length() > 0) {
            return m9006(string);
        }
        return null;
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static void m8998(Closeable closeable, String str) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e) {
                C5608 c5608 = C5608.f16066;
                if (c5608.m8974(6)) {
                    Log.e(c5608.f16067, str, e);
                }
            }
        }
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static void m8999(Flushable flushable, String str) {
        if (flushable != null) {
            try {
                flushable.flush();
            } catch (IOException e) {
                C5608 c5608 = C5608.f16066;
                if (c5608.m8974(6)) {
                    Log.e(c5608.f16067, str, e);
                }
            }
        }
    }

    @SuppressLint({"MissingPermission"})
    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static boolean m9000(Context context) {
        if (!(context.checkCallingOrSelfPermission("android.permission.ACCESS_NETWORK_STATE") == 0)) {
            return true;
        }
        NetworkInfo activeNetworkInfo = ((ConnectivityManager) context.getSystemService("connectivity")).getActiveNetworkInfo();
        return activeNetworkInfo != null && activeNetworkInfo.isConnectedOrConnecting();
    }

    /* JADX INFO: renamed from: ֏, reason: contains not printable characters */
    public static boolean m9001(Context context, String str, boolean z) {
        Resources resources;
        if (context != null && (resources = context.getResources()) != null) {
            int iM8990 = m8990(context, str, "bool");
            if (iM8990 > 0) {
                return resources.getBoolean(iM8990);
            }
            int iM89902 = m8990(context, str, "string");
            if (iM89902 > 0) {
                return Boolean.parseBoolean(context.getString(iM89902));
            }
        }
        return z;
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public static int m9002(Context context) {
        boolean z = true;
        int i = m9009(context) ? 1 : 0;
        if (m9010(context)) {
            i |= 2;
        }
        if (!Debug.isDebuggerConnected() && !Debug.waitingForDebugger()) {
            z = false;
        }
        return z ? i | 4 : i;
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public static synchronized long m9003() {
        if (f16110 == -1) {
            long jM8992 = 0;
            String strM8994 = m8994(new File("/proc/meminfo"), "MemTotal");
            if (!TextUtils.isEmpty(strM8994)) {
                String upperCase = strM8994.toUpperCase(Locale.US);
                try {
                    if (upperCase.endsWith("KB")) {
                        jM8992 = m8992(upperCase, "KB", 1024);
                    } else if (upperCase.endsWith("MB")) {
                        jM8992 = m8992(upperCase, "MB", 1048576);
                    } else if (upperCase.endsWith("GB")) {
                        jM8992 = m8992(upperCase, "GB", 1073741824);
                    } else {
                        C5608.f16066.m8972("Unexpected meminfo format while computing RAM: " + upperCase);
                    }
                } catch (NumberFormatException e) {
                    C5608.f16066.m8976("Unexpected meminfo format while computing RAM: " + upperCase, e);
                }
            }
            f16110 = jM8992;
        }
        return f16110;
    }

    /* JADX INFO: renamed from: ؠ, reason: contains not printable characters */
    public static boolean m9004(String str) {
        return str == null || str.length() == 0;
    }

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public static String m9005(Context context) {
        int iM8990 = m8990(context, "com.google.firebase.crashlytics.mapping_file_id", "string");
        if (iM8990 == 0) {
            iM8990 = m8990(context, "com.crashlytics.android.build_id", "string");
        }
        if (iM8990 != 0) {
            return context.getResources().getString(iM8990);
        }
        return null;
    }

    /* JADX INFO: renamed from: ހ, reason: contains not printable characters */
    public static String m9006(String str) {
        byte[] bytes = str.getBytes();
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("SHA-1");
            messageDigest.update(bytes);
            return m8996(messageDigest.digest());
        } catch (NoSuchAlgorithmException e) {
            C5608.f16066.m8976("Could not create hashing algorithm: SHA-1, returning empty string.", e);
            return "";
        }
    }

    /* JADX INFO: renamed from: ށ, reason: contains not printable characters */
    public static boolean m9007(Context context) {
        return (m9009(context) || ((SensorManager) context.getSystemService("sensor")).getDefaultSensor(8) == null) ? false : true;
    }

    /* JADX INFO: renamed from: ނ, reason: contains not printable characters */
    public static SharedPreferences m9008(Context context) {
        return context.getSharedPreferences("com.google.firebase.crashlytics", 0);
    }

    /* JADX INFO: renamed from: ރ, reason: contains not printable characters */
    public static boolean m9009(Context context) {
        return "sdk".equals(Build.PRODUCT) || "google_sdk".equals(Build.PRODUCT) || Settings.Secure.getString(context.getContentResolver(), "android_id") == null;
    }

    /* JADX INFO: renamed from: ބ, reason: contains not printable characters */
    public static boolean m9010(Context context) {
        boolean zM9009 = m9009(context);
        String str = Build.TAGS;
        if ((zM9009 || str == null || !str.contains("test-keys")) && !new File("/system/app/Superuser.apk").exists()) {
            return !zM9009 && new File("/system/xbin/su").exists();
        }
        return true;
    }
}