package com.ea.ironmonkey;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.ActivityManager;
import android.app.AlertDialog;
import android.app.PendingIntent;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.PackageManager;
import android.content.res.AssetManager;
import android.content.res.Configuration;
import android.graphics.Rect;
import android.hardware.Sensor;
import android.hardware.SensorManager;
import android.media.AudioManager;
import android.net.Uri;
import android.opengl.GLES20;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.PowerManager;
import android.os.Process;
import android.provider.Settings;
import android.util.DisplayMetrics;
import android.view.Display;
import android.view.DisplayCutout;
import android.view.KeyEvent;
import android.view.OrientationEventListener;
import android.view.View;
import android.view.ViewParent;
import android.view.WindowManager;
import android.view.inputmethod.InputMethodManager;
import android.widget.FrameLayout;

import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ComponentActivity;

import com.ea.EAIO.EAIO;
import com.ea.EAMIO.StorageDirectory;
import com.ea.nimble.ApplicationLifecycle;
import com.ea.nimble.Global;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import com.google.gson.reflect.TypeToken;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.TimeUnit;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import org.fmod.FMODAudioDevice;

/* loaded from: classes.dex */
public class GameActivityMain extends AppCompatActivity implements DrawFrameListener {
    private static final String DOWNLOAD_PROPERTIES = "downloadcontent/config.properties";
    public static final int LIFECYCLE_CREATED = 1;
    public static final int LIFECYCLE_DESTROYED = 5;
    public static final int LIFECYCLE_NONE = 0;
    public static final int LIFECYCLE_RUNNING = 3;
    public static final int LIFECYCLE_STARTED = 2;
    public static final int LIFECYCLE_STOPPED = 4;
    private static String SDCARD_DATA_FOLDER = "";
    public static final int STATE_ADC_PROCESS = 4;
    public static final int STATE_ADC_START = 3;
    public static final int STATE_FULL_PROCESS = 6;
    public static final int STATE_FULL_START = 5;
    public static final int STATE_GAME_START = 8;
    public static final int STATE_GOOGLE_DRM = 2;
    public static final int STATE_RESTORE_CONTEXT = 7;
    public static final int STATE_SPLASH = 0;
    public static final int STATE_SPLASH_PROCESS = 1;
    public static final String TAG = "GameActivityMain";
    private static boolean assetsReady;
    public static GameActivityMain instance;
    private static boolean isAmazonDev;
    private static AudioManager mAudioManager;
    private static int oldState;
    private static boolean sIsOtherMusicPlaying;
    public static int state;
    private Accelerometer accelerometer;
    private GameGLSurfaceView gameGLSurfaceView;
    private GameRenderer gameRenderer;
    private Handler handler;
    private int laststate;
    private int lifecycle;
    private AlertDialog.Builder mAd;
    private FMODAudioDevice mFMODAudioDevice;
    private FrameLayout mFrameLayout;
    private OrientationEventListener mOrientationListener;
    private Map mResources;
    private PowerManager.WakeLock mWakeLock;
    public int naturalOrientation;
    private RunLoop runLoop;
    private SplashScreen splash;
    private int splashCounter;
    private long splashDelay;
    private long splashTimer;
    private boolean isXperiaPlay = false;
    private boolean isSleepModeEnabled = true;
    private int mRotation = 0;
    private AssetLocationType mAssetLocationType = AssetLocationType.EXTERNAL;
    private String[] lifecycleNames = {"LIFECYCLE_NONE", "LIFECYCLE_CREATED", "LIFECYCLE_STARTED", "LIFECYCLE_RUNNING", "LIFECYCLE_STOPPED", "LIFECYCLE_DESTROYED"};

    public File getSave() {
        return save;
    }

    public void setSave(File save) {
        this.save = save;
    }

    enum AssetLocationType {
        EXTERNAL,
        ASSETS,
        OBB
    }

    private void updateRequestedOrientation(int i) {
    }

    public boolean IsSystemKey(int i) {
        if (i == 3 || i == 91) {
            return true;
        }
        switch (i) {
            case 5:
            case 6:
                return true;
            default:
                switch (i) {
                    case 24:
                    case 25:
                    case 26:
                    case 27:
                        return true;
                    default:
                        return false;
                }
        }
    }

    public native void nativeOnCreate();

    public native void nativeOnDestroy();

    public native void nativeOnMusicPlayerStateChanged();

    public native void nativeOnOrientationChange(int i);

    public native void nativeOnPause();

    public native void nativeOnPhysicalKeyDown(int i, int i2);

    public native void nativeOnPhysicalKeyUp(int i, int i2);

    public native void nativeOnPhysicalKeyboardVisibilityChanged(boolean z);

    public native void nativeOnPhysicalNavigationVisibilityChanged(boolean z);

    public native void nativeOnRestart();

    public native void nativeOnResume();

    public native void nativeOnStart();

    public native void nativeOnStop();

    public native boolean nativeRestoreContext();

    public native void nativeSurfaceChanged(GL10 gl10, int i, int i2);

    public native void nativeSurfaceCreated(GL10 gl10, EGLConfig eGLConfig);

    @Override // android.app.Activity
    public void onCreate(Bundle bundle) {
        restoreSave();
        Log.setEnable(true);
        Log.i(TAG, "onCreate");
        super.onCreate(bundle);
        instance = this;
        if (this.lifecycle == 5) {
            Log.w(TAG, "onCreate called on destroyed app, finishing");
            finish();
            return;
        }
        if (this.lifecycle >= 1) {
            Log.w(TAG, "onCreate ignored, lifecycle is already " + this.lifecycleNames[this.lifecycle]);
            return;
        }
        this.handler = new Handler();
        setLifecycle(1);
        Log.d("Model", Build.MODEL);
        if (Build.MODEL.length() > 4 && Build.MODEL.substring(0, 4).equals("R800")) {
            this.isXperiaPlay = true;
        }
        String packageName = getPackageName();
        if (packageName.endsWith("_azn_na") || packageName.endsWith("_azn_row")) {
            Log.d(TAG, "It's Amazon dev");
            isAmazonDev = true;
        }
        if (!isAtLeastAPI(18) && getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
        }
        if (isAtLeastAPI(28)) {
            getWindow().getAttributes().layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES;
            getWindow().addFlags(67108864);
        }
        getWindow().setFlags(1024, 1024);
        requestWindowFeature(1);
        this.mOrientationListener = new OrientationEventListener(getApplicationContext()) { // from class: com.ea.ironmonkey.GameActivityMain.1
            @Override // android.view.OrientationEventListener
            public void onOrientationChanged(int i) {
                int rotation;
                if (GameActivityMain.this.accelerometer == null || GameActivityMain.this.mRotation == (rotation = GameActivityMain.this.getWindow().getWindowManager().getDefaultDisplay().getRotation())) {
                    return;
                }
                GameActivityMain.this.mRotation = rotation;
                if (Settings.System.getInt(GameActivityMain.this.getContentResolver(), "accelerometer_rotation", 0) == 1 || !GameActivityMain.isAtLeastAPI(18) || GameActivityMain.isAmazonDev) {
                    GameActivityMain.this.accelerometer.updateOrientation(GameActivityMain.this.mRotation);
                    GameActivityMain.this.nativeOnOrientationChange(GameActivityMain.this.mRotation);
                    Log.d(GameActivityMain.TAG, "OrientationEventListener::onOrientationChanged mRotation = " + Integer.toString(GameActivityMain.this.mRotation));
                    return;
                }
                Log.d(GameActivityMain.TAG, "OrientationEventListener::onOrientationChanged rotation disabled!");
            }
        };
        if (this.mOrientationListener.canDetectOrientation()) {
            this.mOrientationListener.enable();
        }
        mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
        sIsOtherMusicPlaying = mAudioManager.isMusicActive();
        Log.i(TAG, "onCreate() isMusicActive = " + Boolean.toString(sIsOtherMusicPlaying));
        this.mFMODAudioDevice = new FMODAudioDevice();
        if (isAmazonDev) {
            try {
                Log.d(TAG, "onCreate open resources.json");
                InputStream open = getAssetManager().open("resources.json");
                this.mResources = new Gson().fromJson(new InputStreamReader(open), new TypeToken<Map<String, Map<String, FSNode>>>() { // from class: com.ea.ironmonkey.GameActivityMain.2
                }.getType());
                Log.d(TAG, "onCreate resources.json contains " + Integer.toString(this.mResources.size()) + " items");
                open.close();
                this.mAssetLocationType = AssetLocationType.ASSETS;
            } catch (Exception e) {
                Log.d(TAG, "onCreate exception on opening resources.json");
                Log.e(TAG, e.getMessage());
                this.mResources = new HashMap();
            }
        }
        if (this.mAssetLocationType != AssetLocationType.ASSETS) {
            try {
                InputStream open2 = getResources().getAssets().open("obb.size");
                if (open2 != null) {
                    this.mAssetLocationType = AssetLocationType.OBB;
                    open2.close();
                }
            } catch (IOException e2) {
                Log.e(TAG, e2.getMessage());
            }
        }
        SensorManager sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        Sensor defaultSensor = sensorManager.getDefaultSensor(1);
        int rotation = getWindow().getWindowManager().getDefaultDisplay().getRotation();
        switch (rotation) {
            case 0:
                Log.d(TAG, "Orientation: ROTATION_0");
                break;
            case 1:
                Log.d(TAG, "Orientation: ROTATION_90");
                break;
            case 2:
                Log.d(TAG, "Orientation: ROTATION_180");
                break;
            case 3:
                Log.d(TAG, "Orientation: ROTATION_270");
                break;
        }
        this.mRotation = rotation;
        updateRequestedOrientation(rotation);
        if (defaultSensor != null) {
            this.accelerometer = new Accelerometer(sensorManager, defaultSensor, rotation);
        }
        this.gameGLSurfaceView = new GameGLSurfaceView(this);
        this.gameRenderer = new GameRenderer(this);
        this.gameRenderer.setDrawFrameListener(this);
        this.gameGLSurfaceView.setRenderer(this.gameRenderer);
        this.runLoop = new RunLoop(this.gameGLSurfaceView);
        this.mFrameLayout = new FrameLayout(this);
        this.mFrameLayout.addView(this.gameGLSurfaceView);
        setContentView(this.mFrameLayout);
        System.loadLibrary("fmodex");
        System.loadLibrary("fmodevent");
        System.loadLibrary("c++_shared");
        System.loadLibrary(Global.NIMBLE_ID);
        System.loadLibrary("app");
        Log.d(TAG, "Init EAIO/EAMIO");
        EAIO.Startup(this);
        StorageDirectory.Startup(this);
        ApplicationLifecycle.onActivityCreate(bundle, this);
        Log.d(TAG, "nativeOnCreate");
        nativeOnCreate();
    }

    public String[] forEach(String input) {
        return new String[] { input };
    }

    public int getAssetSize(String str) {
        Log.d(TAG, "getAssetSize filename = " + str);
        File file = new File(str);
        String parent = file.getParent();
        if (parent == null) {
            if (this.mResources.containsKey(str)) {
                Log.d(TAG, "getAssetSize mResources contains " + str);
                return -1;
            }
            Log.d(TAG, "getAssetSize mResources not contains " + str);
        } else {
            Log.d(TAG, "getAssetSize path = " + parent);
            if (this.mResources.containsKey(parent)) {
                Log.d(TAG, "getAssetSize mResources contains " + parent);
                Map<String, FSNode> map = (Map<String, FSNode>) this.mResources.get(parent);
                String name = file.getName();
                Log.d(TAG, "getAssetSize name = " + name);
                if (map.containsKey(name)) {
                    Log.d(TAG, "getAssetSize dir contains " + name);
                    FSNode fSNode = map.get(name);
                    int i = fSNode.directory ? -1 : fSNode.size;
                    Log.d(TAG, "getAssetSize filename = " + str + ", directory = " + Boolean.toString(fSNode.directory) + ", size = " + Integer.toString(fSNode.size));
                    return i;
                }
                Log.d(TAG, "getAssetSize dir not contains " + name);
            } else {
                Log.d(TAG, "getAssetSize mResources not contains " + parent);
            }
        }
        return -2;
    }

    public boolean isObbAssets() {
        return this.mAssetLocationType == AssetLocationType.OBB;
    }

    public boolean isFullApkAssets() {
        return this.mAssetLocationType == AssetLocationType.ASSETS;
    }

    public boolean useAssetsFileSystem() {
        return this.mAssetLocationType != AssetLocationType.EXTERNAL;
    }

    private int getVersionCode() {
        try {
            return getPackageManager().getPackageInfo(getPackageName(), 0).versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
            return 0;
        }
    }

    public String getObbFullPath() {
        Log.i(this.getClass().getName(), getObbDir() + "/" + ObbHelper.getObbFileName(this, getVersionCode()));
        return getObbDir() + "/" + ObbHelper.getObbFileName(this, getVersionCode());
    }

    public AssetManager getAssetManager() {
        return getResources().getAssets();
    }

    public static boolean isAnyMusicPlaying() {
        return sIsOtherMusicPlaying;
    }

    public static boolean isAmazon() {
        return isAmazonDev;
    }

    public static boolean isAtLeastAPI(int i) {
        return Build.VERSION.SDK_INT >= i;
    }

    public void enableSleepMode() {
        if (this.isSleepModeEnabled) {
            return;
        }
        this.isSleepModeEnabled = true;
        wakeLockRelease();
    }

    public void disableSleepMode() {
        if (this.isSleepModeEnabled) {
            this.isSleepModeEnabled = false;
            wakeLockAcquire();
        }
    }

    private void checkAnyMusicActive() {
        if (mAudioManager != null) {
            sIsOtherMusicPlaying = mAudioManager.isMusicActive();
            nativeOnMusicPlayerStateChanged();
        }
    }

    @Override // android.app.Activity
    public void onStart() {
        CallGC();
        Log.i(TAG, "onStart");
        super.onStart();
        Log.i(TAG, "onStart 1");
        wakeLockAcquire();
        Log.i(TAG, "onStart 2");
        if (this.lifecycle >= 2 && this.lifecycle < 4) {
            Log.w(TAG, "onStart ignored, lifecycle is already " + this.lifecycleNames[this.lifecycle]);
            return;
        }
        Log.i(TAG, "onStart 3");
        setLifecycle(2);
        Log.i(TAG, "nativeOnStart");
        nativeOnStart();
        Log.i(TAG, "nativeOnStart - end");
        if (this.isXperiaPlay) {
            switch (getResources().getConfiguration().navigationHidden) {
                case 1:
                    nativeOnPhysicalNavigationVisibilityChanged(true);
                    break;
                case 2:
                    nativeOnPhysicalNavigationVisibilityChanged(false);
                    break;
            }
        }
        Log.i(TAG, "ApplicationLifecycle");
        ApplicationLifecycle.onActivityStart(this);
    }

    // Методы для воостановления сейва и его сохранения чтобы всегда использовать внешний сейв

    private String saveFileName = "nfstr_save.sb";
    private File save = null;
    private File externalSave = new File(Environment.getStorageDirectory(),"games/nfsmw/nfstr_save.sb");

    // Сохранить
    private void storeSave() {
        try {
            save = new File(getFilesDir(), "var/nfstr_save.sb");

            // Создаем директории, если они не существуют
            externalSave.getParentFile().mkdirs();

            // Копируем файл из внутреннего хранилища во внешнее
            try (InputStream in = new FileInputStream(save);
                 OutputStream out = new FileOutputStream(externalSave)) {
                byte[] buf = new byte[1024];
                int len;
                while ((len = in.read(buf)) > 0) {
                    out.write(buf, 0, len);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            // Обработка ошибки сохранения
        }
    }

    // Восстановить
    private void restoreSave() {
        try {
            save = new File(getFilesDir(), "var/nfstr_save.sb");
            // Проверяем, существует ли внешний файл
            if (!externalSave.exists()) {
                return; // ничего не делаем, если файла нет
            }

            // Создаем директории для внутреннего файла, если нужно
            save.getParentFile().mkdirs();

            // Копируем файл из внешнего хранилища во внутреннее
            try (InputStream in = new FileInputStream(externalSave);
                 OutputStream out = new FileOutputStream(save)) {
                byte[] buf = new byte[1024];
                int len;
                while ((len = in.read(buf)) > 0) {
                    out.write(buf, 0, len);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            // Обработка ошибки восстановления
        }
    }

    @Override // android.app.Activity
    public void onRestart() {
        Log.i(TAG, "onRestart");
        super.onRestart();
        ApplicationLifecycle.onActivityRestart(this);
        nativeOnRestart();
    }

    @Override // android.app.Activity
    public void onPause() {
        Log.i(TAG, "onPause state=" + state);
        super.onPause();
        this.mFMODAudioDevice.stop();
        if (this.mOrientationListener.canDetectOrientation()) {
            this.mOrientationListener.disable();
        }
        if (this.lifecycle != 3) {
            Log.w(TAG, "onPause ignored, lifecycle is currently " + this.lifecycleNames[this.lifecycle]);
            return;
        }
        setLifecycle(2);
        this.gameGLSurfaceView.onPause();
        ApplicationLifecycle.onActivityPause(this);
        nativeOnPause();
        this.splash = null;
    }

    private void ForceHideVirtualKeyboard() {
        View currentFocus = getCurrentFocus();
        if (currentFocus != null) {
            ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(currentFocus.getWindowToken(), 0);
        }
        getWindow().setSoftInputMode(3);
    }

    @Override // android.app.Activity
    public void onResume() {
        Log.i(TAG, "onResume");
        super.onResume();
        if (state != 7) {
            oldState = state;
            state = 7;
            this.gameRenderer.setDrawFrameListener(this);
        }
        if (this.mOrientationListener.canDetectOrientation()) {
            this.mOrientationListener.enable();
        }
        if (this.lifecycle == 3) {
            Log.w(TAG, "onResume ignored, lifecycle is currently " + this.lifecycleNames[this.lifecycle]);
            return;
        }
        setLifecycle(3);
        this.gameGLSurfaceView.onResume();
        ApplicationLifecycle.onActivityResume(this);
        nativeOnResume();
        checkAnyMusicActive();
        this.mFMODAudioDevice.start();
        Log.i(TAG, "onResume() isMusicActive = " + Boolean.toString(sIsOtherMusicPlaying));
    }

    @Override // android.app.Activity
    public void onStop() {
        Log.i(TAG, "onStop");
        super.onStop();
        if (this.lifecycle >= 4) {
            Log.w(TAG, "onStop ignored, lifecycle is already " + this.lifecycleNames[this.lifecycle]);
            return;
        }
        setLifecycle(4);
        wakeLockRelease();
        nativeOnStop();
    }

    @Override // android.app.Activity
    public void onDestroy() {
        Log.i(TAG, "onDestroy");
        super.onDestroy();
        if (this.lifecycle >= 5) {
            Log.w(TAG, "onDestroy ignored, lifecycle is already " + this.lifecycleNames[this.lifecycle]);
            return;
        }
        setLifecycle(5);
        storeSave();
        if (state == 8) {
            ApplicationLifecycle.onActivityDestroy(this);
            nativeOnDestroy();
        }
        StorageDirectory.Shutdown();
        EAIO.Shutdown();
        System.exit(0);
    }

    @SuppressLint("InvalidWakeLockTag")
    public void wakeLockAcquire() {
        if (this.isSleepModeEnabled) {
            return;
        }
        if (this.mWakeLock == null) {
            this.mWakeLock = ((PowerManager) getSystemService(Context.POWER_SERVICE)).newWakeLock(10, TAG);
        }
        if (this.mWakeLock.isHeld()) {
            return;
        }
        try {
            this.mWakeLock.acquire();
        } catch (SecurityException unused) {
            Log.w(TAG, "Missing WAKE_LOCK permission.");
        }
    }

    public void wakeLockRelease() {
        if (this.isSleepModeEnabled) {
            return;
        }
        try {
            if (this.mWakeLock == null || !this.mWakeLock.isHeld()) {
                return;
            }
            this.mWakeLock.release();
        } catch (SecurityException unused) {
            Log.w(TAG, "Missing WAKE_LOCK permission.");
        }
    }

    @Override // android.app.Activity
    protected void onSaveInstanceState(Bundle bundle) {
        super.onSaveInstanceState(bundle);
        ApplicationLifecycle.onActivitySaveInstanceState(bundle, this);
    }

    @Override // android.app.Activity
    public void onActivityResult(int i, int i2, Intent intent) {
        super.onActivityResult(i, i2, intent);
        ApplicationLifecycle.onActivityResult(i, i2, intent, this);
    }

    @Override // android.app.Activity, android.view.KeyEvent.Callback
    public boolean onKeyDown(final int i, KeyEvent keyEvent) {
        super.onKeyDown(i, keyEvent);
        if (state != 8) {
            return true;
        }
        if ((i == 4 || i == 108) && keyEvent.getRepeatCount() > 0) {
            return true;
        }
        final int scanCode = keyEvent.getScanCode();
        this.gameGLSurfaceView.queueEvent(new Runnable() { // from class: com.ea.ironmonkey.GameActivityMain.3
            @Override // java.lang.Runnable
            public void run() {
                GameActivityMain.this.nativeOnPhysicalKeyDown(i, scanCode);
            }
        });
        return !IsSystemKey(i);
    }

    @Override // android.app.Activity, android.view.KeyEvent.Callback
    public boolean onKeyUp(final int i, KeyEvent keyEvent) {
        super.onKeyUp(i, keyEvent);
        if (state != 8) {
            return true;
        }
        final int scanCode = keyEvent.getScanCode();
        this.gameGLSurfaceView.queueEvent(new Runnable() { // from class: com.ea.ironmonkey.GameActivityMain.4
            @Override // java.lang.Runnable
            public void run() {
                GameActivityMain.this.nativeOnPhysicalKeyUp(i, scanCode);
            }
        });
        return !IsSystemKey(i);
    }

    @Override // android.app.Activity
    public void onBackPressed() {
        //super.onBackPressed();
        if (state == 1 || state == 0 || state == 7) {
            finish();
        }
        ApplicationLifecycle.onBackPressed();
    }

    @Override // android.app.Activity, android.content.ComponentCallbacks
    public void onConfigurationChanged(Configuration configuration) {
        Log.d(TAG, "onConfigurationChanged(" + configuration.toString() + ")");
        super.onConfigurationChanged(configuration);
        if (this.accelerometer != null) {
            int rotation = getWindow().getWindowManager().getDefaultDisplay().getRotation();
            switch (rotation) {
                case 0:
                    Log.i(TAG, "Orientation: ROTATION_0");
                    break;
                case 1:
                    Log.i(TAG, "Orientation: ROTATION_90");
                    break;
                case 2:
                    Log.i(TAG, "Orientation: ROTATION_180");
                    break;
                case 3:
                    Log.i(TAG, "Orientation: ROTATION_270");
                    break;
            }
            if (isAmazonDev) {
                this.accelerometer.updateOrientation(rotation);
            }
        }
        if (this.isXperiaPlay) {
            switch (configuration.navigationHidden) {
                case 1:
                    nativeOnPhysicalNavigationVisibilityChanged(true);
                    break;
                case 2:
                    nativeOnPhysicalNavigationVisibilityChanged(false);
                    break;
            }
        }
    }

    @Override // android.app.Activity, android.view.Window.Callback
    public void onWindowFocusChanged(boolean z) {
        super.onWindowFocusChanged(z);
        Log.i(TAG, "onWindowsFocusChanged(" + z + ") state=" + state);
        if (getGameGLSurfaceView() != null) {
            getGameGLSurfaceView().setRenderMode(z ? 1 : 0);
        }
        if (!z) {
            if (this.mFMODAudioDevice.isMixing()) {
                this.mFMODAudioDevice.stop();
                checkAnyMusicActive();
            }
            Log.i(TAG, "onWindowFocusChanged() isMusicActive = " + Boolean.toString(sIsOtherMusicPlaying));
            ForceHideVirtualKeyboard();
            nativeOnPhysicalKeyDown(131, 0);
            nativeOnPhysicalKeyUp(131, 0);
            if (state == 8 && !isAmazonDev) {
                oldState = state;
                state = 7;
                this.gameRenderer.setDrawFrameListener(this);
            }
        } else {
            if (!this.mFMODAudioDevice.isMixing()) {
                checkAnyMusicActive();
                this.mFMODAudioDevice.start();
            }
            Log.i(TAG, "onWindowFocusChanged() isMusicActive = " + Boolean.toString(sIsOtherMusicPlaying));
            if (!isAmazonDev) {
                getWindow().getDecorView().setSystemUiVisibility(5894);
            }
        }
        ApplicationLifecycle.onActivityWindowFocusChanged(z, this);
    }

    private void setLifecycle(int i) {
        if (i == this.lifecycle) {
            return;
        }
        Log.i(TAG, this.lifecycleNames[this.lifecycle] + " -> " + this.lifecycleNames[i]);
        this.lifecycle = i;
    }

    public RunLoop getRunLoop() {
        return this.runLoop;
    }

    public GameGLSurfaceView getGameGLSurfaceView() {
        return this.gameGLSurfaceView;
    }

    public ViewParent GetViewRoot() {
        return getWindow().getDecorView().getRootView().getParent();
    }

    public void CallGC() {
        Log.d(TAG, "Call garbage collector");
        System.gc();
    }

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

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

    public static String GetDefaultLanguage() {
        return Locale.getDefault().toString().substring(0, 2);
    }

    public static String GetDeviceLocale() {
        String upperCase = Locale.getDefault().toString().replace('_', '-').toUpperCase();
        Log.d(TAG, "GetDeviceLocale locale = " + upperCase);
        return upperCase;
    }

    public void ShowMessage(String str, String[] strArr, final boolean z) {
        Log.d(TAG, "ShowMessage msg=" + str + " finish=" + z);
        this.mAd = new AlertDialog.Builder(this);
        this.mAd.setMessage(str);
        this.mAd.setCancelable(false);
        this.mAd.setPositiveButton(strArr[0], new DialogInterface.OnClickListener() { // from class: com.ea.ironmonkey.GameActivityMain.5
            @Override // android.content.DialogInterface.OnClickListener
            public void onClick(DialogInterface dialogInterface, int i) {
                if (z) {
                    GameActivityMain.this.finish();
                }
            }
        });
        this.handler.postDelayed(new Runnable() { // from class: com.ea.ironmonkey.GameActivityMain.6
            @Override // java.lang.Runnable
            public void run() {
                GameActivityMain.this.mAd.show();
            }
        }, 20L);
    }

    @Override // android.app.Activity, android.content.ComponentCallbacks
    public void onLowMemory() {
        ActivityManager activityManager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        ActivityManager.MemoryInfo memoryInfo = new ActivityManager.MemoryInfo();
        activityManager.getMemoryInfo(memoryInfo);
        super.onLowMemory();
    }

    public static String GetApplicationVersion() {
        try {
            return instance.getPackageManager().getPackageInfo(instance.getPackageName(), 0).versionName;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
            return "1.0.1";
        }
    }

    public int GetNaturalOrientation() {
        int width;
        int height;
        Display defaultDisplay = getWindow().getWindowManager().getDefaultDisplay();
        switch (defaultDisplay.getRotation()) {
            case 0:
            case 2:
                width = defaultDisplay.getWidth();
                height = defaultDisplay.getHeight();
                break;
            case 1:
            case 3:
                width = defaultDisplay.getHeight();
                height = defaultDisplay.getWidth();
                break;
            default:
                height = 0;
                width = 0;
                break;
        }
        if (width > height) {
            Log.d(TAG, "NaturalOrientation = LANDSCAPE");
            return 0;
        }
        Log.d(TAG, "NaturalOrientation = PORTRAIT");
        return 1;
    }

    public Accelerometer getAccelerometer() {
        return this.accelerometer;
    }

    public DisplayMetrics getDisplayMetrics() {
        if (Build.VERSION.SDK_INT >= 17) {
            DisplayMetrics displayMetrics = new DisplayMetrics();
            getWindowManager().getDefaultDisplay().getRealMetrics(displayMetrics);
            return displayMetrics;
        }
        return getResources().getDisplayMetrics();
    }

    public boolean isAssetsReady() {
        return assetsReady;
    }

    @Override // android.app.Activity
    public void setContentView(View view) {
        Log.d(TAG, "setContentView(" + view + ")");
        if (view != null) {
            if (view == this.mFrameLayout) {
                super.setContentView(view);
                return;
            }
            int childCount = this.mFrameLayout.getChildCount();
            for (int i = 0; i < childCount; i++) {
                View childAt = this.mFrameLayout.getChildAt(i);
                if (childAt != this.gameGLSurfaceView) {
                    this.mFrameLayout.removeView(childAt);
                }
            }
            if (view != this.gameGLSurfaceView) {
                this.mFrameLayout.addView(view);
            }
            this.mFrameLayout.bringChildToFront(view);
        }
    }

    @Override // com.ea.ironmonkey.DrawFrameListener
    public void onDrawFrame(GL10 gl10) {
        InputStream inputStream;
        if (state != this.laststate) {
            Log.d(TAG, "onDrawFrame state=" + state);
            this.laststate = state;
        }
        boolean z = false;
        switch (state) {
            case 0:
                this.splash = new SplashScreen(this);
                this.splash.init(gl10, this.gameRenderer.getWidth(), this.gameRenderer.getHeight());
                state = 1;
                this.splashCounter = 3;
                break;
            case 1:
                if (this.splashCounter > 0) {
                    this.splashCounter--;
                    break;
                } else {
                    this.splashTimer = System.currentTimeMillis() + 2500;
                    if (!assetsReady) {
                        try {
                            inputStream = getAssets().open(DOWNLOAD_PROPERTIES);
                            try {
                                inputStream.close();
                            } catch (Exception unused) {
                            }
                        } catch (Exception unused2) {
                            inputStream = null;
                        }
                        if (inputStream != null) {
                            this.handler.postDelayed(new Runnable() { // from class: com.ea.ironmonkey.GameActivityMain.8
                                @Override // java.lang.Runnable
                                public void run() {
                                }
                            }, 20L);
                            Log.i(TAG, "state ADC start");
                            state = 3;
                            break;
                        } else {
                            Log.i(TAG, "STATE_GAME_START 1");
                            state = 8;
                            break;
                        }
                    } else {
                        Log.i(TAG, "STATE_GAME_START 2");
                        state = 8;
                        break;
                    }
                }
            case 3:
                Log.i(TAG, "ADC start");
                break;
            case 7:
                if (this.splash == null) {
                    this.splash = new SplashScreen(this);
                    this.splash.init(gl10, this.gameRenderer.getWidth(), this.gameRenderer.getHeight());
                    this.splashDelay = System.currentTimeMillis() + 2000;
                }
                if (this.splashDelay < System.currentTimeMillis() && hasWindowFocus()) {
                    if (oldState == 8) {
                        this.splashTimer = System.currentTimeMillis() + 300;
                        state = 8;
                        break;
                    } else {
                        state = oldState;
                        break;
                    }
                }
                break;
            case 8:
                if (this.splashTimer < System.currentTimeMillis() && nativeRestoreContext()) {
                    assetsReady = true;
                    nativeOnStart();
                    nativeOnResume();
                    this.gameRenderer.setDrawFrameListener(null);
                    z = true;
                    break;
                }
                break;
        }
        GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        GLES20.glClear(16640);
        if (this.splash != null) {
            this.splash.draw(gl10, this.gameRenderer.getWidth(), this.gameRenderer.getHeight());
        }
        if (!z || this.splash == null) {
            return;
        }
        this.splash.destroy(gl10);
        this.splash = null;
    }

    public void onResult(String str, int i) {
        Log.w(TAG, "onResult(" + str + "," + i + ")");
        if (i == -1) {
            File file = new File(new File(str).getParent() + "/.nomedia");
            if (!file.exists()) {
                try {
                    file.createNewFile();
                } catch (Exception unused) {
                }
            }
            this.handler.postDelayed(new Runnable() { // from class: com.ea.ironmonkey.GameActivityMain.9
                @Override // java.lang.Runnable
                public void run() {
                    GameActivityMain.this.setContentView(GameActivityMain.this.gameGLSurfaceView);
                }
            }, 20L);
            if (hasWindowFocus()) {
                state = 8;
                return;
            } else {
                oldState = 8;
                state = 7;
                return;
            }
        }
        finish();
        Process.killProcess(Process.myPid());
    }

    public int getTotalMemory() {
        return 40000;
    }

    public void openURL(String str) {
        openURLinBrowser(str);
    }

    public void openURLinBrowser(String str) {
        String replace = str.replace("http://", "https://");
        Log.d("OpenURLinBrowser", replace);
        try {
            startActivity(new Intent("android.intent.action.VIEW", Uri.parse(replace)));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public float getPerformanceScore() {
        return 6.6f;
    }

    public boolean needInstallWallpaper() {
        Log.i(TAG, "needInstallWallpaper()");
        return false;
    }

    public void installWallpaper() {}

    public long getUtcTime() {
        return TimeUnit.MILLISECONDS.toDays(System.currentTimeMillis());
    }

    public int[][] getNotchesBoundingRects() {
        DisplayCutout displayCutout;
        int[][] iArr = (int[][]) Array.newInstance((Class<?>) int.class, 0, 0);
        if (Build.VERSION.SDK_INT < 28 || (displayCutout = getWindow().getDecorView().getRootWindowInsets().getDisplayCutout()) == null) {
            return iArr;
        }
        List<Rect> boundingRects = displayCutout.getBoundingRects();
        int[][] iArr2 = (int[][]) Array.newInstance((Class<?>) int.class, boundingRects.size(), 4);
        for (int i = 0; i < boundingRects.size(); i++) {
            iArr2[i][0] = boundingRects.get(i).left;
            iArr2[i][1] = boundingRects.get(i).top;
            iArr2[i][2] = boundingRects.get(i).width();
            iArr2[i][3] = boundingRects.get(i).height();
        }
        return iArr2;
    }

    class FSNode {

        @SerializedName("directory")
        public boolean directory;

        @SerializedName("size")
        public int size;

        FSNode() {
        }
    }
}