package com.firemint.realracing;

import android.app.Activity;
import android.app.ActivityManager;
import android.app.AlertDialog;
import android.content.ActivityNotFoundException;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.media.AudioManager;
import android.media.MediaScannerConnection;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.net.wifi.WifiManager;
import android.opengl.GLUtils;
import android.os.Build;
import android.os.Bundle;
import android.os.Debug;
import android.os.Environment;
import android.os.storage.StorageManager;
import android.provider.MediaStore;
import android.provider.Settings;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.WindowMetrics;
import androidx.work.Data;
import com.applovin.exoplayer2.common.base.Ascii;
import com.applovin.sdk.AppLovinEventTypes;
import com.facebook.internal.security.CertificateUtil;
import com.firemonkeys.cloudcellapi.util.GetInfo;
import com.google.firebase.crashlytics.FirebaseCrashlytics;
import com.ironsource.v8;
import com.mbridge.msdk.foundation.tools.SameMD5;
import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
import com.singular.sdk.Singular;
import com.singular.sdk.SingularConfig;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.Closeable;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.security.MessageDigest;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import javax.microedition.khronos.opengles.GL10;
import org.apache.http.HttpStatus;

/* loaded from: classes2.dex */
public class Platform {
    public static final int ASSET_DOWNLOAD_PROGRESS_NOTIFICATION_ID = 2;
    public static final int ASSET_DOWNLOAD_REMINDER_NOTIFICATION_ID = 1;
    public static final int BUY_DRIVER_XP = 14;
    public static final int CAR_DELIVERY = 6;
    public static final int CAR_REPAIR = 5;
    public static final int CAR_TUNING = 13;
    public static final int CAR_UPGRADE = 4;
    public static final int DAILY_RACE_BONUS = 7;
    public static final int DEFAULT_NOTIFICATION_ID = -2;
    static final int EXTERNAL_MOUNTED_READ_ONLY = 1;
    static final int EXTERNAL_MOUNTED_READ_WRITE = 2;
    static final int EXTERNAL_NOT_MOUNTED = 0;
    public static final int INTERNET_CONNECTION_DELAY = 3600;
    public static final int LAPSED_REWARD = 9;
    public static final int LIMITED_TIME_SERIES_NOTIF = 11;
    public static final int NETWORK_TYPE_EHRPD = 14;
    public static final int NETWORK_TYPE_EVDO_B = 12;
    public static final int NETWORK_TYPE_HSPAP = 15;
    public static final int NETWORK_TYPE_IDEN = 11;
    public static final int NETWORK_TYPE_LTE = 13;
    public static final int QUESTS = 3;
    public static final int REPEAT_REMINDER_MAX = 2;
    public static final int SALE_STARTED = 10;
    public static final int TWO_DAY_DELAY_SEC = 172800;
    public static final int ULTIMATE_DRIVER = 8;
    static Boolean bShouldUseLegacyExternalFilesDir;
    protected static final char[] hexArray = "0123456789abcdef".toCharArray();
    static PendingImageToSave m_PendingImageToSave;

    public static void SingularLimitDataSharing(boolean z) {
    }

    public static int getApiLevel() {
        return Build.VERSION.SDK_INT;
    }

    private static int getNextPOT(int i) {
        int i2 = 1;
        while (i2 < i) {
            i2 *= 2;
        }
        return i2;
    }

    public static Boolean ShouldUseLegacyExternalFilesDir(Context context) {
        if (bShouldUseLegacyExternalFilesDir == null) {
            bShouldUseLegacyExternalFilesDir = Boolean.valueOf(new File(getLegacyExternalStorageDirPath(context) + "/.depot/").exists());
        }
        return bShouldUseLegacyExternalFilesDir;
    }

    public static String getAmazonAdvertisingId() throws Exception {
        if (!GetInfo.GetIsAmazonDevice()) {
            throw new Exception("Attempting to call an Amazon only function on a non Amazon device");
        }
        return Settings.Secure.getString(AppProxy.GetContext().getContentResolver(), "advertising_id");
    }

    public static String getDeviceUID() {
        return Settings.Secure.getString(AppProxy.GetContext().getContentResolver(), "android_id");
    }

    public static boolean IsInForeground() {
        MainActivity mainActivity = MainActivity.instance;
        return mainActivity != null && mainActivity.hasWindowFocus();
    }

    public static String getModelID() {
        return Build.MODEL;
    }

    public static String getModelName() {
        return Build.PRODUCT;
    }

    public static String getBuildDevice() {
        return Build.DEVICE;
    }

    public static String getBuildManufacturer() {
        return Build.MANUFACTURER;
    }

    public static String getCpuName() {
        Pattern compile = Pattern.compile("Hardware\\s*:\\s*(.+)");
        Pattern compile2 = Pattern.compile("model\\s+name\\s*:\\s*(.+)");
        String str = "";
        BufferedReader bufferedReader = null;
        try {
            try {
                BufferedReader bufferedReader2 = new BufferedReader(new FileReader(new File("/proc/cpuinfo")));
                while (true) {
                    try {
                        String readLine = bufferedReader2.readLine();
                        if (readLine == null) {
                            break;
                        }
                        Matcher matcher = compile.matcher(readLine);
                        if (matcher.matches()) {
                            str = matcher.group(1);
                            break;
                        }
                        Matcher matcher2 = compile2.matcher(readLine);
                        if (matcher2.matches()) {
                            str = matcher2.group(1);
                            break;
                        }
                    } catch (IOException unused) {
                        bufferedReader = bufferedReader2;
                        bufferedReader.close();
                        return str;
                    } catch (Throwable th) {
                        th = th;
                        bufferedReader = bufferedReader2;
                        try {
                            bufferedReader.close();
                        } catch (Exception unused2) {
                        }
                        throw th;
                    }
                }
                bufferedReader2.close();
            } catch (Exception unused3) {
            }
        } catch (IOException unused4) {
        } catch (Throwable th2) {
            th = th2;
        }
        return str;
    }

    public static String getScreenDensityName() {
        switch (getScreenDPI()) {
            case 120:
                return "ldpi";
            case 160:
                return "mdpi";
            case 213:
                return "tvdpi";
            case PsExtractor.VIDEO_STREAM_MASK /* 240 */:
                return "hdpi";
            case 260:
            case 280:
            case 300:
            case WEBVIEW_ERROR_VALUE:
                return "xhigh";
            case 340:
            case 360:
            case 400:
            case HttpStatus.SC_METHOD_FAILURE /* 420 */:
            case 440:
            case 480:
                return "xxhigh";
            case 560:
            case 640:
                return "xxxhdpi";
            default:
                return "";
        }
    }

    public static int getScreenSize() {
        return AppProxy.GetContext().getResources().getConfiguration().screenLayout & 15;
    }

    public static String getScreenSizeName() {
        int screenSize = getScreenSize();
        return screenSize != 1 ? screenSize != 2 ? screenSize != 3 ? screenSize != 4 ? "" : "xlarge" : "large" : "normal" : "small";
    }

    public static String getSupportedAbis() {
        StringBuilder sb = new StringBuilder();
        if (MainActivity.IsAtLeastAPI(21)) {
            int length = Build.SUPPORTED_ABIS.length;
            for (int i = 0; i < length; i++) {
                if (i != 0) {
                    sb.append(";");
                }
                sb.append(Build.SUPPORTED_ABIS[i]);
            }
        } else {
            sb.append(Build.CPU_ABI);
            String str = Build.CPU_ABI2;
            if (!TextUtils.isEmpty(str)) {
                sb.append(";");
                sb.append(str);
            }
        }
        return sb.toString();
    }

    public static int getCpuCount() {
        if (MainActivity.IsAtLeastAPI(17)) {
            return Runtime.getRuntime().availableProcessors();
        }
        return 0;
    }

    public static int getCpuSpeed() {
        int cpuCount = getCpuCount();
        int i = 0;
        for (int i2 = 0; i2 < cpuCount; i2++) {
            try {
                int readCpuSpeed = readCpuSpeed("/sys/devices/system/cpu/cpu" + i2 + "/cpufreq/cpuinfo_max_freq");
                if (readCpuSpeed > i) {
                    i = readCpuSpeed;
                }
            } catch (Exception unused) {
            }
        }
        return i;
    }

    private static int readCpuSpeed(String str) throws IOException, NumberFormatException {
        BufferedReader bufferedReader = null;
        try {
            BufferedReader bufferedReader2 = new BufferedReader(new FileReader(new File(str)));
            try {
                int parseInt = Integer.parseInt(bufferedReader2.readLine());
                try {
                    bufferedReader2.close();
                } catch (Exception unused) {
                }
                return parseInt;
            } catch (Throwable th) {
                th = th;
                bufferedReader = bufferedReader2;
                try {
                    bufferedReader.close();
                } catch (Exception unused2) {
                }
                throw th;
            }
        } catch (Throwable th2) {
            th = th2;
        }
    }

    public static String getPackageName() {
        return AppProxy.GetContext().getPackageName().toString();
    }

    public static String getAppName() {
        try {
            Context GetContext = AppProxy.GetContext();
            PackageManager packageManager = GetContext.getPackageManager();
            return packageManager.getApplicationLabel(packageManager.getApplicationInfo(GetContext.getPackageName(), 0)).toString();
        } catch (PackageManager.NameNotFoundException unused) {
            return "";
        }
    }

    public static String getAppVersion() {
        try {
            Context GetContext = AppProxy.GetContext();
            return GetContext.getPackageManager().getPackageInfo(GetContext.getPackageName(), 0).versionName;
        } catch (PackageManager.NameNotFoundException unused) {
            return "";
        }
    }

    public static long getAppInstallTime() {
        try {
            Context GetContext = AppProxy.GetContext();
            return GetContext.getPackageManager().getPackageInfo(GetContext.getPackageName(), 0).lastUpdateTime;
        } catch (PackageManager.NameNotFoundException unused) {
            return 0L;
        }
    }

    public static String getAppPath() {
        try {
            Context GetContext = AppProxy.GetContext();
            return GetContext.getPackageManager().getApplicationInfo(GetContext.getPackageName(), 0).sourceDir;
        } catch (PackageManager.NameNotFoundException unused) {
            return "";
        }
    }

    public static float getSystemMediaVolume() {
        AudioManager audioManager = (AudioManager) MainActivity.instance.getSystemService("audio");
        return audioManager.getStreamVolume(3) / audioManager.getStreamMaxVolume(3);
    }

    public static String getOsVersion() {
        return Build.VERSION.RELEASE;
    }

    public static String GetDeviceHardware() {
        return Build.HARDWARE;
    }

    public static String getStringExtra(String str) {
        Intent intent = MainActivity.instance.getIntent();
        if (intent != null) {
            return intent.getStringExtra(str);
        }
        return null;
    }

    public static int getExternalStorageState() {
        String externalStorageState = Environment.getExternalStorageState();
        if (externalStorageState.equals("mounted")) {
            return 2;
        }
        return externalStorageState.equals("mounted_ro") ? 1 : 0;
    }

    public static String getLegacyExternalStorageDirPath(Context context) {
        File externalStorageDirectory = Environment.getExternalStorageDirectory();
        if (externalStorageDirectory == null) {
            return "";
        }
        return externalStorageDirectory.getAbsolutePath() + "/Android/data/" + context.getPackageName();
    }

    public static String getExternalStorageDir() {
        return getExternalStorageDir(AppProxy.GetContext());
    }

    public static String getExternalStorageDir(Context context) {
        File externalFilesDir;
        if (ShouldUseLegacyExternalFilesDir(context).booleanValue()) {
            return getLegacyExternalStorageDirPath(context);
        }
        return (context == null || (externalFilesDir = context.getExternalFilesDir(null)) == null) ? "" : externalFilesDir.getAbsolutePath();
    }

    public static int getScreenRotation() {
        return MainActivity.instance.getScreenRotation();
    }

    public static Object getAssetManager() {
        return MainActivity.instance.getAssets();
    }

    public static boolean saveToImageGalleryImpl(int[] iArr, int i, int i2, int i3, String str, FileDescriptor fileDescriptor) {
        Bitmap.CompressFormat compressFormat;
        String str2;
        OutputStream fileOutputStream;
        MainActivity.logi("Saving to gallery: " + str);
        if (MainActivity.IsAtLeastAPI(29) && fileDescriptor != null) {
            MainActivity.logi("fileDescriptor should be null on Android 10 and above.");
        }
        if (str.endsWith(".png") || str.endsWith(".PNG")) {
            compressFormat = Bitmap.CompressFormat.PNG;
            str2 = "image/png";
        } else {
            if (!str.endsWith(".jpg") && !str.endsWith(".JPG")) {
                MainActivity.loge("Error: Unrecognised image file extension on filename: " + str);
                return false;
            }
            compressFormat = Bitmap.CompressFormat.JPEG;
            str2 = "image/jpeg";
        }
        for (int i4 = 0; i4 < i; i4++) {
            try {
                int i5 = iArr[i4];
                iArr[i4] = ((i5 & 16711680) >> 16) | ((-16711936) & i5) | ((i5 & 255) << 16);
            } catch (Exception e) {
                StringBuilder sb = new StringBuilder();
                sb.append("Error: ");
                sb.append(e.toString());
                return false;
            }
        }
        Bitmap createBitmap = Bitmap.createBitmap(iArr, i - i2, -i2, i2, i3, Bitmap.Config.ARGB_8888);
        createBitmap.setHasAlpha(false);
        if (MainActivity.IsAtLeastAPI(29)) {
            ContentResolver contentResolver = AppProxy.GetContext().getContentResolver();
            ContentValues contentValues = new ContentValues();
            contentValues.put("_display_name", str);
            contentValues.put("mime_type", str2);
            contentValues.put("relative_path", Environment.DIRECTORY_PICTURES + File.separator + AppProxy.GetContext().getString(R.string.screenshot_folder_name));
            fileOutputStream = contentResolver.openOutputStream(contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues));
        } else {
            fileOutputStream = new FileOutputStream(fileDescriptor);
        }
        createBitmap.compress(compressFormat, 100, fileOutputStream);
        fileOutputStream.flush();
        fileOutputStream.close();
        MediaScannerConnection.scanFile(AppProxy.GetContext(), new String[]{str}, null, new MediaScannerConnection.OnScanCompletedListener() { // from class: com.firemint.realracing.Platform.1
            @Override // android.media.MediaScannerConnection.OnScanCompletedListener
            public void onScanCompleted(String str3, Uri uri) {
                StringBuilder sb2 = new StringBuilder();
                sb2.append("Scanned ");
                sb2.append(str3);
                sb2.append(CertificateUtil.DELIMITER);
                StringBuilder sb3 = new StringBuilder();
                sb3.append("-> uri=");
                sb3.append(uri);
            }
        });
        return true;
    }

    public static void StoragePermissionUpdated(int i, Intent intent) {
        if (i == 0) {
            PendingImageToSave pendingImageToSave = m_PendingImageToSave;
            if (pendingImageToSave != null) {
                boolean SaveImage = pendingImageToSave.SaveImage(intent);
                m_PendingImageToSave = null;
                if (SaveImage) {
                    return;
                }
            }
        } else if (i == -1) {
            m_PendingImageToSave = null;
        } else {
            MainActivity.logw("Warning: Platform.java received an unknown storage permission value");
        }
        DisplayImageSaveErrorMessage();
    }

    public static void RequestPhotoDirectoryWriteAccess() {
        MainActivity.instance.startActivityForResult(((StorageManager) MainActivity.instance.getSystemService(v8.a.j)).getPrimaryStorageVolume().createAccessIntent(Environment.DIRECTORY_PICTURES), 1);
    }

    public static void requestExactNotifications() {
        Intent intent = new Intent();
        intent.setAction("android.settings.REQUEST_SCHEDULE_EXACT_ALARM");
        MainActivity.instance.startActivity(intent);
    }

    public static boolean hasCameraPermission() {
        return MainActivity.instance.IsPermissionGranted("android.permission.CAMERA");
    }

    public static void requestCameraPermission() {
        MainActivity.instance.RequestPermission("android.permission.CAMERA", 2);
    }

    public static void requestPostNotificationsPermission() {
        MainActivity.instance.RequestPermission("android.permission.POST_NOTIFICATIONS", 3);
    }

    public static boolean isNotificationPermissionGranted() {
        return MainActivity.instance.IsPermissionGranted("android.permission.POST_NOTIFICATIONS");
    }

    public static boolean saveToImageGallery(int[] iArr, int i, int i2, int i3, String str) {
        m_PendingImageToSave = new PendingImageToSave(iArr, i, i2, i3, str, Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES));
        if (MainActivity.IsBelowAPI(29)) {
            if (MainActivity.IsAtLeastAPI(24)) {
                RequestPhotoDirectoryWriteAccess();
                return false;
            }
            if (!MainActivity.instance.IsPermissionGranted("android.permission.WRITE_EXTERNAL_STORAGE")) {
                MainActivity.instance.RequestPermission("android.permission.WRITE_EXTERNAL_STORAGE", 0);
                return false;
            }
        }
        if (m_PendingImageToSave.SaveImage(null)) {
            m_PendingImageToSave = null;
            return true;
        }
        DisplayImageSaveErrorMessage();
        return false;
    }

    public static void DisplayImageSaveErrorMessage() {
        AppProxy.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemint.realracing.Platform.2
            @Override // java.lang.Runnable
            public void run() {
                MainActivity mainActivity = MainActivity.instance;
                new AlertDialog.Builder(mainActivity).setTitle(mainActivity.getResources().getString(R.string.IMAGE_SAVE_FAILURE_TITLE)).setMessage(mainActivity.getResources().getString(R.string.IMAGE_SAVE_FAILURE_MESSAGE)).setPositiveButton(mainActivity.getResources().getString(R.string.CONTINUE), (DialogInterface.OnClickListener) null).show();
            }
        });
    }

    public static TextureInfo loadTextureFromMemory(byte[] bArr, int i) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inPreferredConfig = Bitmap.Config.RGB_565;
        Bitmap decodeByteArray = BitmapFactory.decodeByteArray(bArr, 0, i, options);
        if (decodeByteArray == null) {
            return null;
        }
        TextureInfo textureInfo = new TextureInfo();
        textureInfo.width = decodeByteArray.getWidth();
        textureInfo.height = decodeByteArray.getHeight();
        textureInfo.texWidth = getNextPOT(textureInfo.width);
        textureInfo.texHeight = getNextPOT(textureInfo.height);
        Matrix matrix = new Matrix();
        matrix.setScale(1.0f, -1.0f);
        matrix.postTranslate(0.0f, textureInfo.height);
        Bitmap createBitmap = Bitmap.createBitmap(decodeByteArray, 0, 0, textureInfo.width, textureInfo.height, matrix, false);
        int[] iArr = new int[1];
        GL10 gl10 = (GL10) MainActivity.instance.getGLView().getGLContext().getGL();
        gl10.glGenTextures(1, iArr, 0);
        int i2 = iArr[0];
        textureInfo.texId = i2;
        gl10.glBindTexture(3553, i2);
        gl10.glTexParameterf(3553, 10241, 9729.0f);
        gl10.glTexParameterf(3553, Data.MAX_DATA_BYTES, 9729.0f);
        gl10.glTexParameterf(3553, 10242, 10497.0f);
        gl10.glTexParameterf(3553, 10243, 10497.0f);
        gl10.glTexImage2D(3553, 0, GLUtils.getInternalFormat(createBitmap), textureInfo.texWidth, textureInfo.texHeight, 0, GLUtils.getInternalFormat(createBitmap), GLUtils.getType(createBitmap), null);
        GLUtils.texSubImage2D(3553, 0, 0, textureInfo.texHeight - textureInfo.height, createBitmap);
        StringBuilder sb = new StringBuilder();
        sb.append("loadTextureFromMemory() U=");
        sb.append(textureInfo.width);
        sb.append(" V=");
        sb.append(textureInfo.height);
        sb.append(" W=");
        sb.append(textureInfo.texWidth);
        sb.append(" H=");
        sb.append(textureInfo.texHeight);
        return textureInfo;
    }

    public static void toggleIdleMode(boolean z) {
        if (z) {
            AppProxy.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemint.realracing.Platform.3
                @Override // java.lang.Runnable
                public void run() {
                    MainActivity.instance.getWindow().clearFlags(128);
                }
            });
        } else {
            AppProxy.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemint.realracing.Platform.4
                @Override // java.lang.Runnable
                public void run() {
                    MainActivity.instance.getWindow().addFlags(128);
                }
            });
        }
    }

    public static void memoryProbe() {
        Log.e("RealRacing3", "Memory probing now...");
        System.gc();
        System.gc();
        Runtime runtime = Runtime.getRuntime();
        long nativeHeapSize = Debug.getNativeHeapSize();
        long nativeHeapAllocatedSize = Debug.getNativeHeapAllocatedSize();
        long nativeHeapFreeSize = Debug.getNativeHeapFreeSize();
        long maxMemory = runtime.maxMemory();
        long j = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        Log.e("RealRacing3", String.format("Native max memory: %s", humanByteSize(nativeHeapSize)));
        Log.e("RealRacing3", String.format("Native alloc memory: %s", humanByteSize(nativeHeapAllocatedSize)));
        Log.e("RealRacing3", String.format("Native free memory: %s", humanByteSize(nativeHeapFreeSize)));
        Log.e("RealRacing3", String.format("Max memory: %s", humanByteSize(maxMemory)));
        Log.e("RealRacing3", String.format("Total memory: %s", humanByteSize(j)));
        Log.e("RealRacing3", String.format("Free memory: %s", humanByteSize(freeMemory)));
        ActivityManager activityManager = (ActivityManager) MainActivity.instance.getSystemService("activity");
        ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
        activityManager.getMemoryInfo(memoryInfo);
        Log.e("RealRacing3", String.format("TOTAL Available memory: %s", humanByteSize(memoryInfo.availMem)));
        Log.e("RealRacing3", String.format("TOTAL Low memory threshold: %s", humanByteSize(memoryInfo.threshold)));
        Object[] objArr = new Object[1];
        objArr[0] = memoryInfo.lowMemory ? "TRUE" : "false";
        Log.e("RealRacing3", String.format("TOTAL Low memory flag: %s", objArr));
        Log.e("RealRacing3", "Memory probing DONE.");
    }

    public static int GetAudioFramesPerBuffer() {
        if (getApiLevel() >= 17) {
            return Integer.parseInt(((AudioManager) MainActivity.instance.getSystemService("audio")).getProperty("android.media.property.OUTPUT_FRAMES_PER_BUFFER"));
        }
        return 0;
    }

    public static int GetAudioSampleRate() {
        if (getApiLevel() >= 17) {
            return Integer.parseInt(((AudioManager) MainActivity.instance.getSystemService("audio")).getProperty("android.media.property.OUTPUT_SAMPLE_RATE"));
        }
        return 0;
    }

    public static String humanByteSize(long j) {
        if (j < 1000) {
            return j + " B";
        }
        double d = j;
        double d2 = 1000;
        int log = (int) (Math.log(d) / Math.log(d2));
        return String.format("%.1f %sB", Double.valueOf(d / Math.pow(d2, log)), "kMGTPE".charAt(log - 1) + "");
    }

    public static long getAppMemoryUsage() {
        return (Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) + Debug.getNativeHeapAllocatedSize();
    }

    public static long getAppMemoryFree() {
        return Runtime.getRuntime().freeMemory() + Debug.getNativeHeapFreeSize();
    }

    /* JADX WARN: Can't wrap try/catch for region: R(16:(33:89|90|91|92|93|94|95|(1:8)(1:88)|9|10|11|(3:77|78|(19:80|(1:82)|73|21|22|23|(1:25)|26|27|28|30|31|33|34|36|37|38|39|40))|13|70|71|72|73|21|22|23|(0)|26|27|28|30|31|33|34|36|37|38|39|40)|22|23|(0)|26|27|28|30|31|33|34|36|37|38|39|40) */
    /* JADX WARN: Can't wrap try/catch for region: R(33:0|1|(1:3)|4|(33:89|90|91|92|93|94|95|(1:8)(1:88)|9|10|11|(3:77|78|(19:80|(1:82)|73|21|22|23|(1:25)|26|27|28|30|31|33|34|36|37|38|39|40))|13|70|71|72|73|21|22|23|(0)|26|27|28|30|31|33|34|36|37|38|39|40)|6|(0)(0)|9|10|11|(0)|13|70|71|72|73|21|22|23|(0)|26|27|28|30|31|33|34|36|37|38|39|40|(1:(0))) */
    /* JADX WARN: Code restructure failed: missing block: B:44:0x01bf, code lost:
    
        r0 = e;
     */
    /* JADX WARN: Code restructure failed: missing block: B:45:0x01c0, code lost:
    
        r10 = r1;
        r8 = r2;
     */
    /* JADX WARN: Code restructure failed: missing block: B:46:0x01c9, code lost:
    
        android.util.Log.e("RealRacing3", "extractAssets: Exception when saving new zip checksum " + r10.getAbsolutePath() + "\n" + r0.getMessage());
     */
    /* JADX WARN: Code restructure failed: missing block: B:47:0x01eb, code lost:
    
        closeStream(r11);
        closeStream(r8);
     */
    /* JADX WARN: Code restructure failed: missing block: B:48:0x01bc, code lost:
    
        r0 = th;
     */
    /* JADX WARN: Code restructure failed: missing block: B:49:0x01bd, code lost:
    
        r8 = r2;
     */
    /* JADX WARN: Code restructure failed: missing block: B:50:0x01f2, code lost:
    
        closeStream(r11);
        closeStream(r8);
     */
    /* JADX WARN: Code restructure failed: missing block: B:51:0x01f8, code lost:
    
        throw r0;
     */
    /* JADX WARN: Code restructure failed: missing block: B:52:0x01c5, code lost:
    
        r0 = e;
     */
    /* JADX WARN: Code restructure failed: missing block: B:53:0x01c6, code lost:
    
        r10 = r1;
     */
    /* JADX WARN: Code restructure failed: missing block: B:54:0x01c8, code lost:
    
        r0 = e;
     */
    /* JADX WARN: Code restructure failed: missing block: B:75:0x0146, code lost:
    
        r0 = e;
     */
    /* JADX WARN: Code restructure failed: missing block: B:76:0x0144, code lost:
    
        r0 = th;
     */
    /* JADX WARN: Code restructure failed: missing block: B:84:0x014c, code lost:
    
        r0 = e;
     */
    /* JADX WARN: Code restructure failed: missing block: B:85:0x014d, code lost:
    
        r12 = 0;
     */
    /* JADX WARN: Code restructure failed: missing block: B:86:0x0148, code lost:
    
        r0 = th;
     */
    /* JADX WARN: Code restructure failed: missing block: B:87:0x0149, code lost:
    
        r12 = 0;
     */
    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Removed duplicated region for block: B:25:0x0184  */
    /* JADX WARN: Removed duplicated region for block: B:77:0x0117 A[EXC_TOP_SPLITTER, SYNTHETIC] */
    /* JADX WARN: Removed duplicated region for block: B:88:0x00f4  */
    /* JADX WARN: Removed duplicated region for block: B:8:0x00ab  */
    /* JADX WARN: Type inference failed for: r12v1 */
    /* JADX WARN: Type inference failed for: r12v10 */
    /* JADX WARN: Type inference failed for: r12v11, types: [java.io.FileOutputStream] */
    /* JADX WARN: Type inference failed for: r12v12 */
    /* JADX WARN: Type inference failed for: r12v2 */
    /* JADX WARN: Type inference failed for: r12v3, types: [java.io.Closeable] */
    /* JADX WARN: Type inference failed for: r12v5, types: [java.io.Closeable] */
    /* JADX WARN: Type inference failed for: r12v7 */
    /* JADX WARN: Type inference failed for: r12v8 */
    /* JADX WARN: Type inference failed for: r12v9 */
    /* JADX WARN: Type inference failed for: r2v7, types: [java.io.Closeable, java.io.FileOutputStream] */
    /* JADX WARN: Type inference failed for: r9v0 */
    /* JADX WARN: Type inference failed for: r9v1 */
    /* JADX WARN: Type inference failed for: r9v2 */
    /* JADX WARN: Type inference failed for: r9v3, types: [java.io.Closeable] */
    /* JADX WARN: Type inference failed for: r9v4, types: [java.io.BufferedReader, java.io.Closeable] */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static boolean extractRes(java.lang.String r16, java.lang.String r17, android.content.Context r18) {
        /*
            Method dump skipped, instructions count: 586
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: com.firemint.realracing.Platform.extractRes(java.lang.String, java.lang.String, android.content.Context):boolean");
    }

    private static Map<String, String> LoadAssetCacheList(String str) {
        HashMap hashMap = new HashMap();
        File file = new File(str);
        if (file.exists()) {
            try {
                BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
                while (true) {
                    String readLine = bufferedReader.readLine();
                    if (readLine == null) {
                        break;
                    }
                    int indexOf = readLine.indexOf(9);
                    if (indexOf >= 0) {
                        hashMap.put(readLine.substring(readLine.charAt(0) == '/' ? 1 : 0, indexOf), readLine);
                    }
                }
                bufferedReader.close();
            } catch (Exception e) {
                Log.e("RealRacing3", "Exception when Loading asset cache list" + e.getMessage());
            }
        }
        return hashMap;
    }

    private static void deleteResAndRemoveEntriesFromCache(String str, Map<String, String> map) {
        RemoveEntriesFromPath(new File(str), "", map, true);
    }

    private static void RemoveEntriesFromPath(File file, String str, Map<String, String> map, boolean z) {
        if (file.isDirectory()) {
            if (!z) {
                str = str + file.getName() + "/";
            }
            File[] listFiles = file.listFiles();
            if (listFiles != null) {
                for (File file2 : listFiles) {
                    RemoveEntriesFromPath(file2, str, map, false);
                }
            }
        } else {
            map.remove(str + file.getName());
        }
        file.delete();
    }

    private static void removeAPKAssetsFromCache(String str, ZipFile zipFile, Map<String, String> map) {
        int i;
        String str2 = str + "/.depot";
        String str3 = str2 + "/asset_list_base.txtCache.txt";
        HashMap hashMap = new HashMap();
        try {
            MessageDigest messageDigest = MessageDigest.getInstance(SameMD5.TAG);
            byte[] bArr = new byte[8192];
            Enumeration<? extends ZipEntry> entries = zipFile.entries();
            while (true) {
                i = 0;
                if (!entries.hasMoreElements()) {
                    break;
                }
                ZipEntry nextElement = entries.nextElement();
                String name = nextElement.getName();
                if (name.startsWith("res/")) {
                    String substring = name.substring(4);
                    if (!substring.isEmpty() && !nextElement.isDirectory()) {
                        File file = new File(str2 + "/" + substring);
                        if (file.exists()) {
                            file.delete();
                        }
                        if (!substring.startsWith("asset_list")) {
                            messageDigest.reset();
                            try {
                                InputStream inputStream = zipFile.getInputStream(nextElement);
                                while (true) {
                                    int read = inputStream.read(bArr);
                                    if (read == -1) {
                                        break;
                                    } else {
                                        messageDigest.update(bArr, 0, read);
                                    }
                                }
                                inputStream.close();
                            } catch (IOException e) {
                                Log.e("RealRacing3", "Exception when reading zipfile" + e.getMessage());
                            }
                            byte[] digest = messageDigest.digest();
                            char[] cArr = new char[digest.length * 2];
                            while (i < digest.length) {
                                byte b = digest[i];
                                int i2 = i * 2;
                                char[] cArr2 = hexArray;
                                cArr[i2] = cArr2[(b & 255) >>> 4];
                                cArr[i2 + 1] = cArr2[b & Ascii.SI];
                                i++;
                            }
                            hashMap.put(substring, '/' + substring + '\t' + String.valueOf(cArr));
                        }
                    }
                }
            }
            try {
                Map<String, String> FixSpaTrackFolderName = FixSpaTrackFolderName(str2, map);
                FixSpaTrackFolderName.putAll(hashMap);
                ByteBuffer allocate = ByteBuffer.allocate(8);
                allocate.order(ByteOrder.LITTLE_ENDIAN);
                allocate.putInt((int) 2767647645L);
                allocate.putInt(4);
                File file2 = new File(str3);
                FileOutputStream fileOutputStream = new FileOutputStream(file2);
                fileOutputStream.write(allocate.array());
                fileOutputStream.write("0000\n".getBytes());
                fileOutputStream.flush();
                fileOutputStream.close();
                PrintWriter printWriter = new PrintWriter(new BufferedWriter(new FileWriter(file2, true)));
                Iterator<String> it = FixSpaTrackFolderName.values().iterator();
                while (it.hasNext()) {
                    printWriter.println(it.next());
                }
                printWriter.close();
            } catch (IOException e2) {
                Log.e("RealRacing3", "updateResources: Exception when accessing '" + str3 + "'\n" + e2.getMessage());
            }
            File[] listFiles = new File(str2).listFiles();
            if (listFiles != null) {
                while (i < listFiles.length) {
                    File file3 = listFiles[i];
                    String name2 = file3.getName();
                    if (name2.startsWith("asset_list") && !name2.startsWith("asset_list_updates") && !name2.equals("asset_list_base.txtCache.txt")) {
                        file3.delete();
                    }
                    i++;
                }
            }
        } catch (Exception e3) {
            Log.e("RealRacing3", "Exception when creating MessageDigest" + e3.getMessage());
        }
    }

    private static Map<String, String> FixSpaTrackFolderName(String str, Map<String, String> map) {
        try {
            File file = new File(str + "/Tracks");
            if (!file.isDirectory()) {
                return map;
            }
            for (String str2 : file.list()) {
                if (str2.equals("Spa")) {
                    File file2 = new File(file, str2);
                    if (!file2.isDirectory()) {
                        return map;
                    }
                    File file3 = new File(file, "spa-tmp");
                    if (!file2.renameTo(file3) || !file3.renameTo(new File(file, "spa"))) {
                        return map;
                    }
                    HashMap hashMap = new HashMap();
                    for (Map.Entry<String, String> entry : map.entrySet()) {
                        hashMap.put(entry.getKey(), entry.getValue().replaceFirst("/Tracks/Spa/", "/Tracks/spa/"));
                    }
                    return hashMap;
                }
            }
            return map;
        } catch (Exception e) {
            Log.e("RealRacing3", "Exception when attempting to rename spa folder: " + e.getMessage());
            return map;
        }
    }

    private static void extractResZipFile(ZipFile zipFile, String str, boolean z, String str2) {
        FileOutputStream fileOutputStream;
        InputStream inputStream;
        Enumeration<? extends ZipEntry> entries = zipFile.entries();
        while (entries.hasMoreElements()) {
            ZipEntry nextElement = entries.nextElement();
            String name = nextElement.getName();
            if (!name.isEmpty()) {
                File file = new File(str + "/" + name);
                if (nextElement.isDirectory()) {
                    if (!file.exists()) {
                        StringBuilder sb = new StringBuilder();
                        sb.append(str2);
                        sb.append(": creating directory '");
                        sb.append(name);
                        sb.append("'");
                        file.mkdirs();
                    }
                } else if (z || !file.exists() || file.length() != nextElement.getSize()) {
                    File parentFile = file.getParentFile();
                    if (!parentFile.exists()) {
                        StringBuilder sb2 = new StringBuilder();
                        sb2.append(str2);
                        sb2.append(": creating directory '");
                        sb2.append(parentFile.getPath());
                        sb2.append("'");
                        parentFile.mkdirs();
                    }
                    StringBuilder sb3 = new StringBuilder();
                    sb3.append(str2);
                    sb3.append(": extracting file '");
                    sb3.append(name);
                    sb3.append("'");
                    InputStream inputStream2 = null;
                    try {
                        inputStream = zipFile.getInputStream(nextElement);
                        try {
                            fileOutputStream = new FileOutputStream(file);
                        } catch (Exception e) {
                            e = e;
                            fileOutputStream = null;
                        } catch (Throwable th) {
                            th = th;
                            fileOutputStream = null;
                        }
                    } catch (Exception e2) {
                        e = e2;
                        fileOutputStream = null;
                    } catch (Throwable th2) {
                        th = th2;
                        fileOutputStream = null;
                    }
                    try {
                        saveStream(inputStream, fileOutputStream);
                        closeStream(inputStream);
                    } catch (Exception e3) {
                        e = e3;
                        inputStream2 = inputStream;
                        try {
                            Log.e("RealRacing3", str2 + ": Exception when extracting '" + name + "'\n" + e.getMessage());
                            closeStream(inputStream2);
                            closeStream(fileOutputStream);
                        } catch (Throwable th3) {
                            th = th3;
                            closeStream(inputStream2);
                            closeStream(fileOutputStream);
                            throw th;
                        }
                    } catch (Throwable th4) {
                        th = th4;
                        inputStream2 = inputStream;
                        closeStream(inputStream2);
                        closeStream(fileOutputStream);
                        throw th;
                    }
                    closeStream(fileOutputStream);
                }
            }
        }
    }

    public static boolean deleteDir(File file, boolean z) {
        File[] listFiles;
        if (file.isDirectory() && (listFiles = file.listFiles()) != null) {
            for (File file2 : listFiles) {
                if (!deleteDir(file2, false)) {
                    return false;
                }
            }
        }
        if (z) {
            return true;
        }
        return file.delete();
    }

    public static boolean deleteDirectory(String str) {
        return deleteDir(new File(str), false);
    }

    private static void saveStream(InputStream inputStream, FileOutputStream fileOutputStream) throws IOException {
        byte[] bArr = new byte[8192];
        while (true) {
            int read = inputStream.read(bArr);
            if (read == -1) {
                return;
            } else {
                fileOutputStream.write(bArr, 0, read);
            }
        }
    }

    private static void closeStream(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException unused) {
            }
        }
    }

    public static void openURL(String str) {
        Log.e("RealRacing3", "Opening URL '" + str + "'");
        try {
            AppProxy.GetContext().startActivity(new Intent("android.intent.action.VIEW").setData(Uri.parse(str)));
        } catch (ActivityNotFoundException unused) {
            MainActivity.logi("openURL failed as there is no activity to handle it");
        } catch (SecurityException unused2) {
            MainActivity.logi("openURL failed because of a security exception");
        }
    }

    public static int getScreenWidth() {
        WindowMetrics currentWindowMetrics;
        Rect bounds;
        if (MainActivity.IsAtLeastAPI(30)) {
            currentWindowMetrics = AppProxy.GetActivity().getWindowManager().getCurrentWindowMetrics();
            bounds = currentWindowMetrics.getBounds();
            return bounds.width();
        }
        DisplayMetrics displayMetrics = new DisplayMetrics();
        AppProxy.GetActivity().getWindowManager().getDefaultDisplay().getRealMetrics(displayMetrics);
        return displayMetrics.widthPixels;
    }

    public static int getScreenHeight() {
        WindowMetrics currentWindowMetrics;
        Rect bounds;
        if (Build.VERSION.SDK_INT >= 30) {
            currentWindowMetrics = AppProxy.GetActivity().getWindowManager().getCurrentWindowMetrics();
            bounds = currentWindowMetrics.getBounds();
            return bounds.height();
        }
        DisplayMetrics displayMetrics = new DisplayMetrics();
        AppProxy.GetActivity().getWindowManager().getDefaultDisplay().getRealMetrics(displayMetrics);
        return displayMetrics.heightPixels;
    }

    public static int getScreenDPI() {
        return AppProxy.GetContext().getResources().getConfiguration().densityDpi;
    }

    /* JADX WARN: Code restructure failed: missing block: B:13:0x003b, code lost:
    
        r1 = r1[1].trim().split(" ");
        r4 = r1[0];
     */
    /* JADX WARN: Code restructure failed: missing block: B:15:0x0049, code lost:
    
        r2 = java.lang.Integer.parseInt(r1[0].trim()) / 1024;
     */
    /* JADX WARN: Code restructure failed: missing block: B:19:0x0058, code lost:
    
        r1 = move-exception;
     */
    /* JADX WARN: Code restructure failed: missing block: B:20:0x0059, code lost:
    
        r1.toString();
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static int getTotalMemory() {
        /*
            java.io.File r0 = new java.io.File
            java.lang.String r1 = "/proc/meminfo"
            r0.<init>(r1)
            boolean r1 = r0.exists()
            r2 = 0
            if (r1 == 0) goto L77
            java.io.FileReader r1 = new java.io.FileReader     // Catch: java.lang.Exception -> L56
            r1.<init>(r0)     // Catch: java.lang.Exception -> L56
            java.io.BufferedReader r3 = new java.io.BufferedReader     // Catch: java.lang.Exception -> L56
            r3.<init>(r1)     // Catch: java.lang.Exception -> L56
        L18:
            java.lang.String r1 = r3.readLine()     // Catch: java.lang.Exception -> L56
            if (r1 == 0) goto L5c
            java.lang.String r4 = ":"
            java.lang.String[] r1 = r1.split(r4)     // Catch: java.lang.Exception -> L56
            r4 = r1[r2]     // Catch: java.lang.Exception -> L56
            r4 = 1
            r5 = r1[r4]     // Catch: java.lang.Exception -> L56
            r5 = r1[r2]     // Catch: java.lang.Exception -> L56
            java.lang.String r5 = r5.trim()     // Catch: java.lang.Exception -> L56
            java.lang.String r5 = r5.toLowerCase()     // Catch: java.lang.Exception -> L56
            java.lang.String r6 = "memtotal"
            boolean r5 = r5.equals(r6)     // Catch: java.lang.Exception -> L56
            if (r5 == 0) goto L18
            r1 = r1[r4]     // Catch: java.lang.Exception -> L56
            java.lang.String r1 = r1.trim()     // Catch: java.lang.Exception -> L56
            java.lang.String r4 = " "
            java.lang.String[] r1 = r1.split(r4)     // Catch: java.lang.Exception -> L56
            r4 = r1[r2]     // Catch: java.lang.Exception -> L56
            r1 = r1[r2]     // Catch: java.lang.Exception -> L56 java.lang.NumberFormatException -> L58
            java.lang.String r1 = r1.trim()     // Catch: java.lang.Exception -> L56 java.lang.NumberFormatException -> L58
            int r1 = java.lang.Integer.parseInt(r1)     // Catch: java.lang.Exception -> L56 java.lang.NumberFormatException -> L58
            int r2 = r1 / 1024
            goto L5c
        L56:
            r1 = move-exception
            goto L60
        L58:
            r1 = move-exception
            r1.toString()     // Catch: java.lang.Exception -> L56
        L5c:
            r3.close()     // Catch: java.lang.Exception -> L56
            goto L77
        L60:
            java.lang.String r0 = r0.getAbsolutePath()
            java.lang.String r1 = r1.getMessage()
            java.lang.Object[] r0 = new java.lang.Object[]{r0, r1}
            java.lang.String r1 = "Error reading system file: %s (%s)"
            java.lang.String r0 = java.lang.String.format(r1, r0)
            java.lang.String r1 = "RealRacing3"
            android.util.Log.e(r1, r0)
        L77:
            java.lang.StringBuilder r0 = new java.lang.StringBuilder
            r0.<init>()
            java.lang.String r1 = "totalmemory="
            r0.append(r1)
            r0.append(r2)
            return r2
        */
        throw new UnsupportedOperationException("Method not decompiled: com.firemint.realracing.Platform.getTotalMemory():int");
    }

    public static void exitApp() {
        final Activity GetActivity = AppProxy.GetActivity();
        if (GetActivity != null) {
            GetActivity.runOnUiThread(new Runnable() { // from class: com.firemint.realracing.Platform.5
                @Override // java.lang.Runnable
                public void run() {
                    GetActivity.moveTaskToBack(true);
                    GetActivity.finish();
                }
            });
        }
    }

    public static String getLocale() {
        String locale = Locale.getDefault().toString();
        StringBuilder sb = new StringBuilder();
        sb.append("locale = ");
        sb.append(locale);
        return locale;
    }

    public static String getCountry() {
        return Locale.getDefault().getCountry();
    }

    public enum NetworkType {
        Carrier(1),
        Wifi(2),
        Ethernet(4),
        Unmetered(8),
        Any(-1);

        int value;

        NetworkType(int i) {
            this.value = i;
        }
    }

    /* JADX WARN: Code restructure failed: missing block: B:10:0x002c, code lost:
    
        if (r0.isAvailable() != false) goto L12;
     */
    /* JADX WARN: Code restructure failed: missing block: B:20:0x0044, code lost:
    
        if (r0.getType() != 9) goto L13;
     */
    /* JADX WARN: Code restructure failed: missing block: B:24:0x0052, code lost:
    
        if (r0.getType() == 1) goto L25;
     */
    /* JADX WARN: Code restructure failed: missing block: B:25:0x0054, code lost:
    
        r1 = true;
     */
    /* JADX WARN: Code restructure failed: missing block: B:27:?, code lost:
    
        return r1 & true;
     */
    /* JADX WARN: Code restructure failed: missing block: B:31:0x0062, code lost:
    
        if (r0.getType() == 9) goto L25;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static boolean isNetworkAvailable(int r5) {
        /*
            android.content.Context r0 = com.firemint.realracing.AppProxy.GetContext()
            r1 = 0
            if (r0 == 0) goto L74
            android.content.Context r0 = com.firemint.realracing.AppProxy.GetContext()
            java.lang.String r2 = "connectivity"
            java.lang.Object r0 = r0.getSystemService(r2)
            android.net.ConnectivityManager r0 = (android.net.ConnectivityManager) r0
            android.net.NetworkInfo r0 = r0.getActiveNetworkInfo()
            if (r0 == 0) goto L74
            com.firemint.realracing.Platform$NetworkType r2 = com.firemint.realracing.Platform.NetworkType.Any
            int r2 = r2.value
            r3 = r5 & r2
            r4 = 1
            if (r3 != r2) goto L31
            boolean r5 = r0.isConnected()
            if (r5 == 0) goto L2f
            boolean r5 = r0.isAvailable()
            if (r5 == 0) goto L2f
        L2e:
            r1 = r4
        L2f:
            r1 = r1 & r4
            goto L74
        L31:
            com.firemint.realracing.Platform$NetworkType r2 = com.firemint.realracing.Platform.NetworkType.Unmetered
            int r2 = r2.value
            r2 = r2 & r5
            r3 = 9
            if (r2 == 0) goto L47
            int r5 = r0.getType()
            if (r5 == r4) goto L2e
            int r5 = r0.getType()
            if (r5 != r3) goto L2f
            goto L2e
        L47:
            com.firemint.realracing.Platform$NetworkType r2 = com.firemint.realracing.Platform.NetworkType.Wifi
            int r2 = r2.value
            r2 = r2 & r5
            if (r2 == 0) goto L57
            int r5 = r0.getType()
            if (r5 != r4) goto L55
        L54:
            r1 = r4
        L55:
            r1 = r1 & r4
            goto L74
        L57:
            com.firemint.realracing.Platform$NetworkType r2 = com.firemint.realracing.Platform.NetworkType.Ethernet
            int r2 = r2.value
            r2 = r2 & r5
            if (r2 == 0) goto L65
            int r5 = r0.getType()
            if (r5 != r3) goto L55
            goto L54
        L65:
            com.firemint.realracing.Platform$NetworkType r0 = com.firemint.realracing.Platform.NetworkType.Carrier
            int r0 = r0.value
            r5 = r5 & r0
            if (r5 == 0) goto L73
            boolean r5 = isMobileDataAvailable()
            r1 = r5 & 1
            goto L74
        L73:
            r1 = r4
        L74:
            return r1
        */
        throw new UnsupportedOperationException("Method not decompiled: com.firemint.realracing.Platform.isNetworkAvailable(int):boolean");
    }

    public static String GetWifiSSID() {
        return isNetworkAvailable(NetworkType.Wifi.value) ? ((WifiManager) AppProxy.GetContext().getSystemService("wifi")).getConnectionInfo().getSSID() : "";
    }

    public static boolean isMobileDataAvailable() {
        if (AppProxy.GetContext() == null) {
            return false;
        }
        ConnectivityManager connectivityManager = (ConnectivityManager) AppProxy.GetContext().getSystemService("connectivity");
        connectivityManager.getNetworkInfo(0);
        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
        boolean z = activeNetworkInfo != null && activeNetworkInfo.isConnectedOrConnecting();
        if (z && activeNetworkInfo.getType() != 6) {
            switch (activeNetworkInfo.getSubtype()) {
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                case 8:
                case 9:
                case 10:
                case 11:
                case 12:
                case 13:
                case 14:
                case 15:
                    break;
                default:
                    return false;
            }
        }
        return z;
    }

    public static String getMobileDataType() {
        String str;
        if (AppProxy.GetContext() != null) {
            ConnectivityManager connectivityManager = (ConnectivityManager) AppProxy.GetContext().getSystemService("connectivity");
            connectivityManager.getNetworkInfo(0);
            NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
            if (activeNetworkInfo != null && activeNetworkInfo.isConnectedOrConnecting() && activeNetworkInfo.getType() != 6) {
                str = activeNetworkInfo.getSubtypeName();
                StringBuilder sb = new StringBuilder();
                sb.append("getMobileDataType subtype=");
                sb.append(str);
                return str;
            }
        }
        str = "";
        StringBuilder sb2 = new StringBuilder();
        sb2.append("getMobileDataType subtype=");
        sb2.append(str);
        return str;
    }

    public static void showMessage(String str, String str2, String str3, String str4, String str5, long j, long j2, long j3) {
        MainActivity mainActivity = MainActivity.instance;
        if (mainActivity != null) {
            mainActivity.showMessage(str, str2, str3, str4, str5, j, j2, j3);
        }
    }

    public static void dismissMessage() {
        MainActivity mainActivity = MainActivity.instance;
        if (mainActivity != null) {
            mainActivity.dismissMessage();
        }
    }

    public static void openNetworkSettings() {
        if (MainActivity.instance != null) {
            MainActivity.m_WIFISettingsShown = true;
            MainActivity.instance.startActivityForResult(new Intent("android.settings.WIFI_SETTINGS"), 329418467);
        }
    }

    public static boolean isNetworkSettingsShown() {
        return MainActivity.m_WIFISettingsShown;
    }

    public static String getCarrier() {
        return ((TelephonyManager) AppProxy.GetContext().getSystemService("phone")).getNetworkOperatorName();
    }

    public static void setCrashlyticsInt(int i, String str) {
        FirebaseCrashlytics.getInstance().setCustomKey(str, i);
    }

    public static void setCrashlyticsFloat(float f, String str) {
        FirebaseCrashlytics.getInstance().setCustomKey(str, f);
    }

    public static void setCrashlyticsString(String str, String str2) {
        FirebaseCrashlytics.getInstance().setCustomKey(str2, str);
    }

    public static void addCrashlyticsLogEvent(String str) {
        FirebaseCrashlytics.getInstance().log(str);
    }

    public static void addAnalyticsLogEvent(String str, String[] strArr, String[] strArr2) {
        int length;
        Bundle bundle = new Bundle();
        if (strArr.length != strArr2.length) {
            length = strArr.length > strArr2.length ? strArr2.length : strArr.length;
        } else {
            length = strArr.length;
        }
        for (int i = 0; i < length; i++) {
            bundle.putString(strArr[i], strArr2[i]);
        }
        MainActivity.instance.getFirebaseAnalyticsInstance().logEvent(str, bundle);
    }

    public static void addLevelAnalyticsLogEvent(int i, int i2, int i3) {
        Bundle bundle = new Bundle();
        bundle.putInt("Driver_Level", i);
        bundle.putInt("Spender_Level", i2);
        bundle.putInt("Game_Version", i3);
        MainActivity.instance.getFirebaseAnalyticsInstance().logEvent("RR3_Game_Level", bundle);
        Bundle bundle2 = new Bundle();
        bundle2.putString("character", "Driver_Level");
        bundle2.putLong(AppLovinEventTypes.USER_COMPLETED_LEVEL, i);
        MainActivity.instance.getFirebaseAnalyticsInstance().logEvent("level_up", bundle2);
    }

    public static void testCrashlyticsCrash() {
        throw new RuntimeException("This is a crash");
    }

    public static String getCarrierName() {
        return AppProxy.GetContext().getString(R.string.carrier);
    }

    public static String getCloudcellEnvironment() {
        return AppProxy.GetContext().getString(R.string.cc_server_env);
    }

    public static String getStarlightEnvironment() {
        return AppProxy.GetContext().getString(R.string.starlight_env);
    }

    public static void OnLegalOptOutChanged(boolean z) {
        MainActivity.instance.OnLegalOptOutChanged(z);
    }

    public static void InitialiseSingular(String str, String str2) {
        Singular.init(AppProxy.GetContext(), new SingularConfig(str, str2));
    }

    public static void SetSingularCustomUserId(String str) {
        Singular.setCustomUserId(str);
    }

    public static void UnsetSingularCustomUserId() {
        Singular.unsetCustomUserId();
    }

    public static void SingularEvent(String str) {
        Singular.event(str);
    }

    public static void SingularRevenue(String str, double d) {
        Singular.revenue(str, d);
    }

    public static void SingularRevenueWithProductDetails(String str, double d, String str2, String str3, String str4, int i, double d2) {
        Singular.revenue(str, d, str2, str3, str4, i, d2);
    }

    public static void SingularRevenueWithPurchaseReceipt(String str, double d, Object obj) {
        Singular.revenue(str, d, obj);
    }

    public static void SetClipboardText(String str) {
        Context GetContext = AppProxy.GetContext();
        ((ClipboardManager) GetContext.getSystemService("clipboard")).setPrimaryClip(ClipData.newPlainText(GetContext.getResources().getString(R.string.app_name), str));
    }

    public static float GetFloatValueFromRemoteConfig(String str) {
        return (float) MainActivity.instance.getFirebaseRemoteConfigInstance().getDouble(str);
    }

    public static String GetStringValueFromRemoteConfig(String str) {
        return MainActivity.instance.getFirebaseRemoteConfigInstance().getString(str);
    }

    public static boolean GetBooleanValueFromRemoteConfig(String str) {
        return MainActivity.instance.getFirebaseRemoteConfigInstance().getBoolean(str);
    }
}