Many mobile fixes, Android update check, "Background Input" & "Pause On Focus Lost" options

src/dusk/file_select.cpp

@@ -1,9 +1,16 @@
 #include "file_select.hpp"
 
 #include <memory>
+#include <string_view>
 
 #include <SDL3/SDL_dialog.h>
 #include <SDL3/SDL_error.h>
+#include <SDL3/SDL_stdinc.h>
+
+#if defined(__ANDROID__) || defined(ANDROID)
+#include <SDL3/SDL_system.h>
+#include <jni.h>
+#endif
 
 #if defined(__APPLE__)
 #include <TargetConditionals.h>
@@ -19,6 +26,92 @@
 namespace dusk {
 namespace {
 
+std::string fallback_display_name(std::string_view path) {
+    if (path.empty()) {
+        return {};
+    }
+
+    std::string pathString(path);
+    const std::size_t slash = pathString.find_last_of("/\\");
+    if (slash == std::string::npos || slash + 1 >= pathString.size()) {
+        return pathString;
+    }
+    return pathString.substr(slash + 1);
+}
+
+#if defined(__ANDROID__) || defined(ANDROID)
+bool clear_pending_exception(JNIEnv* env) {
+    if (env == nullptr || !env->ExceptionCheck()) {
+        return false;
+    }
+    env->ExceptionClear();
+    return true;
+}
+
+std::string to_string(JNIEnv* env, jstring value) {
+    if (env == nullptr || value == nullptr) {
+        return {};
+    }
+
+    const char* utf8 = env->GetStringUTFChars(value, nullptr);
+    if (utf8 == nullptr) {
+        clear_pending_exception(env);
+        return {};
+    }
+
+    std::string result(utf8);
+    env->ReleaseStringUTFChars(value, utf8);
+    return result;
+}
+
+std::string android_display_name(std::string_view path) {
+    auto* env = static_cast<JNIEnv*>(SDL_GetAndroidJNIEnv());
+    if (env == nullptr) {
+        return {};
+    }
+
+    jobject activity = static_cast<jobject>(SDL_GetAndroidActivity());
+    if (activity == nullptr || clear_pending_exception(env)) {
+        if (activity != nullptr) {
+            env->DeleteLocalRef(activity);
+        }
+        return {};
+    }
+
+    jclass activityClass = env->GetObjectClass(activity);
+    if (activityClass == nullptr || clear_pending_exception(env)) {
+        env->DeleteLocalRef(activity);
+        return {};
+    }
+
+    jmethodID getDisplayName = env->GetMethodID(
+        activityClass, "getDisplayNameForUri", "(Ljava/lang/String;)Ljava/lang/String;");
+    env->DeleteLocalRef(activityClass);
+    if (getDisplayName == nullptr || clear_pending_exception(env)) {
+        env->DeleteLocalRef(activity);
+        return {};
+    }
+
+    jstring uri = env->NewStringUTF(std::string(path).c_str());
+    if (uri == nullptr || clear_pending_exception(env)) {
+        env->DeleteLocalRef(activity);
+        return {};
+    }
+
+    auto* displayName =
+        static_cast<jstring>(env->CallObjectMethod(activity, getDisplayName, uri));
+    env->DeleteLocalRef(uri);
+    env->DeleteLocalRef(activity);
+    if (displayName == nullptr || clear_pending_exception(env)) {
+        return {};
+    }
+
+    std::string result = to_string(env, displayName);
+    env->DeleteLocalRef(displayName);
+    return result;
+}
+#endif
+
 #if USE_IOS_DIALOG
 struct IOSDialogCallbackState {
     FileCallback callback;
@@ -88,4 +181,16 @@ void ShowFileSelect(FileCallback callback, void* userdata, SDL_Window* window,
                            default_location, allow_many);
 #endif
 }
+
+std::string display_name_for_path(std::string_view path) {
+#if defined(__ANDROID__) || defined(ANDROID)
+    if (path.starts_with("content:") || path.starts_with("file:")) {
+        std::string displayName = android_display_name(path);
+        if (!displayName.empty()) {
+            return displayName;
+        }
+    }
+#endif
+    return fallback_display_name(path);
+}
 }  // namespace dusk

src/dusk/file_select.hpp

@@ -2,6 +2,9 @@
 
 #include <SDL3/SDL_dialog.h>
 
+#include <string>
+#include <string_view>
+
 struct SDL_Window;
 
 namespace dusk {
@@ -9,7 +12,9 @@ namespace dusk {
 using FileCallback = void (*)(void* userdata, const char* path, const char* error);
 
 void ShowFileSelect(FileCallback callback, void* userdata, SDL_Window* window,
-                    const SDL_DialogFileFilter* filters, int nfilters, const char* default_location,
-                    bool allow_many);
+    const SDL_DialogFileFilter* filters, int nfilters, const char* default_location,
+    bool allow_many);
+
+std::string display_name_for_path(std::string_view path);
 
 }  // namespace dusk

src/dusk/http/android.cpp

@@ -0,0 +1,402 @@
+#include "http.hpp"
+
+#include <SDL3/SDL_system.h>
+#include <jni.h>
+
+#include <algorithm>
+#include <limits>
+#include <string_view>
+#include <utility>
+
+namespace dusk::http {
+namespace {
+
+constexpr int JavaErrorNone = 0;
+constexpr int JavaErrorInvalidUrl = 1;
+constexpr int JavaErrorUnsupportedScheme = 2;
+constexpr int JavaErrorTimeout = 3;
+constexpr int JavaErrorTooLarge = 4;
+
+int timeout_ms(std::chrono::milliseconds timeout) {
+    const auto count = std::max<std::chrono::milliseconds::rep>(1, timeout.count());
+    return static_cast<int>(
+        std::min<std::chrono::milliseconds::rep>(count, std::numeric_limits<int>::max()));
+}
+
+jlong max_body_bytes(size_t maxBodyBytes) {
+    return static_cast<jlong>(std::min<size_t>(
+        maxBodyBytes, static_cast<size_t>(std::numeric_limits<jlong>::max())));
+}
+
+bool clear_pending_exception(JNIEnv* env) {
+    if (env == nullptr || !env->ExceptionCheck()) {
+        return false;
+    }
+    env->ExceptionClear();
+    return true;
+}
+
+std::string to_string(JNIEnv* env, jstring value) {
+    if (env == nullptr || value == nullptr) {
+        return {};
+    }
+
+    const char* utf8 = env->GetStringUTFChars(value, nullptr);
+    if (utf8 == nullptr) {
+        clear_pending_exception(env);
+        return {};
+    }
+
+    std::string result(utf8);
+    env->ReleaseStringUTFChars(value, utf8);
+    return result;
+}
+
+jstring to_jstring(JNIEnv* env, std::string_view value) {
+    if (env == nullptr) {
+        return nullptr;
+    }
+    return env->NewStringUTF(std::string(value).c_str());
+}
+
+Error map_java_error(int error) {
+    switch (error) {
+    case JavaErrorNone:
+        return Error::None;
+    case JavaErrorInvalidUrl:
+        return Error::InvalidUrl;
+    case JavaErrorUnsupportedScheme:
+        return Error::UnsupportedScheme;
+    case JavaErrorTimeout:
+        return Error::Timeout;
+    case JavaErrorTooLarge:
+        return Error::TooLarge;
+    default:
+        return Error::Network;
+    }
+}
+
+jclass load_dusk_class(JNIEnv* env, jobject activity, const char* className) {
+    jclass activityClass = env->GetObjectClass(activity);
+    if (activityClass == nullptr || clear_pending_exception(env)) {
+        return nullptr;
+    }
+
+    jmethodID getClassLoader =
+        env->GetMethodID(activityClass, "getClassLoader", "()Ljava/lang/ClassLoader;");
+    env->DeleteLocalRef(activityClass);
+    if (getClassLoader == nullptr || clear_pending_exception(env)) {
+        return nullptr;
+    }
+
+    jobject classLoader = env->CallObjectMethod(activity, getClassLoader);
+    if (classLoader == nullptr || clear_pending_exception(env)) {
+        return nullptr;
+    }
+
+    jclass classLoaderClass = env->FindClass("java/lang/ClassLoader");
+    if (classLoaderClass == nullptr || clear_pending_exception(env)) {
+        env->DeleteLocalRef(classLoader);
+        return nullptr;
+    }
+
+    jmethodID loadClass = env->GetMethodID(
+        classLoaderClass, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
+    env->DeleteLocalRef(classLoaderClass);
+    if (loadClass == nullptr || clear_pending_exception(env)) {
+        env->DeleteLocalRef(classLoader);
+        return nullptr;
+    }
+
+    jstring javaClassName = env->NewStringUTF(className);
+    if (javaClassName == nullptr || clear_pending_exception(env)) {
+        env->DeleteLocalRef(classLoader);
+        return nullptr;
+    }
+
+    auto* loadedClass =
+        static_cast<jclass>(env->CallObjectMethod(classLoader, loadClass, javaClassName));
+    env->DeleteLocalRef(javaClassName);
+    env->DeleteLocalRef(classLoader);
+    if (loadedClass == nullptr || clear_pending_exception(env)) {
+        return nullptr;
+    }
+
+    return loadedClass;
+}
+
+jobjectArray make_string_array(JNIEnv* env, const std::vector<Header>& headers, bool names) {
+    jclass stringClass = env->FindClass("java/lang/String");
+    if (stringClass == nullptr || clear_pending_exception(env)) {
+        return nullptr;
+    }
+
+    jobjectArray array =
+        env->NewObjectArray(static_cast<jsize>(headers.size()), stringClass, nullptr);
+    env->DeleteLocalRef(stringClass);
+    if (array == nullptr || clear_pending_exception(env)) {
+        return nullptr;
+    }
+
+    for (jsize i = 0; i < static_cast<jsize>(headers.size()); ++i) {
+        const std::string& value = names ? headers[static_cast<size_t>(i)].name :
+                                           headers[static_cast<size_t>(i)].value;
+        jstring javaValue = to_jstring(env, value);
+        if (javaValue == nullptr || clear_pending_exception(env)) {
+            env->DeleteLocalRef(array);
+            return nullptr;
+        }
+        env->SetObjectArrayElement(array, i, javaValue);
+        env->DeleteLocalRef(javaValue);
+        if (clear_pending_exception(env)) {
+            env->DeleteLocalRef(array);
+            return nullptr;
+        }
+    }
+
+    return array;
+}
+
+std::vector<Header> read_headers(JNIEnv* env, jobjectArray names, jobjectArray values) {
+    std::vector<Header> headers;
+    if (names == nullptr || values == nullptr) {
+        return headers;
+    }
+
+    const jsize count = std::min(env->GetArrayLength(names), env->GetArrayLength(values));
+    headers.reserve(static_cast<size_t>(count));
+    for (jsize i = 0; i < count; ++i) {
+        auto* name = static_cast<jstring>(env->GetObjectArrayElement(names, i));
+        auto* value = static_cast<jstring>(env->GetObjectArrayElement(values, i));
+        if (clear_pending_exception(env)) {
+            if (name != nullptr) {
+                env->DeleteLocalRef(name);
+            }
+            if (value != nullptr) {
+                env->DeleteLocalRef(value);
+            }
+            headers.clear();
+            return headers;
+        }
+
+        if (name != nullptr) {
+            headers.push_back({
+                .name = to_string(env, name),
+                .value = to_string(env, value),
+            });
+        }
+
+        if (name != nullptr) {
+            env->DeleteLocalRef(name);
+        }
+        if (value != nullptr) {
+            env->DeleteLocalRef(value);
+        }
+    }
+
+    return headers;
+}
+
+std::string read_body(JNIEnv* env, jbyteArray body) {
+    if (body == nullptr) {
+        return {};
+    }
+
+    const jsize bodySize = env->GetArrayLength(body);
+    std::string result(static_cast<size_t>(bodySize), '\0');
+    if (bodySize > 0) {
+        env->GetByteArrayRegion(body, 0, bodySize, reinterpret_cast<jbyte*>(result.data()));
+        if (clear_pending_exception(env)) {
+            return {};
+        }
+    }
+    return result;
+}
+
+Result result_from_response(JNIEnv* env, jobject response) {
+    if (response == nullptr) {
+        return {
+            .error = Error::Network,
+            .message = "Android HTTP request did not return a response",
+        };
+    }
+
+    jclass responseClass = env->GetObjectClass(response);
+    if (responseClass == nullptr || clear_pending_exception(env)) {
+        return {
+            .error = Error::Network,
+            .message = "Failed to inspect Android HTTP response",
+        };
+    }
+
+    jfieldID errorField = env->GetFieldID(responseClass, "error", "I");
+    jfieldID messageField = env->GetFieldID(responseClass, "message", "Ljava/lang/String;");
+    jfieldID statusField = env->GetFieldID(responseClass, "statusCode", "I");
+    jfieldID headerNamesField =
+        env->GetFieldID(responseClass, "headerNames", "[Ljava/lang/String;");
+    jfieldID headerValuesField =
+        env->GetFieldID(responseClass, "headerValues", "[Ljava/lang/String;");
+    jfieldID bodyField = env->GetFieldID(responseClass, "body", "[B");
+    env->DeleteLocalRef(responseClass);
+    if (errorField == nullptr || messageField == nullptr || statusField == nullptr ||
+        headerNamesField == nullptr || headerValuesField == nullptr || bodyField == nullptr ||
+        clear_pending_exception(env))
+    {
+        return {
+            .error = Error::Network,
+            .message = "Android HTTP response shape was not recognized",
+        };
+    }
+
+    const int javaError = env->GetIntField(response, errorField);
+    auto* message = static_cast<jstring>(env->GetObjectField(response, messageField));
+    auto* headerNames = static_cast<jobjectArray>(env->GetObjectField(response, headerNamesField));
+    auto* headerValues =
+        static_cast<jobjectArray>(env->GetObjectField(response, headerValuesField));
+    auto* body = static_cast<jbyteArray>(env->GetObjectField(response, bodyField));
+    if (clear_pending_exception(env)) {
+        return {
+            .error = Error::Network,
+            .message = "Failed to read Android HTTP response",
+        };
+    }
+
+    Response httpResponse{
+        .statusCode = static_cast<int>(env->GetIntField(response, statusField)),
+        .headers = read_headers(env, headerNames, headerValues),
+        .body = read_body(env, body),
+    };
+
+    std::string messageString = to_string(env, message);
+
+    if (message != nullptr) {
+        env->DeleteLocalRef(message);
+    }
+    if (headerNames != nullptr) {
+        env->DeleteLocalRef(headerNames);
+    }
+    if (headerValues != nullptr) {
+        env->DeleteLocalRef(headerValues);
+    }
+    if (body != nullptr) {
+        env->DeleteLocalRef(body);
+    }
+
+    return {
+        .error = map_java_error(javaError),
+        .message = std::move(messageString),
+        .response = std::move(httpResponse),
+    };
+}
+
+}  // namespace
+
+bool available() noexcept {
+    return true;
+}
+
+Backend backend() noexcept {
+    return Backend::Android;
+}
+
+const char* backend_name() noexcept {
+    return "Android";
+}
+
+Result get(const Request& request) {
+    if (request.url.empty()) {
+        return {
+            .error = Error::InvalidUrl,
+            .message = "URL is empty",
+        };
+    }
+    if (!request.url.starts_with("https://")) {
+        return {
+            .error = Error::UnsupportedScheme,
+            .message = "Only https:// URLs are supported",
+        };
+    }
+
+    auto* env = static_cast<JNIEnv*>(SDL_GetAndroidJNIEnv());
+    if (env == nullptr) {
+        return {
+            .error = Error::Network,
+            .message = "Failed to access Android JNI environment",
+        };
+    }
+
+    jobject activity = static_cast<jobject>(SDL_GetAndroidActivity());
+    if (activity == nullptr || clear_pending_exception(env)) {
+        if (activity != nullptr) {
+            env->DeleteLocalRef(activity);
+        }
+        return {
+            .error = Error::Network,
+            .message = "Failed to access Android activity",
+        };
+    }
+
+    jclass clientClass =
+        load_dusk_class(env, activity, "com.twilitrealm.dusk.DuskHttpClient");
+    env->DeleteLocalRef(activity);
+    if (clientClass == nullptr) {
+        return {
+            .error = Error::Network,
+            .message = "Failed to load Android HTTP helper",
+        };
+    }
+
+    jmethodID getMethod = env->GetStaticMethodID(clientClass, "get",
+        "(Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;IJ)"
+        "Lcom/twilitrealm/dusk/DuskHttpClient$Response;");
+    if (getMethod == nullptr || clear_pending_exception(env)) {
+        env->DeleteLocalRef(clientClass);
+        return {
+            .error = Error::Network,
+            .message = "Failed to find Android HTTP helper method",
+        };
+    }
+
+    jstring url = to_jstring(env, request.url);
+    jobjectArray headerNames = make_string_array(env, request.headers, true);
+    jobjectArray headerValues = make_string_array(env, request.headers, false);
+    if (url == nullptr || headerNames == nullptr || headerValues == nullptr ||
+        clear_pending_exception(env))
+    {
+        if (url != nullptr) {
+            env->DeleteLocalRef(url);
+        }
+        if (headerNames != nullptr) {
+            env->DeleteLocalRef(headerNames);
+        }
+        if (headerValues != nullptr) {
+            env->DeleteLocalRef(headerValues);
+        }
+        env->DeleteLocalRef(clientClass);
+        return {
+            .error = Error::Network,
+            .message = "Failed to prepare Android HTTP request",
+        };
+    }
+
+    jobject response = env->CallStaticObjectMethod(clientClass, getMethod, url, headerNames,
+        headerValues, timeout_ms(request.timeout), max_body_bytes(request.maxBodyBytes));
+    env->DeleteLocalRef(url);
+    env->DeleteLocalRef(headerNames);
+    env->DeleteLocalRef(headerValues);
+    env->DeleteLocalRef(clientClass);
+    if (clear_pending_exception(env)) {
+        return {
+            .error = Error::Network,
+            .message = "Android HTTP request failed with a Java exception",
+        };
+    }
+
+    Result result = result_from_response(env, response);
+    if (response != nullptr) {
+        env->DeleteLocalRef(response);
+    }
+    return result;
+}
+
+}  // namespace dusk::http

src/dusk/http/http.hpp

@@ -13,6 +13,7 @@ enum class Backend {
     WinHttp,
     UrlSession,
     LibCurl,
+    Android,
 };
 
 enum class Error {

src/dusk/settings.cpp

@@ -82,6 +82,7 @@ UserSettings g_userSettings = {
         .freeCameraSensitivity {"game.freeCameraSensitivity", 1.0f},
         .debugFlyCam {"game.debugFlyCam", false},
         .debugFlyCamLockEvents {"game.debugFlyCamLockEvents", true},
+        .allowBackgroundInput {"game.allowBackgroundInput", true},
 
         // Cheats
         .infiniteHearts {"game.infiniteHearts", false},
@@ -215,6 +216,7 @@ void registerSettings() {
     Register(g_userSettings.game.freeCamera);
     Register(g_userSettings.game.debugFlyCam);
     Register(g_userSettings.game.debugFlyCamLockEvents);
+    Register(g_userSettings.game.allowBackgroundInput);
 
     Register(g_userSettings.backend.isoPath);
     Register(g_userSettings.backend.isoVerification);

src/dusk/ui/prelaunch.cpp

@@ -445,8 +445,7 @@ private:
         }
 
         if (mFileName != nullptr) {
-            std::string fileName =
-                std::filesystem::path(sDiscVerificationTask->path).filename().string();
+            std::string fileName = display_name_for_path(sDiscVerificationTask->path);
             if (fileName.empty()) {
                 fileName = sDiscVerificationTask->path;
             }

src/dusk/ui/settings.cpp

@@ -6,6 +6,7 @@
 #include "dusk/audio/DuskAudioSystem.h"
 #include "dusk/audio/DuskDsp.hpp"
 #include "dusk/config.hpp"
+#include "dusk/file_select.hpp"
 #include "dusk/imgui/ImGuiEngine.hpp"
 #include "dusk/livesplit.h"
 #include "graphics_tuner.hpp"
@@ -317,7 +318,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                                 if (path.empty()) {
                                     display = "(none)";
                                 } else {
-                                    display = std::filesystem::path(path).filename().string();
+                                    display = display_name_for_path(path);
                                     if (display.empty()) {
                                         display = path;
                                     }
@@ -612,6 +613,12 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 pane.clear();
                 pane.add_text("Open controller binding configuration.");
             });
+        config_bool_select(leftPane, rightPane, getSettings().game.allowBackgroundInput,
+            {
+                .key = "Allow Background Input",
+                .helpText = "Allow controller input even when the game window is not focused.",
+                .onChange = [](bool value) { aurora_set_background_input(value); },
+            });
 
         leftPane.add_section("Camera");
         addOption("Free Camera", getSettings().game.freeCamera,
@@ -923,6 +930,12 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .helpText = "Checks GitHub releases for a new Dusk version on startup.<br/><br/>"
                             "No personal information is transmitted or collected.",
             });
+        config_bool_select(leftPane, rightPane, getSettings().game.pauseOnFocusLost,
+            {
+                .key = "Pause On Focus Lost",
+                .helpText = "Pause the game when window focus is lost.",
+                .onChange = [](bool value) { aurora_set_pause_on_focus_lost(value); },
+            });
         config_bool_select(leftPane, rightPane, getSettings().backend.enableAdvancedSettings,
             {
                 .key = "Enable Advanced Settings",

src/dusk/ui/ui.cpp

@@ -255,11 +255,7 @@ void update() noexcept {
 }
 
 std::filesystem::path resource_path(const std::filesystem::path& filename) noexcept {
-    const char* basePath = SDL_GetBasePath();
-    if (basePath == nullptr) {
-        return std::filesystem::path("res") / filename;
-    }
-    return std::filesystem::path(basePath) / "res" / filename;
+    return std::filesystem::path("res") / filename;
 }
 
 std::string escape(std::string_view str) noexcept {

src/dusk/ui/window.cpp

@@ -16,10 +16,7 @@ namespace dusk::ui {
 namespace {
 
 float base_body_padding(Rml::Context* context) noexcept {
-    if (context == nullptr) {
-        return 64.0f;
-    }
-    const float dpRatio = std::max(context->GetDensityIndependentPixelRatio(), 0.001f);
+    const float dpRatio = context->GetDensityIndependentPixelRatio();
     const float heightDp = static_cast<float>(context->GetDimensions().y) / dpRatio;
     if (heightDp <= 640.0f) {
         return 16.0f * dpRatio;

src/m_Do/m_Do_main.cpp

@@ -105,7 +105,6 @@ const int audioHeapSize = 0x14D800;
 bool dusk::IsRunning = true;
 bool dusk::IsShuttingDown = false;
 bool dusk::IsGameLaunched = false;
-bool dusk::IsFocusPaused = false;
 bool dusk::RestartRequested = false;
 std::filesystem::path dusk::ConfigPath;
 #endif
@@ -228,19 +227,16 @@ void main01(void) {
             switch (event->type) {
             case AURORA_NONE:
                 goto eventsDone;
+            case AURORA_PAUSED:
+                dusk::audio::SetPaused(true);
+                break;
+            case AURORA_UNPAUSED:
+                dusk::audio::SetPaused(false);
+                dusk::game_clock::reset_frame_timer();
+                break;
             case AURORA_SDL_EVENT:
                 dusk::ui::handle_event(event->sdl);
                 dusk::g_imguiConsole.HandleSDLEvent(event->sdl);
-                if (event->sdl.type == SDL_EVENT_WINDOW_FOCUS_LOST &&
-                    dusk::getSettings().game.pauseOnFocusLost) {
-                    dusk::IsFocusPaused = true;
-                    dusk::audio::SetPaused(true);
-                } else if (event->sdl.type == SDL_EVENT_WINDOW_FOCUS_GAINED &&
-                           dusk::IsFocusPaused) {
-                    dusk::IsFocusPaused = false;
-                    dusk::audio::SetPaused(false);
-                    dusk::game_clock::reset_frame_timer();
-                }
                 break;
             case AURORA_DISPLAY_SCALE_CHANGED:
                 dusk::ImGuiEngine_Initialize(event->windowSize.scale);
@@ -254,19 +250,14 @@ void main01(void) {
 
         eventsDone:;
 
-        if (dusk::IsFocusPaused) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(16));
+        if (!aurora_begin_frame()) {
+            DuskLog.debug("aurora_begin_frame returned false, skipping draw this frame");
             continue;
         }
 
         VIWaitForRetrace();
 
         dusk::lastFrameAuroraStats = *aurora_get_stats();
-        if (!aurora_begin_frame()) {
-            DuskLog.debug("aurora_begin_frame returned false, skipping draw this frame");
-            continue;
-        }
-
         mDoGph_gInf_c::updateRenderSize();
 
         dusk::ui::update();
@@ -571,7 +562,8 @@ int game_main(int argc, char* argv[]) {
         config.logLevel = startupLogLevel;
         config.mem1Size = 256 * 1024 * 1024;
         config.mem2Size = 24 * 1024 * 1024;
-        config.allowJoystickBackgroundEvents = true;
+        config.allowJoystickBackgroundEvents = dusk::getSettings().game.allowBackgroundInput;
+        config.pauseOnFocusLost = dusk::getSettings().game.pauseOnFocusLost;
         config.imGuiInitCallback = &aurora_imgui_init_callback;
         config.allowTextureReplacements = true;
         config.allowTextureDumps = false;
@@ -618,13 +610,19 @@ int game_main(int argc, char* argv[]) {
 
     // Invalidate a bad saved isoPath so that Dusk can't get blocked from starting up.
     // This is only a metadata check; full hash verification is handled by the prelaunch UI.
+    bool forcePreLaunchUI = false;
+    bool saveConfigBeforePrelaunch = false;
+
     const std::string p = dusk::getSettings().backend.isoPath;
     dusk::iso::DiscInfo discInfo{};
     if (!p.empty() &&
         dusk::iso::inspect(p.c_str(), discInfo) != dusk::iso::ValidationError::Success)
     {
+        DuskLog.warn("Saved DVD image path failed validation, clearing configured path: {}", p);
         dusk::getSettings().backend.isoPath.setValue("");
         dusk::getSettings().backend.isoVerification.setValue(dusk::DiscVerificationState::Unknown);
+        forcePreLaunchUI = true;
+        saveConfigBeforePrelaunch = true;
     }
 
     std::string dvd_path;
@@ -636,6 +634,7 @@ int game_main(int argc, char* argv[]) {
             dvd_opened = aurora_dvd_open(dvd_path.c_str());
             if (!dvd_opened) {
                 DuskLog.warn("Failed to open DVD image from command line: {}, opening prelaunch UI", dvd_path);
+                forcePreLaunchUI = true;
             } else {
                 dusk::getSettings().backend.isoPath.setValue(dvd_path);
                 dusk::getSettings().backend.isoVerification.setValue(
@@ -645,10 +644,23 @@ int game_main(int argc, char* argv[]) {
             }
         } else {
             DuskLog.warn("DVD image from command line failed validation: {}, opening prelaunch UI", dvd_path);
+            forcePreLaunchUI = true;
         }
     }
 
     if (!dvd_opened) {
+        if (dusk::getSettings().backend.isoPath.getValue().empty()) {
+            forcePreLaunchUI = true;
+        }
+        if (forcePreLaunchUI && dusk::getSettings().backend.skipPreLaunchUI.getValue()) {
+            DuskLog.warn("Prelaunch UI was disabled with no usable DVD image, enabling prelaunch UI");
+            dusk::getSettings().backend.skipPreLaunchUI.setValue(false);
+            saveConfigBeforePrelaunch = true;
+        }
+        if (saveConfigBeforePrelaunch) {
+            dusk::config::Save();
+        }
+
         if (!dusk::getSettings().backend.skipPreLaunchUI) {
             dusk::ui::push_document(std::make_unique<dusk::ui::Prelaunch>(), true);