package com.ea.nimble;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Bundle;
import android.os.Looper;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;
import com.applovin.exoplayer2.common.base.Ascii;
import com.ea.nimble.Log;
import com.google.gson.GsonBuilder;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Serializable;
import java.io.StringWriter;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
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.TimeZone;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

/* loaded from: classes2.dex */
public final class Utility {
    public static boolean getTestResult() {
        return true;
    }

    public static String safeString(String str) {
        return str == null ? "" : str;
    }

    private Utility() {
    }

    public static void loadLibrary(String str) {
        String obj;
        if (str == null) {
            Log.Helper.LOGDS("Utility", "loadLibrary(): libName is null", new Object[0]);
            return;
        }
        try {
            System.loadLibrary(str);
            obj = "Success";
        } catch (NullPointerException e) {
            obj = e.toString();
        } catch (SecurityException e2) {
            obj = e2.toString();
        } catch (Exception e3) {
            obj = e3.toString();
        } catch (UnsatisfiedLinkError e4) {
            obj = e4.toString();
        }
        Log.Helper.LOGDS("Utility", "loadLibrary(" + str + "): " + obj, new Object[0]);
    }

    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Removed duplicated region for block: B:36:0x0070  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static java.util.Map<java.lang.String, java.lang.String> parseXmlFile(int r6) {
        /*
            r0 = 0
            com.ea.nimble.IApplicationEnvironment r1 = com.ea.nimble.ApplicationEnvironment.getComponent()     // Catch: java.lang.Throwable -> L48 java.lang.Exception -> L4d
            android.content.Context r1 = r1.getApplicationContext()     // Catch: java.lang.Throwable -> L48 java.lang.Exception -> L4d
            android.content.res.Resources r1 = r1.getResources()     // Catch: java.lang.Throwable -> L48 java.lang.Exception -> L4d
            android.content.res.XmlResourceParser r6 = r1.getXml(r6)     // Catch: java.lang.Throwable -> L48 java.lang.Exception -> L4d
            if (r6 == 0) goto L42
            java.util.LinkedHashMap r1 = new java.util.LinkedHashMap     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
            r1.<init>()     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
            int r2 = r6.getEventType()     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
            r3 = r0
        L1d:
            r4 = 1
            if (r2 == r4) goto L3b
            r4 = 2
            if (r2 != r4) goto L2c
            java.lang.String r3 = r6.getName()     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
            goto L36
        L28:
            r0 = move-exception
            goto L6e
        L2a:
            r1 = move-exception
            goto L4f
        L2c:
            r4 = 4
            if (r2 != r4) goto L36
            java.lang.String r2 = r6.getText()     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
            r1.put(r3, r2)     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
        L36:
            int r2 = r6.next()     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
            goto L1d
        L3b:
            r6.close()     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
            r6.close()
            return r1
        L42:
            java.lang.Exception r1 = new java.lang.Exception     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
            r1.<init>()     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
            throw r1     // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
        L48:
            r6 = move-exception
            r5 = r0
            r0 = r6
            r6 = r5
            goto L6e
        L4d:
            r1 = move-exception
            r6 = r0
        L4f:
            java.lang.String r2 = "Utility"
            java.lang.StringBuilder r3 = new java.lang.StringBuilder     // Catch: java.lang.Throwable -> L28
            r3.<init>()     // Catch: java.lang.Throwable -> L28
            java.lang.String r4 = "Error reading xml file: "
            r3.append(r4)     // Catch: java.lang.Throwable -> L28
            r3.append(r1)     // Catch: java.lang.Throwable -> L28
            java.lang.String r1 = r3.toString()     // Catch: java.lang.Throwable -> L28
            r3 = 0
            java.lang.Object[] r3 = new java.lang.Object[r3]     // Catch: java.lang.Throwable -> L28
            com.ea.nimble.Log.Helper.LOGES(r2, r1, r3)     // Catch: java.lang.Throwable -> L28
            if (r6 == 0) goto L6d
            r6.close()
        L6d:
            return r0
        L6e:
            if (r6 == 0) goto L73
            r6.close()
        L73:
            throw r0
        */
        throw new UnsupportedOperationException("Method not decompiled: com.ea.nimble.Utility.parseXmlFile(int):java.util.Map");
    }

    public static String readStringFromStream(InputStream inputStream) throws IOException {
        InputStreamReader inputStreamReader = new InputStreamReader(inputStream, Charset.defaultCharset());
        char[] cArr = new char[4096];
        StringWriter stringWriter = new StringWriter();
        while (true) {
            int read = inputStreamReader.read(cArr, 0, 4096);
            if (read > 0) {
                stringWriter.write(cArr, 0, read);
            } else {
                return stringWriter.toString();
            }
        }
    }

    public static String getUTCDateStringFormat(Date date) {
        if (date == null) {
            return "";
        }
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US);
        simpleDateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
        return simpleDateFormat.format(date);
    }

    public static boolean validString(String str) {
        return str != null && str.length() > 0;
    }

    public static boolean validStringObject(Object obj) {
        return obj != null && (obj instanceof String) && ((String) obj).length() > 0;
    }

    public static String convertObjectToJSONString(Object obj) {
        return new GsonBuilder().disableHtmlEscaping().create().toJson(obj);
    }

    public static Map<String, Object> convertJSONObjectToMap(JSONObject jSONObject) {
        HashMap hashMap = new HashMap();
        Iterator<String> keys = jSONObject.keys();
        while (keys.hasNext()) {
            String next = keys.next();
            if (jSONObject.isNull(next)) {
                hashMap.put(next, null);
            } else {
                JSONObject optJSONObject = jSONObject.optJSONObject(next);
                if (optJSONObject != null) {
                    hashMap.put(next, convertJSONObjectToMap(optJSONObject));
                } else {
                    JSONArray optJSONArray = jSONObject.optJSONArray(next);
                    if (optJSONArray != null) {
                        hashMap.put(next, convertJSONArrayToList(optJSONArray));
                    } else {
                        try {
                            hashMap.put(next, jSONObject.get(next));
                        } catch (JSONException e) {
                            e.printStackTrace();
                            hashMap.put(next, null);
                        }
                    }
                }
            }
        }
        return hashMap;
    }

    public static Map<String, Object> convertJSONObjectStringToMap(String str) {
        try {
            return convertJSONObjectToMap(new JSONObject(str));
        } catch (JSONException e) {
            e.printStackTrace();
            return new HashMap();
        }
    }

    public static List<Object> convertJSONArrayToList(JSONArray jSONArray) {
        ArrayList arrayList = new ArrayList();
        for (int i = 0; i < jSONArray.length(); i++) {
            if (jSONArray.isNull(i)) {
                arrayList.add(null);
            } else {
                JSONObject optJSONObject = jSONArray.optJSONObject(i);
                if (optJSONObject != null) {
                    arrayList.add(convertJSONObjectToMap(optJSONObject));
                } else {
                    JSONArray optJSONArray = jSONArray.optJSONArray(i);
                    if (optJSONArray != null) {
                        arrayList.add(convertJSONArrayToList(optJSONArray));
                    } else {
                        try {
                            arrayList.add(jSONArray.get(i));
                        } catch (JSONException e) {
                            e.printStackTrace();
                            arrayList.add(null);
                        }
                    }
                }
            }
        }
        return arrayList;
    }

    public static String readFile(String str) {
        try {
            InputStream open = ApplicationEnvironment.getCurrentActivity().getAssets().open(str);
            byte[] bArr = new byte[open.available()];
            open.read(bArr);
            open.close();
            return new String(bArr, "UTF-8");
        } catch (IOException e) {
            Log.Helper.LOGVS("Utility", "readFile(): %s", e.toString());
            return null;
        }
    }

    public static void sendBroadcast(String str) {
        LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext()).sendBroadcast(new Intent(str));
    }

    public static void sendBroadcast(String str, Map<String, String> map) {
        LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext());
        Intent intent = new Intent(str);
        if (map != null) {
            for (Map.Entry<String, String> entry : map.entrySet()) {
                intent.putExtra(entry.getKey(), entry.getValue());
            }
        }
        localBroadcastManager.sendBroadcast(intent);
    }

    public static void sendBroadcast(String str, Bundle bundle) {
        LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext()).sendBroadcast(new Intent(str).replaceExtras(bundle));
    }

    public static void sendBroadcastSerializable(String str, Map<String, Serializable> map) {
        LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext());
        Intent intent = new Intent(str);
        if (map != null) {
            for (Map.Entry<String, Serializable> entry : map.entrySet()) {
                intent.putExtra(entry.getKey(), entry.getValue());
            }
        }
        localBroadcastManager.sendBroadcast(intent);
    }

    public static void sendExplicitBroadcast(Intent intent) {
        List<ResolveInfo> queryBroadcastReceivers;
        PackageManager.ResolveInfoFlags of;
        Context applicationContext = ApplicationEnvironment.getComponent().getApplicationContext();
        PackageManager packageManager = applicationContext.getPackageManager();
        if (Build.VERSION.SDK_INT >= 33) {
            of = PackageManager.ResolveInfoFlags.of(0L);
            queryBroadcastReceivers = packageManager.queryBroadcastReceivers(intent, of);
        } else {
            queryBroadcastReceivers = packageManager.queryBroadcastReceivers(intent, 0);
        }
        for (ResolveInfo resolveInfo : queryBroadcastReceivers) {
            Intent intent2 = new Intent(intent);
            ActivityInfo activityInfo = resolveInfo.activityInfo;
            intent2.setComponent(new ComponentName(activityInfo.applicationInfo.packageName, activityInfo.name));
            applicationContext.sendBroadcast(intent2);
        }
    }

    public static void registerReceiver(String str, BroadcastReceiver broadcastReceiver) {
        LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext()).registerReceiver(broadcastReceiver, new IntentFilter(str));
    }

    public static void unregisterReceiver(BroadcastReceiver broadcastReceiver) {
        LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext()).unregisterReceiver(broadcastReceiver);
    }

    public static String SHA256HashString(String str) {
        if (str == null) {
            return null;
        }
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
            messageDigest.reset();
            byte[] digest = messageDigest.digest(str.getBytes());
            StringBuffer stringBuffer = new StringBuffer();
            for (byte b : digest) {
                stringBuffer.append(Integer.toString((b & 255) + 256, 16).substring(1));
            }
            return stringBuffer.toString();
        } catch (NoSuchAlgorithmException unused) {
            Log.Helper.LOGES("Utility", "Can't find SHA-256 algorithm", new Object[0]);
            return null;
        }
    }

    public static byte[] SHA256Hash(String str) {
        if (str == null) {
            return null;
        }
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
            messageDigest.reset();
            return messageDigest.digest(str.getBytes());
        } catch (NoSuchAlgorithmException unused) {
            Log.Helper.LOGES("Utility", "Can't find SHA-256 algorithm", new Object[0]);
            return null;
        }
    }

    public static boolean stringsAreEquivalent(String str, String str2) {
        return (str == null || str2 == null) ? str == str2 : str.compareTo(str2) == 0;
    }

    public static String bytesToHexString(byte[] bArr) {
        char[] charArray = "0123456789ABCDEF".toCharArray();
        char[] cArr = new char[bArr.length * 2];
        for (int i = 0; i < bArr.length; i++) {
            byte b = bArr[i];
            int i2 = i * 2;
            cArr[i2] = charArray[(b & 255) >> 4];
            cArr[i2 + 1] = charArray[b & Ascii.SI];
        }
        return new String(cArr);
    }

    public static boolean isOnlyDecimalCharacters(String str) {
        if (str == null) {
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    public static String convertLiteralMapToString(Map<String, String> map) {
        if (map == null) {
            return "NULL";
        }
        StringBuilder sb = new StringBuilder();
        sb.append("{\n");
        for (Map.Entry<String, String> entry : map.entrySet()) {
            sb.append("\t\"");
            sb.append(entry.getKey());
            sb.append("\" = \"");
            sb.append(entry.getValue());
            sb.append("\",\n");
        }
        sb.deleteCharAt(sb.length() - 2);
        sb.append("}");
        return sb.toString();
    }

    public static void runOnWorkerThread(Runnable runnable) {
        if (Looper.getMainLooper() == Looper.myLooper()) {
            AsyncTask.SERIAL_EXECUTOR.execute(runnable);
        } else {
            runnable.run();
        }
    }

    public static ApplicationInfo getApplicationInfo(int i) {
        PackageManager.ApplicationInfoFlags of;
        Activity currentActivity = ApplicationEnvironment.getCurrentActivity();
        ApplicationInfo applicationInfo = null;
        if (currentActivity != null) {
            try {
                PackageManager packageManager = currentActivity.getPackageManager();
                if (packageManager == null) {
                    Log.Helper.LOGES("Utility", "PackageManager could not be obtained", new Object[0]);
                } else if (Build.VERSION.SDK_INT >= 33) {
                    String packageName = currentActivity.getPackageName();
                    of = PackageManager.ApplicationInfoFlags.of(i);
                    applicationInfo = packageManager.getApplicationInfo(packageName, of);
                } else {
                    applicationInfo = packageManager.getApplicationInfo(currentActivity.getPackageName(), i);
                }
            } catch (PackageManager.NameNotFoundException e) {
                Log.Helper.LOGES("Utility", "Package name %s not found. Exception: %s", currentActivity.getPackageName(), e.toString());
            }
        } else {
            Log.Helper.LOGES("Utility", "Application Context is null", new Object[0]);
        }
        return applicationInfo;
    }

    public static PackageInfo getPackageInfo(int i) {
        PackageManager.PackageInfoFlags of;
        Context applicationContext = ApplicationEnvironment.getComponent().getApplicationContext();
        PackageInfo packageInfo = null;
        if (applicationContext != null) {
            try {
                PackageManager packageManager = applicationContext.getPackageManager();
                if (packageManager == null) {
                    Log.Helper.LOGES("Utility", "PackageManager could not be obtained", new Object[0]);
                } else if (Build.VERSION.SDK_INT >= 33) {
                    String packageName = applicationContext.getPackageName();
                    of = PackageManager.PackageInfoFlags.of(i);
                    packageInfo = packageManager.getPackageInfo(packageName, of);
                } else {
                    packageInfo = packageManager.getPackageInfo(applicationContext.getPackageName(), i);
                }
            } catch (PackageManager.NameNotFoundException e) {
                Log.Helper.LOGES("Utility", "Package name %s not found. Exception: %s", applicationContext.getPackageName(), e.toString());
            }
        } else {
            Log.Helper.LOGES("Utility", "Application Context is null", new Object[0]);
        }
        return packageInfo;
    }
}