package com.firemint.realracing;

import android.annotation.TargetApi;
import android.app.AlertDialog;
import android.app.UiModeManager;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.res.Configuration;
import android.database.ContentObserver;
import android.media.AudioManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.StrictMode;
import android.provider.Settings;
import android.util.Log;
import android.view.DisplayCutout;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowInsets;
import android.widget.FrameLayout;
import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import com.ea.eadp.pushnotification.forwarding.FCMMessageService;
import com.ea.nimble.Global;
import com.firemint.realracing.CheatView;
import com.firemonkeys.cloudcellapi.CC_Activity;
import com.firemonkeys.cloudcellapi.CC_Component;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.analytics.FirebaseAnalytics;
import com.google.firebase.crashlytics.FirebaseCrashlytics;
import com.google.firebase.installations.FirebaseInstallations;
import com.google.firebase.installations.InstallationTokenResult;
import com.google.firebase.perf.FirebasePerformance;
import com.google.firebase.remoteconfig.FirebaseRemoteConfig;
import com.google.firebase.remoteconfig.FirebaseRemoteConfigSettings;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/* loaded from: classes2.dex */
public class MainActivity extends CC_Activity {
    public static final int ANDROID_ORIENTATION_LANDSCAPE = 2;
    public static final int ANDROID_ORIENTATION_PORTRAIT = 1;
    public static final int ANDROID_ORIENTATION_UNDEFINED = 0;
    public static final int ANDROID_ROTATION_0 = 0;
    public static final int ANDROID_ROTATION_180 = 2;
    public static final int ANDROID_ROTATION_270 = 3;
    public static final int ANDROID_ROTATION_90 = 1;
    public static final String APPLICATION_LIB_NAME = "RealRacing3";
    public static final int ButtonId_NEGATIVE = 1;
    public static final int ButtonId_NEUTRAL = 2;
    public static final int ButtonId_POSITIVE = 0;
    public static final int GAMESTATE_CREATED = 1;
    public static final int GAMESTATE_DESTROYED = 6;
    public static final int GAMESTATE_NONE = 0;
    public static final int GAMESTATE_NOSTORAGE = 5;
    public static final int GAMESTATE_RUNNING = 3;
    public static final int GAMESTATE_STARTED = 2;
    public static final int GAMESTATE_STOPPED = 4;
    public static final String LOG_TAG = "RealRacing3";
    static final int PERMISSIONS_CAMERA_REQUEST = 2;
    static final int PERMISSION_POST_NOTIFICATIONS_REQUEST = 3;
    static final int PERMISSION_STORAGE_REQUEST = 0;
    static final int PICTURE_DIR_REQUEST = 1;
    static final int WIFI_SETTINGS = 329418467;
    public static MainActivity instance;
    public static boolean m_WIFISettingsShown;
    private static boolean m_bIsAmazon;
    private static boolean m_bIsAndroidTv;
    static boolean s_bRunStrictMode;
    public Handler handler;
    private FirebaseAnalytics mFirebaseAnalytics;
    public FirebaseRemoteConfig mFirebaseRemoteConfig;
    public ControllerManager m_controllerManager = null;
    private HeadphoneBroadcastReceiver m_headphoneBroadcastReceiver = null;
    private DisplayCutout m_displayCutout = null;
    private boolean m_paused = false;
    private boolean m_hasFocus = false;
    private boolean m_delayedResumeJNI = false;
    private boolean m_skipOnDestroyJNI = false;
    private String m_sLoadingString = "";
    private View m_splashView = null;
    private View m_loadingView = null;
    private GLView m_glView = null;
    private FrameLayout m_frameLayout = null;
    private PauseRunnable m_pauseRunnable = null;
    private CheatView m_cheatView = null;
    private CheatView m_keyboardView = null;
    private String m_cheatText = "";
    private String m_keyboardText = "";
    private long m_cheatPtr = 0;
    private long m_keyboardPtr = 0;
    private int m_keyboardInputMaxLength = 0;
    private boolean m_keyboardInputUppercaseOnly = false;
    private boolean m_keyboardInputAlphaNumericOnly = false;
    private AudioStreamManager m_audioStreamManager = new AudioStreamManager();
    private NimbleManager m_nimbleManager = new NimbleManager();
    private int m_gameState = 0;
    int oldGameState = 0;
    public Message m_message = null;

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

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

    public static boolean IsBelowAPI(int i) {
        return Build.VERSION.SDK_INT < i;
    }

    public static boolean getIsAmazon() {
        return m_bIsAmazon;
    }

    public static boolean getIsAndroidTv() {
        return m_bIsAndroidTv;
    }

    private boolean isMenuBackKey(int i) {
        return i == 4 || i == 82;
    }

    private boolean isVolumeKey(int i) {
        return i == 24 || i == 25;
    }

    public static void logi(String str) {
    }

    public native void HandleIntent(Intent intent);

    public boolean HasDisplayCutout() {
        return this.m_displayCutout != null;
    }

    public void OnMessageDismissed(Message message) {
        if (message == this.m_message) {
            this.m_message = null;
        }
    }

    public native void SSExperimentalHoldAndWaitJNI();

    public native void SetRunningOnAndroidTv(boolean z);

    public native void alertMessageExecuteCallback(long j);

    public native boolean checkMemoryJNI();

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

    public FirebaseAnalytics getFirebaseAnalyticsInstance() {
        return this.mFirebaseAnalytics;
    }

    public FirebaseRemoteConfig getFirebaseRemoteConfigInstance() {
        return this.mFirebaseRemoteConfig;
    }

    public FrameLayout getFrameLayout() {
        return this.m_frameLayout;
    }

    public GLView getGLView() {
        return this.m_glView;
    }

    public boolean getPaused() {
        return this.m_paused;
    }

    public native boolean isLegalUsageEnabled();

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

    public native void onCheatInputDone(String str, long j);

    public native void onConfigurationChangedJNI();

    public native void onCreateJNI();

    public native void onDestroyJNI();

    public native void onFirebaseAuthTokenFetched(String str);

    public native void onFirebaseRemoteConfigFetched(boolean z);

    public native void onKeyPressed(int i);

    public native void onKeyReleased(int i);

    public native void onKeyboardInputDone(String str, long j);

    public native void onKeyboardInputUpdate(String str, long j);

    public native void onPauseJNI();

    public native void onRecievedMemoryWarningJNI();

    public native void onResumeJNI();

    public native void onStartJNI();

    public native void onStopJNI();

    public native void onTouchBeginJNI(int i, float f, float f2);

    public native void onTouchCancelJNI();

    public native void onTouchEndJNI(int i, float f, float f2, boolean z);

    public native void onTouchMoveJNI(int i, float f, float f2);

    public native void onViewChangedJNI(int i, int i2, int i3, int i4);

    public native void onViewCreatedJNI();

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

    public native void onWindowFocusChangedJNI(boolean z);

    public native void permissionRequestCompleted(boolean z);

    public native void setBackgroundLaunchURL(String str, String str2, boolean z);

    public native void setLaunchURL(String str);

    public native void setMusicEnabled(boolean z);

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

    static {
        System.loadLibrary(Global.NIMBLE_ID);
        System.loadLibrary("fmodex");
        System.loadLibrary("RealRacing3");
        instance = null;
        m_bIsAmazon = false;
        m_bIsAndroidTv = false;
        s_bRunStrictMode = false;
        m_WIFISettingsShown = false;
    }

    public void RunOnGlThread(Runnable runnable) {
        getGLView().queueEvent(runnable);
    }

    public void showLoadingSplash(String str) {
        this.m_sLoadingString = str;
        runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.1
            @Override // java.lang.Runnable
            public void run() {
                if (MainActivity.this.m_frameLayout == null || MainActivity.this.m_frameLayout.indexOfChild(MainActivity.this.m_splashView) >= 0) {
                    return;
                }
                MainActivity.this.m_frameLayout.addView(MainActivity.this.m_splashView);
                MainActivity mainActivity = MainActivity.this;
                mainActivity.m_loadingView = mainActivity.createLoadingView(mainActivity.m_sLoadingString);
                MainActivity.this.m_frameLayout.addView(MainActivity.this.m_loadingView);
            }
        });
    }

    public void hideLoadingSplash() {
        runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.2
            @Override // java.lang.Runnable
            public void run() {
                if (MainActivity.this.m_frameLayout == null || MainActivity.this.m_frameLayout.indexOfChild(MainActivity.this.m_splashView) < 0) {
                    return;
                }
                MainActivity.this.m_frameLayout.removeView(MainActivity.this.m_splashView);
                MainActivity.this.m_frameLayout.removeView(MainActivity.this.m_loadingView);
            }
        });
    }

    public void showSplash() {
        runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.3
            @Override // java.lang.Runnable
            public void run() {
                if (MainActivity.this.m_frameLayout == null || MainActivity.this.m_frameLayout.indexOfChild(MainActivity.this.m_splashView) >= 0) {
                    return;
                }
                MainActivity.this.m_frameLayout.addView(MainActivity.this.m_splashView);
            }
        });
    }

    public void hideSplash() {
        runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.4
            @Override // java.lang.Runnable
            public void run() {
                if (MainActivity.this.m_frameLayout == null || MainActivity.this.m_frameLayout.indexOfChild(MainActivity.this.m_splashView) < 0) {
                    return;
                }
                MainActivity.this.m_frameLayout.removeView(MainActivity.this.m_splashView);
            }
        });
    }

    public static int getGameState() {
        MainActivity mainActivity = instance;
        if (mainActivity == null) {
            return 0;
        }
        return mainActivity.m_gameState;
    }

    public static boolean setGameState(int i) {
        if (instance == null) {
            return false;
        }
        logi("setGameState(" + i + ")");
        instance.m_gameState = i;
        return true;
    }

    public boolean checkStorage(boolean z) {
        if (this.m_gameState == 5 && !z) {
            return false;
        }
        logi("checkStorage(): storage state = " + Environment.getExternalStorageState());
        if (Environment.getExternalStorageState().equals("mounted") || Environment.getExternalStorageState().equals("mounted_ro")) {
            return true;
        }
        int i = this.m_gameState;
        if (i != 5) {
            this.oldGameState = i;
        }
        setGameState(5);
        logi("checkStorage(): game state = " + this.m_gameState + " old state=" + this.oldGameState);
        if (this.oldGameState <= 1 && checkMemoryJNI()) {
            new Message(getString(R.string.STORAGE_ERROR_TITLE), getString(R.string.STORAGE_ERROR_DESC), getString(R.string.STORAGE_ERROR_POS_BTN), getString(R.string.STORAGE_ERROR_NEG_BTN), null, new MessageCallback() { // from class: com.firemint.realracing.MainActivity.5
                @Override // com.firemint.realracing.MessageCallback
                public void onMessage(int i2) {
                    if (i2 == 0) {
                        MainActivity.instance.onContinueLowMemory();
                    }
                }
            });
        } else {
            new Message(getString(R.string.STORAGE_ERROR_TITLE), getString(R.string.STORAGE_ERROR_DESC), null, getString(R.string.STORAGE_ERROR_NEG_BTN), null, null);
        }
        return false;
    }

    public void onContinueLowMemory() {
        if (checkStorage(true)) {
            onCreateJNI();
            onStartJNI();
            if (this.m_hasFocus) {
                onDelayedResume();
            }
            this.m_paused = false;
            this.oldGameState = 3;
            setGameState(3);
        }
    }

    @Override // com.firemonkeys.cloudcellapi.CC_Activity, android.app.Activity
    public void onCreate(Bundle bundle) {
        logi("onCreate(): start");
        if (s_bRunStrictMode) {
            logi("enabling strict mode settings");
            StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder().detectAll().permitDiskReads().permitDiskWrites().penaltyLog().penaltyDeath().build());
            StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectActivityLeaks().detectFileUriExposure().detectLeakedRegistrationObjects().penaltyLog().penaltyDeath().build());
        }
        AppProxy.SetActivity(this);
        m_bIsAmazon = getApplication().getPackageName().contains("_azn");
        m_bIsAndroidTv = ((UiModeManager) getSystemService("uimode")).getCurrentModeType() == 4;
        SetRunningOnAndroidTv(getIsAndroidTv());
        this.m_headphoneBroadcastReceiver = new HeadphoneBroadcastReceiver(this);
        SetupDisplayCutoutCallback();
        super.onCreate(bundle);
        new NotificationChannelHelper(this);
        this.handler = new Handler();
        HandleLaunchURL(getIntent());
        int i = this.m_gameState;
        if (i == 6) {
            finish();
            return;
        }
        if (i >= 1) {
            return;
        }
        instance = this;
        setGameState(1);
        getContentResolver().registerContentObserver(Settings.System.CONTENT_URI, true, new ContentObserver(new Handler()) { // from class: com.firemint.realracing.MainActivity.6
            @Override // android.database.ContentObserver
            public void onChange(boolean z) {
                onChange(z, null);
            }

            @Override // android.database.ContentObserver
            public void onChange(boolean z, Uri uri) {
                MainActivity.logi("contentchange");
                MainActivity.this.updateScreenOrientationConfiguration();
            }
        });
        updateScreenOrientationConfiguration();
        this.m_audioStreamManager.setAudioManager((AudioManager) getSystemService("audio"));
        getWindow().requestFeature(1);
        getWindow().addFlags(1152);
        this.m_splashView = createSplashView(this);
        this.m_glView = new GLView(getApplication());
        SetupSystemUiVisibility();
        HideSystemKeys(getWindow().getDecorView());
        CC_Component.setIsUsingImmersiveMode(true);
        FrameLayout frameLayout = new FrameLayout(this);
        this.m_frameLayout = frameLayout;
        frameLayout.addView(this.m_glView);
        this.m_frameLayout.addView(this.m_splashView);
        setContentView(this.m_frameLayout);
        super.setInstances(this.m_glView, this.m_frameLayout);
        MoviePlayer.startup(this, this.m_frameLayout, this.handler);
        this.m_nimbleManager.initialise(this);
        this.m_nimbleManager.onCreate(bundle);
        if (checkStorage(false)) {
            onCreateJNI();
        }
        CheckInitialiseCrashlytics(isLegalUsageEnabled());
        FirebaseAnalytics firebaseAnalytics = FirebaseAnalytics.getInstance(this);
        this.mFirebaseAnalytics = firebaseAnalytics;
        firebaseAnalytics.setAnalyticsCollectionEnabled(isLegalUsageEnabled());
        FirebasePerformance.getInstance().setPerformanceCollectionEnabled(isLegalUsageEnabled());
        this.mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
        this.mFirebaseRemoteConfig.setConfigSettingsAsync(new FirebaseRemoteConfigSettings.Builder().setMinimumFetchIntervalInSeconds(3600L).build());
        this.mFirebaseRemoteConfig.fetchAndActivate().addOnCompleteListener(this, new OnCompleteListener<Boolean>() { // from class: com.firemint.realracing.MainActivity.7
            @Override // com.google.android.gms.tasks.OnCompleteListener
            public void onComplete(@NonNull Task<Boolean> task) {
                if (task.isSuccessful()) {
                    MainActivity.this.onFirebaseRemoteConfigFetched(true);
                } else {
                    MainActivity.this.onFirebaseRemoteConfigFetched(false);
                }
            }
        });
        FirebaseInstallations.getInstance().getToken(true).addOnCompleteListener(new OnCompleteListener<InstallationTokenResult>() { // from class: com.firemint.realracing.MainActivity.8
            @Override // com.google.android.gms.tasks.OnCompleteListener
            public void onComplete(@NonNull Task<InstallationTokenResult> task) {
                if (task.isSuccessful() && task.getResult() != null) {
                    MainActivity.this.onFirebaseAuthTokenFetched(task.getResult().getToken().toString());
                } else {
                    MainActivity.this.onFirebaseAuthTokenFetched("");
                }
            }
        });
        logi("onCreate(): finish");
    }

    public void OnLegalOptOutChanged(boolean z) {
        logi("MainActivity::OnLegalOptOutChanged: " + z);
        CheckInitialiseCrashlytics(z);
        this.mFirebaseAnalytics.setAnalyticsCollectionEnabled(z);
        FirebasePerformance.getInstance().setPerformanceCollectionEnabled(z);
    }

    public void CheckInitialiseCrashlytics(boolean z) {
        FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(z);
    }

    @TargetApi(28)
    public int GetCutoutLeft() {
        int safeInsetLeft;
        DisplayCutout displayCutout = this.m_displayCutout;
        if (displayCutout == null) {
            return 0;
        }
        safeInsetLeft = displayCutout.getSafeInsetLeft();
        return safeInsetLeft;
    }

    @TargetApi(28)
    public int GetCutoutRight() {
        int safeInsetRight;
        DisplayCutout displayCutout = this.m_displayCutout;
        if (displayCutout == null) {
            return 0;
        }
        safeInsetRight = displayCutout.getSafeInsetRight();
        return safeInsetRight;
    }

    public boolean ShouldUseDefaultDisplayCutout() {
        if (HasDisplayCutout()) {
            return false;
        }
        String str = Build.MODEL;
        return (str.toUpperCase().contains("SM-M205") && Build.VERSION.SDK_INT < 28) || str.toLowerCase().contains("vivo 1818") || str.toUpperCase().contains("CPH1969") || str.toUpperCase().contains("CPH1909") || str.toUpperCase().contains("PIXEL 4") || str.toUpperCase().contains("PIXEL 4 XL") || str.toUpperCase().contains("PIXEL 3") || str.toUpperCase().contains("GM1913");
    }

    private void SetupDisplayCutoutCallback() {
        try {
            if (IsAtLeastAPI(28)) {
                getWindow().getDecorView().setOnApplyWindowInsetsListener(new View.OnApplyWindowInsetsListener() { // from class: com.firemint.realracing.MainActivity.9
                    @Override // android.view.View.OnApplyWindowInsetsListener
                    public WindowInsets onApplyWindowInsets(View view, WindowInsets windowInsets) {
                        DisplayCutout displayCutout;
                        final int safeInsetLeft;
                        final int safeInsetRight;
                        MainActivity mainActivity = MainActivity.this;
                        displayCutout = windowInsets.getDisplayCutout();
                        mainActivity.m_displayCutout = displayCutout;
                        if (MainActivity.this.m_displayCutout != null && MainActivity.this.getGLView() != null) {
                            safeInsetLeft = MainActivity.this.m_displayCutout.getSafeInsetLeft();
                            safeInsetRight = MainActivity.this.m_displayCutout.getSafeInsetRight();
                            MainActivity.this.RunOnGlThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.9.1
                                @Override // java.lang.Runnable
                                public void run() {
                                    MainActivity.this.setSafeArea(safeInsetLeft, safeInsetRight);
                                }
                            });
                        }
                        return windowInsets;
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override // android.app.Activity
    public void onRequestPermissionsResult(int i, String[] strArr, int[] iArr) {
        int i2;
        final boolean z = false;
        if (i == 0) {
            i2 = (iArr == null || iArr.length <= 0) ? -1 : iArr[0];
            Platform.StoragePermissionUpdated(i2, null);
        } else {
            if (i == 3 && iArr != null && iArr.length > 0) {
                i2 = iArr[0];
            }
            RunOnGlThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.10
                @Override // java.lang.Runnable
                public void run() {
                    MainActivity.this.permissionRequestCompleted(z);
                }
            });
            super.onRequestPermissionsResult(i, strArr, iArr);
        }
        if (i2 == 0) {
            z = true;
        }
        RunOnGlThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.10
            @Override // java.lang.Runnable
            public void run() {
                MainActivity.this.permissionRequestCompleted(z);
            }
        });
        super.onRequestPermissionsResult(i, strArr, iArr);
    }

    public boolean IsPermissionGranted(String str) {
        return ContextCompat.checkSelfPermission(this, str) == 0;
    }

    public void RequestPermission(String str, int i) {
        ActivityCompat.requestPermissions(this, new String[]{str}, i);
    }

    public void HandleLaunchURL(Intent intent) {
        if (intent != null) {
            String stringExtra = intent.getStringExtra("deepLinkUrl");
            String stringExtra2 = intent.getStringExtra(FCMMessageService.PushIntentExtraKeys.ALERT);
            if (stringExtra == null || stringExtra.length() == 0) {
                stringExtra = intent.getStringExtra(com.firemonkeys.cloudcellapi.LocalNotificationsCenter.EXTRA_LAUNCH_URL);
            }
            if (stringExtra == null || stringExtra.length() == 0) {
                stringExtra = intent.getDataString();
            }
            if (stringExtra == null || stringExtra.length() <= 0) {
                return;
            }
            HandleDeepLink(stringExtra2, stringExtra);
        }
    }

    public void HandleDeepLink(final String str, final String str2) {
        Runnable runnable = new Runnable() { // from class: com.firemint.realracing.MainActivity.11
            @Override // java.lang.Runnable
            public void run() {
                boolean IsInForeground = Platform.IsInForeground();
                MainActivity mainActivity = MainActivity.this;
                String str3 = str;
                if (str3 == null) {
                    str3 = "";
                }
                mainActivity.setBackgroundLaunchURL(str3, str2, IsInForeground);
            }
        };
        if (getGLView() != null) {
            RunOnGlThread(runnable);
        } else {
            runnable.run();
        }
    }

    public boolean areHeadphonesConnected() {
        return this.m_headphoneBroadcastReceiver.AreHeadphonesConnected();
    }

    @TargetApi(14)
    private void SetupSystemUiVisibility() {
        getWindow().getDecorView().setOnSystemUiVisibilityChangeListener(new View.OnSystemUiVisibilityChangeListener() { // from class: com.firemint.realracing.MainActivity.12
            @Override // android.view.View.OnSystemUiVisibilityChangeListener
            public void onSystemUiVisibilityChange(int i) {
                if (MainActivity.this.m_hasFocus) {
                    MainActivity.this.OnSystemUiVisibilityChanged();
                }
            }
        });
    }

    @Override // android.app.Activity, android.content.ComponentCallbacks2
    public void onTrimMemory(int i) {
        StringBuilder sb = new StringBuilder();
        sb.append("OnTrimMemory(");
        sb.append(i);
        sb.append(")");
        if (i == 15) {
            Log.e("RealRacing3", "Received memory warning: TRIM_MEMORY_RUNNING_CRITICAL)");
        }
        this.m_glView.queueEvent(new Runnable() { // from class: com.firemint.realracing.MainActivity.13
            @Override // java.lang.Runnable
            public void run() {
                MainActivity.this.onRecievedMemoryWarningJNI();
            }
        });
    }

    public void createControllerManager() {
        this.m_controllerManager = new ControllerManager(this);
    }

    /* renamed from: com.firemint.realracing.MainActivity$14, reason: invalid class name */
    public class AnonymousClass14 implements Runnable {
        public AnonymousClass14() {
        }

        @Override // java.lang.Runnable
        public void run() {
            if (MainActivity.this.m_cheatView == null) {
                CheatView.CheatListener cheatListener = new CheatView.CheatListener() { // from class: com.firemint.realracing.MainActivity.14.1
                    @Override // com.firemint.realracing.CheatView.CheatListener
                    public CharSequence onInputUpdate(boolean z, CharSequence charSequence) {
                        return charSequence;
                    }

                    @Override // com.firemint.realracing.CheatView.CheatListener
                    public void onInputDone(boolean z, CharSequence charSequence) {
                        MainActivity.this.m_cheatText = charSequence.toString();
                        MainActivity.this.hideCheatInput();
                        MainActivity.this.m_glView.queueEvent(new Runnable() { // from class: com.firemint.realracing.MainActivity.14.1.1
                            @Override // java.lang.Runnable
                            public void run() {
                                MainActivity mainActivity = MainActivity.this;
                                mainActivity.onCheatInputDone(mainActivity.m_cheatText, MainActivity.this.m_cheatPtr);
                            }
                        });
                    }
                };
                MainActivity.this.m_cheatView = new CheatView(MainActivity.instance, cheatListener, true);
            }
            if (MainActivity.this.m_cheatView.getParent() == null) {
                MainActivity.this.m_frameLayout.addView(MainActivity.this.m_cheatView);
            }
            MainActivity.this.m_cheatView.begin("");
        }
    }

    public void showCheatInput(long j) {
        this.m_cheatPtr = j;
        this.m_cheatText = "";
        runOnUiThread(new AnonymousClass14());
    }

    public void hideCheatInput() {
        runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.15
            @Override // java.lang.Runnable
            public void run() {
                if (MainActivity.this.m_cheatView != null) {
                    MainActivity.this.m_cheatView.end();
                    if (MainActivity.this.m_cheatView.getParent() != null) {
                        MainActivity.this.m_frameLayout.removeView(MainActivity.this.m_cheatView);
                    }
                }
            }
        });
    }

    public boolean isCheatInputShown() {
        CheatView cheatView = this.m_cheatView;
        return (cheatView == null || cheatView.getParent() == null) ? false : true;
    }

    /* renamed from: com.firemint.realracing.MainActivity$16, reason: invalid class name */
    public class AnonymousClass16 implements Runnable {
        final /* synthetic */ boolean val$bPassword;
        final /* synthetic */ String val$text;

        public AnonymousClass16(boolean z, String str) {
            this.val$bPassword = z;
            this.val$text = str;
        }

        @Override // java.lang.Runnable
        public void run() {
            if (MainActivity.this.m_keyboardView == null) {
                CheatView.CheatListener cheatListener = new CheatView.CheatListener() { // from class: com.firemint.realracing.MainActivity.16.1
                    @Override // com.firemint.realracing.CheatView.CheatListener
                    public void onInputDone(boolean z, CharSequence charSequence) {
                        MainActivity.this.m_keyboardText = charSequence.toString();
                        MainActivity.this.hideKeyboardInput();
                        MainActivity.this.m_glView.queueEvent(new Runnable() { // from class: com.firemint.realracing.MainActivity.16.1.1
                            @Override // java.lang.Runnable
                            public void run() {
                                MainActivity mainActivity = MainActivity.this;
                                mainActivity.onKeyboardInputDone(mainActivity.m_keyboardText, MainActivity.this.m_keyboardPtr);
                            }
                        });
                    }

                    @Override // com.firemint.realracing.CheatView.CheatListener
                    public CharSequence onInputUpdate(boolean z, CharSequence charSequence) {
                        MainActivity.this.m_keyboardText = charSequence.toString();
                        if (MainActivity.this.m_keyboardInputAlphaNumericOnly) {
                            MainActivity mainActivity = MainActivity.this;
                            mainActivity.m_keyboardText = mainActivity.m_keyboardText.replaceAll("[^a-zA-Z0-9]", "");
                        }
                        AnonymousClass16 anonymousClass16 = AnonymousClass16.this;
                        if (anonymousClass16.val$bPassword) {
                            MainActivity mainActivity2 = MainActivity.this;
                            mainActivity2.m_keyboardText = mainActivity2.m_keyboardText.replaceAll("[^a-zA-Z0-9\\s]", "");
                        }
                        try {
                            Matcher matcher = Pattern.compile("[^\\u0000-\\u1FFF\\u2C00-\\uD7FF\\uF900-\\uFAFF]", 66).matcher(MainActivity.this.m_keyboardText);
                            MainActivity.this.m_keyboardText = matcher.replaceAll("");
                        } catch (Exception e) {
                            Log.e("RR3IME", e.toString());
                        }
                        if (MainActivity.this.m_keyboardInputUppercaseOnly) {
                            MainActivity mainActivity3 = MainActivity.this;
                            mainActivity3.m_keyboardText = mainActivity3.m_keyboardText.toUpperCase();
                        }
                        int i = MainActivity.this.m_keyboardInputMaxLength;
                        if (MainActivity.this.m_keyboardText.length() < i) {
                            i = MainActivity.this.m_keyboardText.length();
                        }
                        if (i > 0) {
                            MainActivity mainActivity4 = MainActivity.this;
                            mainActivity4.m_keyboardText = mainActivity4.m_keyboardText.substring(0, i);
                        }
                        MainActivity.this.m_glView.queueEvent(new Runnable() { // from class: com.firemint.realracing.MainActivity.16.1.2
                            @Override // java.lang.Runnable
                            public void run() {
                                MainActivity mainActivity5 = MainActivity.this;
                                mainActivity5.onKeyboardInputUpdate(mainActivity5.m_keyboardText, MainActivity.this.m_keyboardPtr);
                            }
                        });
                        return MainActivity.this.m_keyboardText;
                    }
                };
                MainActivity.this.m_keyboardView = new CheatView(MainActivity.instance, cheatListener, this.val$bPassword);
            }
            if (MainActivity.this.m_keyboardView.getParent() == null) {
                MainActivity.this.m_frameLayout.addView(MainActivity.this.m_keyboardView);
            }
            MainActivity.this.m_keyboardView.begin(this.val$text);
            MainActivity.this.m_keyboardView.touchOffToClose = false;
        }
    }

    public void showKeyboardInput(long j, int i, boolean z, boolean z2, boolean z3, String str) {
        this.m_keyboardPtr = j;
        this.m_keyboardText = str;
        this.m_keyboardInputMaxLength = i;
        this.m_keyboardInputUppercaseOnly = z;
        this.m_keyboardInputAlphaNumericOnly = z2;
        runOnUiThread(new AnonymousClass16(z3, str));
    }

    public void hideKeyboardInput() {
        runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.17
            @Override // java.lang.Runnable
            public void run() {
                if (MainActivity.this.m_keyboardView != null) {
                    MainActivity.this.m_keyboardView.end();
                    if (MainActivity.this.m_keyboardView.getParent() != null) {
                        MainActivity.this.m_frameLayout.removeView(MainActivity.this.m_keyboardView);
                    }
                    MainActivity.this.OnSystemUiVisibilityChanged();
                }
            }
        });
    }

    public boolean isKeyboardInputShown() {
        CheatView cheatView = this.m_keyboardView;
        return (cheatView == null || cheatView.getParent() == null) ? false : true;
    }

    public TextField createTextField(long j, String str) {
        logi("createTextField(): " + str);
        final TextField textField = new TextField(instance, j, str);
        runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.18
            @Override // java.lang.Runnable
            public void run() {
                MainActivity.logi("Attached text field");
                MainActivity.this.m_frameLayout.addView(textField);
            }
        });
        return textField;
    }

    public void removeTextField(final TextField textField) {
        runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.19
            @Override // java.lang.Runnable
            public void run() {
                TextField textField2 = textField;
                if (textField2 != null && textField2.getParent() != null) {
                    MainActivity.logi("Destroying text field");
                    MainActivity.this.m_frameLayout.removeView(textField);
                } else {
                    MainActivity.logi("Attempting to destroy null text field");
                }
            }
        });
    }

    public View createLoadingView(String str) {
        Platform.getScreenWidth();
        int screenHeight = Platform.getScreenHeight();
        TextView textView = new TextView(this);
        textView.setText(str);
        textView.setTextColor(-1);
        textView.setTextSize(32.0f);
        textView.setVisibility(0);
        textView.setGravity(1);
        textView.setPadding(0, screenHeight - (screenHeight / 7), 0, 0);
        return textView;
    }

    public static View createSplashView(Context context) {
        return LayoutInflater.from(context).inflate(R.layout.unpacking_assets, (ViewGroup) null);
    }

    public void OnViewChanged(int i, int i2, int i3, int i4) {
        runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.20
            @Override // java.lang.Runnable
            public void run() {
                boolean z;
                try {
                    if (MainActivity.this.m_splashView == null || MainActivity.this.m_frameLayout.indexOfChild(MainActivity.this.m_splashView) < 0) {
                        z = false;
                    } else {
                        MainActivity.this.m_frameLayout.removeView(MainActivity.this.m_splashView);
                        z = true;
                    }
                    MainActivity mainActivity = MainActivity.this;
                    mainActivity.m_splashView = MainActivity.createSplashView(mainActivity);
                    if (z) {
                        MainActivity.this.m_frameLayout.addView(MainActivity.this.m_splashView);
                    }
                } catch (Exception e) {
                    Log.e("RealRacing3", "Exception when attempting to recreate the splash view: " + e.getMessage());
                }
            }
        });
        onViewChangedJNI(i, i2, i3, i4);
    }

    @Override // android.app.Activity
    public void onRestart() {
        logi("onRestart(): start");
        super.onRestart();
        this.m_nimbleManager.onRestart();
        logi("onRestart(): finish");
    }

    @Override // com.firemonkeys.cloudcellapi.CC_Activity, android.app.Activity
    public void onStart() {
        logi("IANU>> onStart(): start");
        super.onStart();
        if (checkStorage(false)) {
            int i = this.m_gameState;
            if (i < 2 || i >= 4) {
                setGameState(2);
                onStartJNI();
                this.m_nimbleManager.onStart();
                logi("IANU>> onStart(): finish");
            }
        }
    }

    @Override // android.app.Activity
    public void onNewIntent(Intent intent) {
        logi("onNewIntent");
        super.onNewIntent(intent);
        HandleLaunchURL(intent);
        HandleIntent(intent);
    }

    @Override // com.firemonkeys.cloudcellapi.CC_Activity, android.app.Activity
    public void onResume() {
        logi("IANU>> onResume(): start");
        this.m_delayedResumeJNI = true;
        super.onResume();
        this.m_glView.onResume();
        this.m_nimbleManager.onResume();
        this.m_headphoneBroadcastReceiver.onResume();
        int i = this.m_gameState;
        if (i != 5 && i != 3) {
            setGameState(3);
            this.m_delayedResumeJNI = false;
            this.m_glView.queueEvent(new Runnable() { // from class: com.firemint.realracing.MainActivity.21
                @Override // java.lang.Runnable
                public void run() {
                    MainActivity.this.onResumeJNI();
                }
            });
            this.m_paused = false;
        }
        if (isKeyboardInputShown()) {
            this.m_keyboardView.onResume();
        }
        if (isCheatInputShown()) {
            this.m_cheatView.onResume();
        }
        MoviePlayer.resume();
        ControllerManager controllerManager = this.m_controllerManager;
        if (controllerManager != null) {
            controllerManager.onResume();
        }
        logi("IANU>> onResume(): finish");
    }

    public void onDelayedResume() {
        if (this.m_delayedResumeJNI) {
            this.m_delayedResumeJNI = false;
            this.m_glView.queueEvent(new Runnable() { // from class: com.firemint.realracing.MainActivity.22
                @Override // java.lang.Runnable
                public void run() {
                    MainActivity.this.onResumeJNI();
                }
            });
        }
    }

    @Override // android.app.Activity, android.view.Window.Callback
    public void onWindowFocusChanged(boolean z) {
        logi("onWindowFocusChanged(" + z + "): start");
        this.m_hasFocus = z;
        super.onWindowFocusChanged(z);
        this.m_glView.queueEvent(new Runnable() { // from class: com.firemint.realracing.MainActivity.23
            @Override // java.lang.Runnable
            public void run() {
                MainActivity mainActivity = MainActivity.this;
                mainActivity.onWindowFocusChangedJNI(mainActivity.m_hasFocus);
            }
        });
        if (this.m_hasFocus) {
            if (!this.m_paused) {
                onDelayedResume();
            }
            OnSystemUiVisibilityChanged();
        }
        this.m_nimbleManager.onWindowFocusChanged(z);
        logi("onWindowFocusChanged(" + this.m_hasFocus + "): finish");
    }

    @Override // com.firemonkeys.cloudcellapi.CC_Activity, android.app.Activity
    public void onPause() {
        logi("onPause(): start");
        this.m_delayedResumeJNI = false;
        super.onPause();
        showSplash();
        logi("onPause(): glPause");
        this.m_glView.onPause();
        this.m_nimbleManager.onPause();
        this.m_headphoneBroadcastReceiver.onPause();
        MoviePlayer.pause();
        ControllerManager controllerManager = this.m_controllerManager;
        if (controllerManager != null) {
            controllerManager.onPause();
        }
        if (this.m_gameState == 3) {
            logi("onPause(): pauseJNI");
            setGameState(2);
            this.m_paused = true;
            PauseRunnable pauseRunnable = new PauseRunnable(this);
            this.m_pauseRunnable = pauseRunnable;
            this.m_glView.queueEvent(pauseRunnable);
        }
        if (isKeyboardInputShown()) {
            this.m_keyboardView.onPause();
        }
        if (isCheatInputShown()) {
            this.m_cheatView.onPause();
        }
        logi("onPause(): finish");
    }

    @Override // com.firemonkeys.cloudcellapi.CC_Activity, android.app.Activity
    public void onStop() {
        logi("onStop(): start");
        PauseRunnable.waitUntilFinished(this.m_pauseRunnable);
        super.onStop();
        int i = this.m_gameState;
        if (i != 5 && i < 4) {
            setGameState(4);
            onStopJNI();
        }
        this.m_nimbleManager.onStop();
        logi("onStop(): finish");
    }

    @Override // com.firemonkeys.cloudcellapi.CC_Activity, android.app.Activity
    public void onDestroy() {
        logi("onDestroy(): start");
        ControllerManager controllerManager = this.m_controllerManager;
        if (controllerManager != null) {
            controllerManager.onDestroy();
        }
        if (this.m_gameState < 6) {
            setGameState(6);
            if (!this.m_skipOnDestroyJNI) {
                onDestroyJNI();
            }
        }
        super.onDestroy();
        super.clearInstances();
        this.m_nimbleManager.onDestroy();
        this.m_glView = null;
        this.m_splashView = null;
        this.m_cheatView = null;
        this.m_frameLayout = null;
        instance = null;
        AppProxy.SetActivity(null);
        logi("onDestroy(): exit");
        System.exit(0);
        logi("onDestroy(): finish");
    }

    @Override // android.app.Activity
    public void onRestoreInstanceState(Bundle bundle) {
        this.m_nimbleManager.onRestoreInstanceState(bundle);
    }

    @Override // android.app.Activity
    public void onSaveInstanceState(Bundle bundle) {
        this.m_nimbleManager.onSaveInstanceState(bundle);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnSystemUiVisibilityChanged() {
        if (isKeyboardInputShown()) {
            return;
        }
        if (!getIsAmazon() || IsAtLeastAPI(21)) {
            getGLView().postDelayed(new Runnable() { // from class: com.firemint.realracing.MainActivity.24
                @Override // java.lang.Runnable
                public void run() {
                    MainActivity.HideSystemKeys(MainActivity.this.getWindow().getDecorView());
                }
            }, 1000L);
        }
    }

    @TargetApi(19)
    public static void HideSystemKeys(View view) {
        if (IsAtLeastAPI(19)) {
            view.setSystemUiVisibility(4614);
        } else {
            if (!IsAtLeastAPI(14) || (view.getSystemUiVisibility() & 1) == 1) {
                return;
            }
            view.setSystemUiVisibility(1);
        }
    }

    @Override // android.app.Activity
    public void onBackPressed() {
        if (this.m_nimbleManager.onBackPressed()) {
            super.onBackPressed();
        }
    }

    public void finishActivity() {
        finish();
    }

    public void setSkipOnDestroyJNI(boolean z) {
        StringBuilder sb = new StringBuilder();
        sb.append("Setting skipOnDestroyJNI: ");
        sb.append(z ? "true" : "false");
        logi(sb.toString());
        this.m_skipOnDestroyJNI = z;
    }

    public void updateScreenOrientationConfiguration() {
        if (Settings.System.getInt(getContentResolver(), "accelerometer_rotation", 1) == 0) {
            logi("setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE)");
            setRequestedOrientation(0);
        } else {
            logi("setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE)");
            setRequestedOrientation(6);
        }
    }

    public int getScreenOrientation() {
        int i = getResources().getConfiguration().orientation;
        int i2 = 1;
        if (i != 1) {
            i2 = 2;
            if (i != 2) {
                return 0;
            }
        }
        return i2;
    }

    public int getScreenRotation() {
        int rotation = getWindowManager().getDefaultDisplay().getRotation();
        if (rotation == 0) {
            return 0;
        }
        int i = 1;
        if (rotation != 1) {
            i = 2;
            if (rotation != 2) {
                return 3;
            }
        }
        return i;
    }

    @Override // android.app.Activity, android.content.ComponentCallbacks
    public void onConfigurationChanged(Configuration configuration) {
        super.onConfigurationChanged(configuration);
    }

    @Override // com.firemonkeys.cloudcellapi.CC_Activity, android.app.Activity
    public void onActivityResult(int i, int i2, Intent intent) {
        super.onActivityResult(i, i2, intent);
        int i3 = 0;
        if (i == WIFI_SETTINGS) {
            m_WIFISettingsShown = false;
        } else if (i == 1) {
            if (i2 == -1) {
                getContentResolver().takePersistableUriPermission(intent.getData(), 3);
            } else {
                i3 = -1;
            }
            Platform.StoragePermissionUpdated(i3, intent);
        }
        this.m_nimbleManager.onActivityResult(i, i2, intent);
    }

    public void SSExperimental_SimulateDeadlock() {
        this.m_glView.queueEvent(new Runnable() { // from class: com.firemint.realracing.MainActivity.25
            @Override // java.lang.Runnable
            public void run() {
                MainActivity.this.runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.25.1
                    @Override // java.lang.Runnable
                    public void run() {
                        try {
                            MainActivity.loge("UI thread sleeping...");
                            Thread.sleep(3000L);
                            MainActivity.loge("UI thread waking...");
                            MainActivity.instance.SSExperimentalHoldAndWaitJNI();
                        } catch (InterruptedException unused) {
                        }
                    }
                });
                MainActivity.instance.SSExperimentalHoldAndWaitJNI();
            }
        });
    }

    @Override // android.app.Activity, android.view.Window.Callback
    public boolean dispatchKeyEvent(KeyEvent keyEvent) {
        ControllerManager controllerManager;
        if (isCheatInputShown() || isKeyboardInputShown() || (controllerManager = this.m_controllerManager) == null || !controllerManager.HandleKeyEvents(keyEvent)) {
            return super.dispatchKeyEvent(keyEvent);
        }
        return true;
    }

    @Override // android.app.Activity, android.view.KeyEvent.Callback
    public boolean onKeyDown(int i, KeyEvent keyEvent) {
        if (handleKeyEvent(i, keyEvent)) {
            return true;
        }
        return super.onKeyDown(i, keyEvent);
    }

    @Override // android.app.Activity, android.view.KeyEvent.Callback
    public boolean onKeyUp(int i, KeyEvent keyEvent) {
        if (handleKeyEvent(i, keyEvent)) {
            return true;
        }
        return super.onKeyUp(i, keyEvent);
    }

    public boolean handleKeyEvent(int i, KeyEvent keyEvent) {
        if (isMenuBackKey(i) && keyEvent.getRepeatCount() == 0) {
            this.m_glView.queueEvent(new KeyEventRunnable(i, keyEvent.getAction()));
            return true;
        }
        if (!isVolumeKey(i)) {
            return false;
        }
        this.m_glView.queueEvent(new KeyEventRunnable(i, keyEvent.getAction()));
        return false;
    }

    @Override // android.app.Activity
    public boolean onGenericMotionEvent(MotionEvent motionEvent) {
        ControllerManager controllerManager;
        if (!isCheatInputShown() && !isKeyboardInputShown() && (controllerManager = this.m_controllerManager) != null) {
            if (controllerManager.HandleMotionEvents(motionEvent)) {
                return true;
            }
            this.m_controllerManager.Log("Not controller motion event");
        }
        return super.onGenericMotionEvent(motionEvent);
    }

    public class KeyEventRunnable implements Runnable {
        int m_keyCode;
        int m_nAction;

        public KeyEventRunnable(int i, int i2) {
            this.m_keyCode = i;
            this.m_nAction = i2;
        }

        @Override // java.lang.Runnable
        public void run() {
            try {
                int i = this.m_nAction;
                if (i == 0) {
                    MainActivity.instance.onKeyPressed(this.m_keyCode);
                } else if (i == 1) {
                    MainActivity.instance.onKeyReleased(this.m_keyCode);
                }
            } catch (UnsatisfiedLinkError e) {
                Log.e("RealRacing3", "UnsatisfiedLinkError when processing key event: " + e.getMessage());
            }
        }
    }

    public class MessageExecuteCallback implements Runnable {
        long messageId;

        public MessageExecuteCallback(long j) {
            this.messageId = j;
        }

        @Override // java.lang.Runnable
        public void run() {
            MainActivity.instance.alertMessageExecuteCallback(this.messageId);
        }
    }

    public class Message {
        AlertDialog.Builder mAd;
        private String TAG = "Message";
        AlertDialog mDialog = null;
        boolean mCancelled = false;

        public AlertDialog GetDialog() {
            return this.mDialog;
        }

        public Message(String str, String str2, String str3, String str4, String str5, final MessageCallback messageCallback) {
            this.mAd = null;
            StringBuilder sb = new StringBuilder();
            sb.append("Message(");
            sb.append(str);
            sb.append(", ");
            sb.append(str2);
            sb.append(", ");
            sb.append(str3);
            sb.append(", ");
            sb.append(str4);
            sb.append(")");
            this.mAd = new AlertDialog.Builder(MainActivity.instance);
            if (str != null && !str.isEmpty()) {
                this.mAd.setTitle(str);
            }
            if (str2 != null && !str2.isEmpty()) {
                this.mAd.setMessage(str2);
            }
            this.mAd.setCancelable(false);
            if (str3 != null && !str3.isEmpty()) {
                this.mAd.setPositiveButton(str3, new DialogInterface.OnClickListener() { // from class: com.firemint.realracing.MainActivity.Message.1
                    @Override // android.content.DialogInterface.OnClickListener
                    public void onClick(DialogInterface dialogInterface, int i) {
                        MessageCallback messageCallback2 = messageCallback;
                        if (messageCallback2 != null) {
                            messageCallback2.onMessage(0);
                        }
                    }
                });
            }
            if (str4 != null && !str4.isEmpty()) {
                this.mAd.setNegativeButton(str4, new DialogInterface.OnClickListener() { // from class: com.firemint.realracing.MainActivity.Message.2
                    @Override // android.content.DialogInterface.OnClickListener
                    public void onClick(DialogInterface dialogInterface, int i) {
                        MessageCallback messageCallback2 = messageCallback;
                        if (messageCallback2 != null) {
                            messageCallback2.onMessage(1);
                        }
                    }
                });
                this.mAd.setOnKeyListener(new DialogInterface.OnKeyListener() { // from class: com.firemint.realracing.MainActivity.Message.3
                    @Override // android.content.DialogInterface.OnKeyListener
                    public boolean onKey(DialogInterface dialogInterface, int i, KeyEvent keyEvent) {
                        if (i != 4) {
                            return false;
                        }
                        MessageCallback messageCallback2 = messageCallback;
                        if (messageCallback2 != null) {
                            messageCallback2.onMessage(1);
                        }
                        return true;
                    }
                });
            }
            if (str5 != null && !str5.isEmpty()) {
                this.mAd.setNeutralButton(str5, new DialogInterface.OnClickListener() { // from class: com.firemint.realracing.MainActivity.Message.4
                    @Override // android.content.DialogInterface.OnClickListener
                    public void onClick(DialogInterface dialogInterface, int i) {
                        MessageCallback messageCallback2 = messageCallback;
                        if (messageCallback2 != null) {
                            messageCallback2.onMessage(2);
                        }
                    }
                });
            }
            MainActivity.this.runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.Message.5
                @Override // java.lang.Runnable
                public void run() {
                    Message message = Message.this;
                    if (message.mCancelled) {
                        return;
                    }
                    message.mDialog = message.mAd.show();
                    Message.this.mDialog.setOnDismissListener(new DialogInterface.OnDismissListener() { // from class: com.firemint.realracing.MainActivity.Message.5.1
                        @Override // android.content.DialogInterface.OnDismissListener
                        public void onDismiss(DialogInterface dialogInterface) {
                            MainActivity.instance.OnMessageDismissed(this);
                        }
                    });
                }
            });
        }

        public void Cancel() {
            this.mCancelled = true;
            AlertDialog alertDialog = this.mDialog;
            if (alertDialog != null) {
                alertDialog.dismiss();
            }
        }
    }

    public void showMessage(String str, String str2, String str3, String str4, String str5, final long j, final long j2, final long j3) {
        showMessage(str, str2, str3, str4, str5, new MessageCallback() { // from class: com.firemint.realracing.MainActivity.26
            @Override // com.firemint.realracing.MessageCallback
            public void onMessage(int i) {
                if (i == 0) {
                    MainActivity.instance.getGLView().queueEvent(MainActivity.this.new MessageExecuteCallback(j));
                } else if (i == 1) {
                    MainActivity.instance.getGLView().queueEvent(MainActivity.this.new MessageExecuteCallback(j2));
                } else if (i == 2) {
                    MainActivity.instance.getGLView().queueEvent(MainActivity.this.new MessageExecuteCallback(j3));
                }
            }
        });
    }

    public void showMessage(String str, String str2, String str3, String str4, String str5, MessageCallback messageCallback) {
        this.m_message = new Message(str, str2, str3, str4, str5, messageCallback);
    }

    public void dismissMessage() {
        runOnUiThread(new Runnable() { // from class: com.firemint.realracing.MainActivity.27
            @Override // java.lang.Runnable
            public void run() {
                Message message = MainActivity.this.m_message;
                if (message != null) {
                    message.Cancel();
                }
            }
        });
    }

    public static void logw(String str) {
        Log.w("RealRacing3", str);
    }

    public static void loge(String str) {
        Log.e("RealRacing3", str);
    }
}