哔哩哔哩 v1.6.6 - axo.java 源代码

package bl;

import android.app.ActivityManager;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.Signature;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Proxy;
import android.os.Build;
import android.os.Environment;
import android.os.Process;
import android.os.StatFs;
import android.support.v4.app.FragmentTransaction;
import android.telephony.TelephonyManager;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.WindowManager;
import android.webkit.WebSettings;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Random;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;
import org.apache.http.HttpHost;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import tv.danmaku.ijk.media.player.IjkMediaMeta;

public class axo {
    private static String A = "";
    private static long B = -1;
    private static long C = 0;
    private static Intent D = null;
    public static String a = "next_al_report_time";
    private static String b = null;
    private static String c = null;
    private static String d = null;
    private static String e = null;
    private static Random f = null;
    private static DisplayMetrics g = null;
    private static String h = null;
    private static String i = "";
    private static String j = "";
    private static String k = "";
    private static String l = "";
    private static int m = -1;
    private static axq n = null;
    private static String o = null;
    private static String p = null;
    private static volatile int q = -1;
    private static String r = null;
    private static String s = null;
    private static long t = -1;

    private static String f26u = "";
    private static b v = null;
    private static String w = "__MTA_FIRST_ACTIVATE__";
    private static int x = -1;
    private static long y = -1;
    private static int z;

    static class b {
    }

    private static synchronized Random g() {
        Random random;
        synchronized (axo.class) {
            if (f == null) {
                f = new Random();
            }
            random = f;
        }
        return random;
    }

    public static int a() {
        return g().nextInt(Integer.MAX_VALUE);
    }

    public static byte[] a(byte[] bArr) throws IOException {
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bArr);
        GZIPInputStream gZIPInputStream = new GZIPInputStream(byteArrayInputStream);
        byte[] bArr2 = new byte[FragmentTransaction.TRANSIT_ENTER_MASK];
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(bArr.length * 2);
        while (true) {
            int read = gZIPInputStream.read(bArr2);
            if (read != -1) {
                byteArrayOutputStream.write(bArr2, 0, read);
            } else {
                byte[] byteArray = byteArrayOutputStream.toByteArray();
                byteArrayInputStream.close();
                gZIPInputStream.close();
                byteArrayOutputStream.close();
                return byteArray;
            }
        }
    }

    public static String a(String str) {
        if (str == null) {
            return "0";
        }
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            messageDigest.update(str.getBytes());
            byte[] digest = messageDigest.digest();
            StringBuffer stringBuffer = new StringBuffer();
            for (byte b2 : digest) {
                int i2 = b2 & 255;
                if (i2 < 16) {
                    stringBuffer.append("0");
                }
                stringBuffer.append(Integer.toHexString(i2));
            }
            return stringBuffer.toString();
        } catch (Throwable unused) {
            return "0";
        }
    }

    public static HttpHost a(Context context) {
        NetworkInfo activeNetworkInfo;
        String extraInfo;
        if (context == null) {
            return null;
        }
        try {
        } catch (Throwable th) {
            n.b(th);
        }
        if (context.getPackageManager().checkPermission("android.permission.ACCESS_NETWORK_STATE", context.getPackageName()) != 0 || (activeNetworkInfo = ((ConnectivityManager) context.getSystemService("connectivity")).getActiveNetworkInfo()) == null) {
            return null;
        }
        if ((activeNetworkInfo.getTypeName() != null && activeNetworkInfo.getTypeName().equalsIgnoreCase("WIFI")) || (extraInfo = activeNetworkInfo.getExtraInfo()) == null) {
            return null;
        }
        if (!extraInfo.equals("cmwap") && !extraInfo.equals("3gwap") && !extraInfo.equals("uniwap")) {
            if (extraInfo.equals("ctwap")) {
                return new HttpHost("10.0.0.200", 80);
            }
            String defaultHost = Proxy.getDefaultHost();
            if (defaultHost != null && defaultHost.trim().length() > 0) {
                return new HttpHost(defaultHost, Proxy.getDefaultPort());
            }
            return null;
        }
        return new HttpHost("10.0.0.172", 80);
    }

    public static synchronized String b(Context context) {
        synchronized (axo.class) {
            if (b != null && b.trim().length() != 0) {
                return b;
            }
            b = axs.a(context);
            if (b == null || b.trim().length() == 0) {
                b = Integer.toString(g().nextInt(Integer.MAX_VALUE));
            }
            return b;
        }
    }

    public static synchronized String c(Context context) {
        String str;
        synchronized (axo.class) {
            if (d == null || d.trim().length() == 0) {
                d = axs.b(context);
            }
            str = d;
        }
        return str;
    }

    public static DisplayMetrics d(Context context) {
        if (g == null) {
            g = new DisplayMetrics();
            ((WindowManager) context.getApplicationContext().getSystemService("window")).getDefaultDisplay().getMetrics(g);
        }
        return g;
    }

    public static boolean e(Context context) {
        NetworkInfo[] allNetworkInfo;
        try {
        } catch (Throwable th) {
            n.b(th);
        }
        if (axs.a(context, "android.permission.ACCESS_WIFI_STATE")) {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getApplicationContext().getSystemService("connectivity");
            if (connectivityManager != null && (allNetworkInfo = connectivityManager.getAllNetworkInfo()) != null) {
                for (int i2 = 0; i2 < allNetworkInfo.length; i2++) {
                    if (allNetworkInfo[i2].getTypeName().equalsIgnoreCase("WIFI") && allNetworkInfo[i2].isConnected()) {
                        return true;
                    }
                }
            }
            return false;
        }
        n.c("can not get the permission of android.permission.ACCESS_WIFI_STATE");
        return false;
    }

    public static String f(Context context) {
        if (c != null) {
            return c;
        }
        try {
            ApplicationInfo applicationInfo = context.getPackageManager().getApplicationInfo(context.getPackageName(), u.aly.j.h);
            if (applicationInfo == null) {
                return null;
            }
            String string = applicationInfo.metaData.getString("TA_APPKEY");
            if (string != null) {
                c = string;
                return string;
            }
            n.b("Could not read APPKEY meta-data from AndroidManifest.xml");
            return null;
        } catch (Throwable unused) {
            n.b("Could not read APPKEY meta-data from AndroidManifest.xml");
            return null;
        }
    }

    public static String g(Context context) {
        try {
            ApplicationInfo applicationInfo = context.getPackageManager().getApplicationInfo(context.getPackageName(), u.aly.j.h);
            if (applicationInfo == null) {
                return null;
            }
            Object obj = applicationInfo.metaData.get("InstallChannel");
            if (obj != null) {
                return obj.toString();
            }
            n.d("Could not read InstallChannel meta-data from AndroidManifest.xml");
            return null;
        } catch (Throwable unused) {
            n.d("Could not read InstallChannel meta-data from AndroidManifest.xml");
            return null;
        }
    }

    public static String h(Context context) {
        if (context == null) {
            return null;
        }
        return context.getClass().getName();
    }

    public static String i(Context context) {
        TelephonyManager telephonyManager;
        if (h != null) {
            return h;
        }
        try {
            if (axs.a(context, "android.permission.READ_PHONE_STATE")) {
                if (m(context) && (telephonyManager = (TelephonyManager) context.getSystemService("phone")) != null) {
                    h = telephonyManager.getSimOperator();
                }
            } else {
                n.f("Could not get permission of android.permission.READ_PHONE_STATE");
            }
        } catch (Throwable th) {
            n.b(th);
        }
        return h;
    }

    public static String j(Context context) {
        try {
            if (!axs.a(context, "android.permission.READ_PHONE_STATE")) {
                return "";
            }
            String subscriberId = m(context) ? ((TelephonyManager) context.getSystemService("phone")).getSubscriberId() : null;
            if (subscriberId != null) {
                return subscriberId;
            }
            return null;
        } catch (Throwable th) {
            n.b(th);
            return "";
        }
    }

    public static String k(Context context) {
        if (c(i)) {
            return i;
        }
        try {
            i = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
            if (i == null) {
                return "";
            }
        } catch (Throwable th) {
            n.b(th);
        }
        return i;
    }

    public static String l(Context context) {
        PackageInfo packageInfo;
        if (c(k)) {
            return k;
        }
        try {
            packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 64);
        } catch (PackageManager.NameNotFoundException e2) {
            att.a(e2);
        } catch (NoSuchAlgorithmException e3) {
            att.a(e3);
        } catch (Throwable th) {
            att.a(th);
        }
        if (packageInfo == null) {
            n.f("packageInfo is null ");
            return "";
        }
        Signature[] signatureArr = packageInfo.signatures;
        if (signatureArr != null && signatureArr.length != 0) {
            byte[] digest = MessageDigest.getInstance("SHA1").digest(signatureArr[0].toByteArray());
            StringBuffer stringBuffer = new StringBuffer();
            int length = digest.length;
            for (int i2 = 0; i2 < length; i2++) {
                String upperCase = Integer.toHexString(digest[i2] & 255).toUpperCase(Locale.US);
                if (upperCase.length() == 1) {
                    stringBuffer.append("0");
                }
                stringBuffer.append(upperCase);
                if (i2 != length - 1) {
                    stringBuffer.append(":");
                }
            }
            k = stringBuffer.toString();
            return k;
        }
        n.f("signatures is null");
        return "";
    }

    public static boolean m(Context context) {
        return context.getPackageManager().checkPermission("android.permission.READ_PHONE_STATE", context.getPackageName()) == 0;
    }

    public static String n(Context context) {
        try {
            if (axs.a(context, "android.permission.INTERNET") && axs.a(context, "android.permission.ACCESS_NETWORK_STATE")) {
                NetworkInfo activeNetworkInfo = ((ConnectivityManager) context.getSystemService("connectivity")).getActiveNetworkInfo();
                if (activeNetworkInfo == null || !activeNetworkInfo.isConnected()) {
                    return "";
                }
                String typeName = activeNetworkInfo.getTypeName();
                String extraInfo = activeNetworkInfo.getExtraInfo();
                if (typeName == null) {
                    return "";
                }
                if (typeName.equalsIgnoreCase("WIFI")) {
                    extraInfo = "WIFI";
                } else if (typeName.equalsIgnoreCase("MOBILE")) {
                    if (extraInfo == null || extraInfo.trim().length() <= 0) {
                        extraInfo = "MOBILE";
                    }
                } else if (extraInfo == null || extraInfo.trim().length() <= 0) {
                    return typeName;
                }
                return extraInfo;
            }
            n.f("can not get the permission of android.permission.ACCESS_WIFI_STATE");
            return "";
        } catch (Throwable th) {
            n.b(th);
            return "";
        }
    }

    public static Integer o(Context context) {
        try {
            TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService("phone");
            if (telephonyManager != null) {
                return Integer.valueOf(telephonyManager.getNetworkType());
            }
            return null;
        } catch (Throwable unused) {
            return null;
        }
    }

    public static String p(Context context) {
        if (c(l)) {
            return l;
        }
        try {
            l = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionName;
        } catch (Throwable th) {
            n.b(th);
        }
        if (l == null) {
            return IjkMediaMeta.IJKM_VAL_TYPE__UNKNOWN;
        }
        if (l.length() == 0) {
            return IjkMediaMeta.IJKM_VAL_TYPE__UNKNOWN;
        }
        return l;
    }

    public static int q(Context context) {
        if (m != -1) {
            return m;
        }
        m = 0;
        try {
            if (c.a()) {
                m = 1;
            }
        } catch (Throwable th) {
            n.b(th);
        }
        return m;
    }

    static class c {
        private static int a = -1;

        public static boolean a() {
            if (a == 1) {
                return true;
            }
            if (a == 0) {
                return false;
            }
            for (String str : new String[]{"/bin", "/system/bin/", "/system/xbin/", "/system/sbin/", "/sbin/", "/vendor/bin/"}) {
                try {
                    File file = new File(str + "su");
                    if (file != null && file.exists()) {
                        a = 1;
                        return true;
                    }
                } catch (Exception unused) {
                }
            }
            a = 0;
            return false;
        }
    }

    public static synchronized axq b() {
        axq axqVar;
        synchronized (axo.class) {
            if (n == null) {
                n = new axq("MtaSDK");
                n.a(false);
            }
            axqVar = n;
        }
        return axqVar;
    }

    public static long c() {
        try {
            Calendar calendar = Calendar.getInstance();
            calendar.set(11, 0);
            calendar.set(12, 0);
            calendar.set(13, 0);
            calendar.set(14, 0);
            return calendar.getTimeInMillis() + 86400000;
        } catch (Throwable th) {
            n.b(th);
            return System.currentTimeMillis() + 86400000;
        }
    }

    public static String a(int i2) {
        Calendar calendar = Calendar.getInstance();
        calendar.roll(6, i2);
        return new SimpleDateFormat("yyyyMMdd").format(calendar.getTime());
    }

    public static Long a(String str, String str2, int i2, int i3, Long l2) {
        if (str == null || str2 == null) {
            return l2;
        }
        if (str2.equalsIgnoreCase(".") || str2.equalsIgnoreCase("|")) {
            str2 = "\\" + str2;
        }
        String[] split = str.split(str2);
        if (split.length != i3) {
            return l2;
        }
        try {
            Long l3 = 0L;
            for (String str3 : split) {
                l3 = Long.valueOf(i2 * (l3.longValue() + Long.valueOf(str3).longValue()));
            }
            return l3;
        } catch (NumberFormatException unused) {
            return l2;
        }
    }

    public static long b(String str) {
        return a(str, ".", 100, 3, 0L).longValue();
    }

    public static boolean c(String str) {
        return (str == null || str.trim().length() == 0) ? false : true;
    }

    public static String r(Context context) {
        String path;
        if (c(o)) {
            return o;
        }
        try {
        } catch (Throwable th) {
            n.b(th);
        }
        if (axs.a(context, "android.permission.WRITE_EXTERNAL_STORAGE")) {
            String externalStorageState = Environment.getExternalStorageState();
            if (externalStorageState != null && externalStorageState.equals("mounted") && (path = Environment.getExternalStorageDirectory().getPath()) != null) {
                StatFs statFs = new StatFs(path);
                long availableBlocks = (statFs.getAvailableBlocks() * statFs.getBlockSize()) / 1000000;
                o = String.valueOf(availableBlocks) + "/" + String.valueOf((statFs.getBlockCount() * statFs.getBlockSize()) / 1000000);
                return o;
            }
            return null;
        }
        n.c("can not get the permission of android.permission.WRITE_EXTERNAL_STORAGE");
        return null;
    }

    public static String a(long j2) {
        return new SimpleDateFormat("yyyyMMdd").format(new Date(j2));
    }

    public static String b(long j2) {
        return new SimpleDateFormat("yyyyMMddHHmmSS").format(new Date(j2));
    }

    public static boolean s(Context context) {
        return context.getPackageName().equals(t(context));
    }

    public static String t(Context context) {
        if (p != null) {
            return p;
        }
        int myPid = Process.myPid();
        Iterator<ActivityManager.RunningAppProcessInfo> it = ((ActivityManager) context.getSystemService("activity")).getRunningAppProcesses().iterator();
        while (true) {
            if (!it.hasNext()) {
                break;
            }
            ActivityManager.RunningAppProcessInfo next = it.next();
            if (next.pid == myPid) {
                p = next.processName;
                break;
            }
        }
        return p;
    }

    public static String a(Context context, String str) {
        if (awr.t()) {
            if (p == null) {
                p = t(context);
            }
            if (p != null) {
                return str + "_" + p;
            }
        }
        return str;
    }

    public static void a(Process process) {
        if (process != null) {
            try {
                process.exitValue();
            } catch (Throwable unused) {
            }
        }
    }

    public static String u(Context context) {
        return a(context, axp.b);
    }

    public static synchronized Integer v(Context context) {
        Integer valueOf;
        synchronized (axo.class) {
            if (q > 0) {
                if (q % 1000 == 0) {
                    try {
                        int i2 = q + 1000;
                        if (q >= 2147383647) {
                            i2 = 0;
                        }
                        axr.b(context, "MTA_EVENT_INDEX", i2);
                    } catch (Throwable th) {
                        n.d(th);
                    }
                }
            } else {
                q = axr.a(context, "MTA_EVENT_INDEX", 0);
                axr.b(context, "MTA_EVENT_INDEX", q + 1000);
            }
            q++;
            valueOf = Integer.valueOf(q);
        }
        return valueOf;
    }

    public static String d() {
        if (c(s)) {
            return s;
        }
        long e2 = e() / 1000000;
        StatFs statFs = new StatFs(Environment.getDataDirectory().getPath());
        s = String.valueOf((statFs.getBlockSize() * statFs.getAvailableBlocks()) / 1000000) + "/" + String.valueOf(e2);
        return s;
    }

    public static long e() {
        StatFs statFs = new StatFs(Environment.getDataDirectory().getPath());
        return statFs.getBlockCount() * statFs.getBlockSize();
    }

    public static String w(Context context) {
        try {
            return String.valueOf(M(context) / 1000000) + "/" + String.valueOf(h() / 1000000);
        } catch (Throwable th) {
            att.a(th);
            return null;
        }
    }

    private static long M(Context context) {
        ActivityManager activityManager = (ActivityManager) context.getSystemService("activity");
        ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
        activityManager.getMemoryInfo(memoryInfo);
        return memoryInfo.availMem;
    }

    private static long h() {
        throw new UnsupportedOperationException("Method not decompiled: bl.axo.h():long");
    }

    public static JSONObject x(Context context) {
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("n", a.a());
            String d2 = a.d();
            if (d2 != null && d2.length() > 0) {
                jSONObject.put("na", d2);
            }
            int b2 = a.b();
            if (b2 > 0) {
                jSONObject.put("fx", b2 / 1000000);
            }
            int c2 = a.c();
            if (c2 > 0) {
                jSONObject.put("fn", c2 / 1000000);
            }
        } catch (Throwable th) {
            Log.w("MtaSDK", "get cpu error", th);
        }
        return jSONObject;
    }

    static class a {

        class C0019a implements FileFilter {
            C0019a() {
            }

            @Override
            public boolean accept(File file) {
                return Pattern.matches("cpu[0-9]", file.getName());
            }
        }

        static int a() {
            try {
                return new File("/sys/devices/system/cpu/").listFiles(new C0019a()).length;
            } catch (Exception e) {
                att.a(e);
                return 1;
            }
        }

        static int b() {
            int i = 0;
            try {
                String str = "";
                InputStream inputStream = new ProcessBuilder("/system/bin/cat", "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq").start().getInputStream();
                byte[] bArr = new byte[24];
                while (inputStream.read(bArr) != -1) {
                    str = str + new String(bArr);
                }
                inputStream.close();
                String trim = str.trim();
                if (trim.length() > 0) {
                    i = Integer.valueOf(trim).intValue();
                }
            } catch (Exception e) {
                axo.n.b((Throwable) e);
            }
            return i * 1000;
        }

        static int c() {
            int i = 0;
            try {
                String str = "";
                InputStream inputStream = new ProcessBuilder("/system/bin/cat", "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_min_freq").start().getInputStream();
                byte[] bArr = new byte[24];
                while (inputStream.read(bArr) != -1) {
                    str = str + new String(bArr);
                }
                inputStream.close();
                String trim = str.trim();
                if (trim.length() > 0) {
                    i = Integer.valueOf(trim).intValue();
                }
            } catch (Throwable th) {
                axo.n.b(th);
            }
            return i * 1000;
        }

        static java.lang.String d() {
            throw new UnsupportedOperationException("Method not decompiled: bl.axo.a.d():java.lang.String");
        }
    }

    public static synchronized int y(Context context) {
        synchronized (axo.class) {
            if (x != -1) {
                return x;
            }
            z(context);
            return x;
        }
    }

    public static void z(Context context) {
        x = axr.a(context, w, 1);
        if (x == 1) {
            axr.b(context, w, 0);
        }
    }

    public static boolean a(axa axaVar) {
        if (axaVar == null) {
            return false;
        }
        return c(axaVar.d());
    }

    public static boolean A(Context context) {
        if (y < 0) {
            y = axr.a(context, "mta.qq.com.checktime", 0L);
        }
        return Math.abs(System.currentTimeMillis() - y) > 86400000;
    }

    public static void B(Context context) {
        y = System.currentTimeMillis();
        axr.b(context, "mta.qq.com.checktime", y);
    }

    public static int a(Context context, boolean z2) {
        if (z2) {
            z = C(context);
        }
        return z;
    }

    public static int C(Context context) {
        return axr.a(context, "mta.qq.com.difftime", 0);
    }

    public static void a(Context context, int i2) {
        z = i2;
        axr.b(context, "mta.qq.com.difftime", i2);
    }

    public static Map<String, Integer> D(Context context) {
        HashMap hashMap = new HashMap();
        try {
            Iterator<ActivityManager.RunningAppProcessInfo> it = ((ActivityManager) context.getSystemService("activity")).getRunningAppProcesses().iterator();
            while (it.hasNext()) {
                hashMap.put(it.next().processName, 1);
            }
        } catch (Throwable th) {
            n.b(th);
        }
        return hashMap;
    }

    public static Map<String, Integer> E(Context context) {
        HashMap hashMap = new HashMap();
        try {
            Iterator<ActivityManager.RecentTaskInfo> it = ((ActivityManager) context.getSystemService("activity")).getRecentTasks(64, 1).iterator();
            while (it.hasNext()) {
                ResolveInfo resolveActivity = context.getPackageManager().resolveActivity(it.next().baseIntent, 0);
                if (resolveActivity != null) {
                    hashMap.put(resolveActivity.resolvePackageName, 1);
                }
            }
        } catch (Throwable th) {
            n.b(th);
        }
        return hashMap;
    }

    public static JSONArray a(Throwable th) {
        JSONArray jSONArray = new JSONArray();
        if (th != null) {
            jSONArray.put(th.toString());
            a(jSONArray, th.getStackTrace());
        }
        return jSONArray;
    }

    public static JSONArray a(JSONArray jSONArray, StackTraceElement[] stackTraceElementArr) {
        if (stackTraceElementArr != null) {
            for (StackTraceElement stackTraceElement : stackTraceElementArr) {
                jSONArray.put(stackTraceElement.toString());
            }
        }
        return jSONArray;
    }

    public static int F(Context context) {
        try {
            String str = k(context) + ".run.cnt";
            int a2 = axr.a(context, str, 1);
            axr.b(context, str, a2 + 1);
            return a2;
        } catch (Throwable unused) {
            return 0;
        }
    }

    public static void a(JSONObject jSONObject, PackageInfo packageInfo) {
        try {
            jSONObject.put("pn", packageInfo.packageName);
            jSONObject.put("av", packageInfo.versionName);
            jSONObject.put("vc", packageInfo.versionCode);
            jSONObject.put("fit", packageInfo.firstInstallTime / 1000);
            jSONObject.put("lut", packageInfo.lastUpdateTime / 1000);
            jSONObject.put("fg", packageInfo.applicationInfo.flags);
        } catch (JSONException unused) {
        }
    }

    public static JSONArray G(Context context) {
        JSONArray jSONArray = new JSONArray();
        try {
            List<PackageInfo> installedPackages = context.getPackageManager().getInstalledPackages(0);
            Map<String, Integer> D2 = D(context);
            Map<String, Integer> E = E(context);
            for (PackageInfo packageInfo : installedPackages) {
                try {
                    JSONObject jSONObject = new JSONObject();
                    String str = packageInfo.packageName;
                    a(jSONObject, packageInfo);
                    if (D2.containsKey(str)) {
                        jSONObject.put("rn", 1);
                    }
                    if (E.containsKey(str)) {
                        jSONObject.put("rt", 1);
                    }
                    jSONArray.put(jSONObject);
                } catch (JSONException e2) {
                    n.b((Throwable) e2);
                }
            }
        } catch (Throwable th) {
            att.a(th);
        }
        return jSONArray;
    }

    public static String H(Context context) {
        if (context == null) {
            return null;
        }
        try {
            Intent intent = new Intent("android.intent.action.MAIN");
            intent.addCategory("android.intent.category.HOME");
            ResolveInfo resolveActivity = context.getPackageManager().resolveActivity(intent, 0);
            if (resolveActivity.activityInfo == null || resolveActivity.activityInfo.packageName.equals("android")) {
                return null;
            }
            return resolveActivity.activityInfo.packageName;
        } catch (Throwable th) {
            att.a(th);
            return null;
        }
    }

    public static boolean I(Context context) {
        if (!awr.A()) {
            return false;
        }
        if (B == -1) {
            C = Long.valueOf(awr.b("autoAL", String.valueOf(86400L))).longValue() * 1000;
            if (C > 10800000) {
                B = axr.a(context, a, 0L);
            } else {
                B = Long.MAX_VALUE;
            }
            n.h("next_al_report_time:" + B);
        }
        return B < System.currentTimeMillis();
    }

    public static void J(Context context) {
        B = System.currentTimeMillis() + C;
        axr.b(context, a, B);
    }

    public static String K(Context context) {
        try {
            return (String) avw.class.getMethod("getNewMid", Context.class).invoke(null, context);
        } catch (Throwable unused) {
            n.d("MidService.getNewMid method notfound");
            return null;
        }
    }

    public static void a(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException e2) {
                att.a(e2);
            }
        }
    }

    public static String L(Context context) {
        String property;
        if (Build.VERSION.SDK_INT >= 17) {
            try {
                property = WebSettings.getDefaultUserAgent(context);
            } catch (Exception unused) {
                property = System.getProperty("http.agent");
            }
        } else {
            property = System.getProperty("http.agent");
        }
        StringBuffer stringBuffer = new StringBuffer();
        int length = property.length();
        for (int i2 = 0; i2 < length; i2++) {
            char charAt = property.charAt(i2);
            if (charAt <= 31 || charAt >= 127) {
                stringBuffer.append(String.format("\\u%04x", Integer.valueOf(charAt)));
            } else {
                stringBuffer.append(charAt);
            }
        }
        return stringBuffer.toString();
    }
}