Android #118

Merge pull request #11922 from t895/simplify-card-layout
android: Simplify game card layout
2023-10-31 00:57:24 +00:00 · 2023-10-30 15:32:45 -04:00 · 2023-10-30 15:32:39 -04:00 · 2023-10-30 15:32:31 -04:00 · 2023-10-30 13:28:52 -04:00 · 2023-10-30 13:28:11 -04:00
54 changed files with 1076 additions and 1175 deletions
--- a/.ci/scripts/clang/docker.sh
+++ b/.ci/scripts/clang/docker.sh
@ -19,6 +19,7 @@ cmake .. \
      -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
      -DENABLE_QT_TRANSLATION=ON \
      -DUSE_DISCORD_PRESENCE=ON \
+      -DYUZU_CRASH_DUMPS=ON \
      -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
      -DYUZU_USE_BUNDLED_FFMPEG=ON \
      -GNinja
--- a/.ci/scripts/linux/docker.sh
+++ b/.ci/scripts/linux/docker.sh
@ -23,6 +23,7 @@ cmake .. \
      -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
      -DYUZU_USE_BUNDLED_FFMPEG=ON \
      -DYUZU_ENABLE_LTO=ON \
+      -DYUZU_CRASH_DUMPS=ON \
      -GNinja

 ninja
--- a/.ci/scripts/windows/docker.sh
+++ b/.ci/scripts/windows/docker.sh
@ -17,7 +17,6 @@ cmake .. \
    -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
    -DENABLE_QT_TRANSLATION=ON \
    -DUSE_CCACHE=ON \
-    -DYUZU_CRASH_DUMPS=ON \
    -DYUZU_USE_BUNDLED_SDL2=OFF \
    -DYUZU_USE_EXTERNAL_SDL2=OFF \
    -DYUZU_TESTS=OFF \
--- a/.gitmodules
+++ b/.gitmodules
@ -32,7 +32,7 @@
 	path = externals/xbyak
 	url = https://github.com/herumi/xbyak.git
 [submodule "opus"]
-	path = externals/opus/opus
+	path = externals/opus
 	url = https://github.com/xiph/opus.git
 [submodule "SDL"]
 	path = externals/SDL
@ -58,3 +58,6 @@
 [submodule "VulkanMemoryAllocator"]
 	path = externals/VulkanMemoryAllocator
 	url = https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
+[submodule "breakpad"]
+	path = externals/breakpad
+	url = https://github.com/yuzu-emu/breakpad.git
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -52,7 +52,7 @@ option(YUZU_DOWNLOAD_ANDROID_VVL "Download validation layer binary for android"

 CMAKE_DEPENDENT_OPTION(YUZU_ROOM "Compile LDN room server" ON "NOT ANDROID" OFF)

-CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile Windows crash dump (Minidump) support" OFF "WIN32" OFF)
+CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)

 option(YUZU_USE_BUNDLED_VCPKG "Use vcpkg for yuzu dependencies" "${MSVC}")

@ -139,9 +139,6 @@ if (YUZU_USE_BUNDLED_VCPKG)
    if (YUZU_TESTS)
        list(APPEND VCPKG_MANIFEST_FEATURES "yuzu-tests")
    endif()
-    if (YUZU_CRASH_DUMPS)
-        list(APPEND VCPKG_MANIFEST_FEATURES "dbghelp")
-    endif()
    if (ENABLE_WEB_SERVICE)
        list(APPEND VCPKG_MANIFEST_FEATURES "web-service")
    endif()
@ -551,6 +548,18 @@ if (NOT YUZU_USE_BUNDLED_FFMPEG)
    find_package(FFmpeg 4.3 REQUIRED QUIET COMPONENTS ${FFmpeg_COMPONENTS})
 endif()

+if (WIN32 AND YUZU_CRASH_DUMPS)
+    set(BREAKPAD_VER "breakpad-c89f9dd")
+    download_bundled_external("breakpad/" ${BREAKPAD_VER} BREAKPAD_PREFIX)
+
+    set(BREAKPAD_CLIENT_INCLUDE_DIR "${BREAKPAD_PREFIX}/include")
+    set(BREAKPAD_CLIENT_LIBRARY "${BREAKPAD_PREFIX}/lib/libbreakpad_client.lib")
+
+    add_library(libbreakpad_client INTERFACE IMPORTED)
+    target_link_libraries(libbreakpad_client INTERFACE "${BREAKPAD_CLIENT_LIBRARY}")
+    target_include_directories(libbreakpad_client INTERFACE "${BREAKPAD_CLIENT_INCLUDE_DIR}")
+endif()
+
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
@ -570,13 +579,6 @@ elseif (WIN32)
        # PSAPI is the Process Status API
        set(PLATFORM_LIBRARIES ${PLATFORM_LIBRARIES} psapi imm32 version)
    endif()
-
-    if (YUZU_CRASH_DUMPS)
-        find_library(DBGHELP_LIBRARY dbghelp)
-        if ("${DBGHELP_LIBRARY}" STREQUAL "DBGHELP_LIBRARY-NOTFOUND")
-            message(FATAL_ERROR "YUZU_CRASH_DUMPS enabled but dbghelp library not found")
-        endif()
-    endif()
 elseif (CMAKE_SYSTEM_NAME MATCHES "^(Linux|kFreeBSD|GNU|SunOS)$")
    set(PLATFORM_LIBRARIES rt)
 endif()
--- a/README.md
+++ b/README.md
@ -1,6 +1,5 @@
 | Pull Request | Commit | Title | Author | Merged? |
 |----|----|----|----|----|
-| [11910](https://github.com/yuzu-emu/yuzu//pull/11910) | [`8427b9d49`](https://github.com/yuzu-emu/yuzu//pull/11910/files) | renderer_vulkan: ensure exception on surface loss | [liamwhite](https://github.com/liamwhite/) | Yes |


 End of merge log. You can find the original README.md below the break.
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@ -134,6 +134,10 @@ endif()

 # Opus
 if (NOT TARGET Opus::opus)
+    set(OPUS_BUILD_TESTING OFF)
+    set(OPUS_BUILD_PROGRAMS OFF)
+    set(OPUS_INSTALL_PKG_CONFIG_MODULE OFF)
+    set(OPUS_INSTALL_CMAKE_CONFIG_MODULE OFF)
    add_subdirectory(opus)
 endif()

@ -189,3 +193,105 @@ if (ANDROID)
       add_subdirectory(libadrenotools)
   endif()
 endif()
+
+# Breakpad
+# https://github.com/microsoft/vcpkg/blob/master/ports/breakpad/CMakeLists.txt
+if (YUZU_CRASH_DUMPS AND NOT TARGET libbreakpad_client)
+    set(BREAKPAD_WIN32_DEFINES
+        NOMINMAX
+        UNICODE
+        WIN32_LEAN_AND_MEAN
+        _CRT_SECURE_NO_WARNINGS
+        _CRT_SECURE_NO_DEPRECATE
+        _CRT_NONSTDC_NO_DEPRECATE
+    )
+
+    # libbreakpad
+    add_library(libbreakpad STATIC)
+    file(GLOB_RECURSE LIBBREAKPAD_SOURCES breakpad/src/processor/*.cc)
+    file(GLOB_RECURSE LIBDISASM_SOURCES breakpad/src/third_party/libdisasm/*.c)
+    list(FILTER LIBBREAKPAD_SOURCES EXCLUDE REGEX "_unittest|_selftest|synth_minidump|/tests|/testdata|/solaris|microdump_stackwalk|minidump_dump|minidump_stackwalk")
+    if (WIN32)
+        list(FILTER LIBBREAKPAD_SOURCES EXCLUDE REGEX "/linux|/mac|/android")
+        target_compile_definitions(libbreakpad PRIVATE ${BREAKPAD_WIN32_DEFINES})
+        target_include_directories(libbreakpad PRIVATE "${CMAKE_GENERATOR_INSTANCE}/DIA SDK/include")
+    elseif (APPLE)
+        list(FILTER LIBBREAKPAD_SOURCES EXCLUDE REGEX "/linux|/windows|/android")
+    else()
+        list(FILTER LIBBREAKPAD_SOURCES EXCLUDE REGEX "/mac|/windows|/android")
+    endif()
+    target_sources(libbreakpad PRIVATE ${LIBBREAKPAD_SOURCES} ${LIBDISASM_SOURCES})
+    target_include_directories(libbreakpad
+        PUBLIC
+            ${CMAKE_CURRENT_SOURCE_DIR}/breakpad/src
+            ${CMAKE_CURRENT_SOURCE_DIR}/breakpad/src/third_party/libdisasm
+    )
+
+    # libbreakpad_client
+    add_library(libbreakpad_client STATIC)
+    file(GLOB LIBBREAKPAD_COMMON_SOURCES breakpad/src/common/*.cc breakpad/src/common/*.c breakpad/src/client/*.cc)
+
+    if (WIN32)
+        file(GLOB_RECURSE LIBBREAKPAD_CLIENT_SOURCES breakpad/src/client/windows/*.cc breakpad/src/common/windows/*.cc)
+        list(FILTER LIBBREAKPAD_COMMON_SOURCES EXCLUDE REGEX "language.cc|path_helper.cc|stabs_to_module.cc|stabs_reader.cc|minidump_file_writer.cc")
+        target_include_directories(libbreakpad_client PRIVATE "${CMAKE_GENERATOR_INSTANCE}/DIA SDK/include")
+        target_compile_definitions(libbreakpad_client PRIVATE ${BREAKPAD_WIN32_DEFINES})
+    elseif (APPLE)
+        target_compile_definitions(libbreakpad_client PRIVATE HAVE_MACH_O_NLIST_H)
+        file(GLOB_RECURSE LIBBREAKPAD_CLIENT_SOURCES breakpad/src/client/mac/*.cc breakpad/src/common/mac/*.cc)
+        list(APPEND LIBBREAKPAD_CLIENT_SOURCES breakpad/src/common/mac/MachIPC.mm)
+    else()
+        target_compile_definitions(libbreakpad_client PUBLIC -DHAVE_A_OUT_H)
+        file(GLOB_RECURSE LIBBREAKPAD_CLIENT_SOURCES breakpad/src/client/linux/*.cc breakpad/src/common/linux/*.cc)
+    endif()
+    list(APPEND LIBBREAKPAD_CLIENT_SOURCES ${LIBBREAKPAD_COMMON_SOURCES})
+    list(FILTER LIBBREAKPAD_CLIENT_SOURCES EXCLUDE REGEX "/sender|/tests|/unittests|/testcases|_unittest|_test")
+    target_sources(libbreakpad_client PRIVATE ${LIBBREAKPAD_CLIENT_SOURCES})
+    target_include_directories(libbreakpad_client PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/breakpad/src)
+
+    if (WIN32)
+        target_link_libraries(libbreakpad_client PRIVATE wininet.lib)
+    elseif (APPLE)
+        find_library(CoreFoundation_FRAMEWORK CoreFoundation)
+        target_link_libraries(libbreakpad_client PRIVATE ${CoreFoundation_FRAMEWORK})
+    else()
+        find_library(PTHREAD_LIBRARIES pthread)
+        target_compile_definitions(libbreakpad_client PRIVATE HAVE_GETCONTEXT=1)
+        if (PTHREAD_LIBRARIES)
+            target_link_libraries(libbreakpad_client PRIVATE ${PTHREAD_LIBRARIES})
+        endif()
+    endif()
+
+    # Host tools for symbol processing
+    if (LINUX)
+        find_package(ZLIB REQUIRED)
+
+        add_executable(minidump_stackwalk breakpad/src/processor/minidump_stackwalk.cc)
+        target_link_libraries(minidump_stackwalk PRIVATE libbreakpad libbreakpad_client)
+
+        add_executable(dump_syms
+            breakpad/src/common/dwarf_cfi_to_module.cc
+            breakpad/src/common/dwarf_cu_to_module.cc
+            breakpad/src/common/dwarf_line_to_module.cc
+            breakpad/src/common/dwarf_range_list_handler.cc
+            breakpad/src/common/language.cc
+            breakpad/src/common/module.cc
+            breakpad/src/common/path_helper.cc
+            breakpad/src/common/stabs_reader.cc
+            breakpad/src/common/stabs_to_module.cc
+            breakpad/src/common/dwarf/bytereader.cc
+            breakpad/src/common/dwarf/dwarf2diehandler.cc
+            breakpad/src/common/dwarf/dwarf2reader.cc
+            breakpad/src/common/dwarf/elf_reader.cc
+            breakpad/src/common/linux/crc32.cc
+            breakpad/src/common/linux/dump_symbols.cc
+            breakpad/src/common/linux/elf_symbols_to_module.cc
+            breakpad/src/common/linux/elfutils.cc
+            breakpad/src/common/linux/file_id.cc
+            breakpad/src/common/linux/linux_libc_support.cc
+            breakpad/src/common/linux/memory_mapped_file.cc
+            breakpad/src/common/linux/safe_readlink.cc
+            breakpad/src/tools/linux/dump_syms/dump_syms.cc)
+        target_link_libraries(dump_syms PRIVATE libbreakpad_client ZLIB::ZLIB)
+    endif()
+endif()
--- a/externals/SDL
+++ b/externals/SDL
--- a/externals/Vulkan-Headers
+++ b/externals/Vulkan-Headers
--- a/externals/VulkanMemoryAllocator
+++ b/externals/VulkanMemoryAllocator
--- a/externals/breakpad
+++ b/externals/breakpad
--- a/externals/cpp-httplib
+++ b/externals/cpp-httplib
--- a/externals/cpp-jwt
+++ b/externals/cpp-jwt
--- a/externals/dynarmic
+++ b/externals/dynarmic
--- a/externals/ffmpeg/ffmpeg
+++ b/externals/ffmpeg/ffmpeg
--- a/externals/inih/inih
+++ b/externals/inih/inih
--- a/externals/libusb/CMakeLists.txt
+++ b/externals/libusb/CMakeLists.txt
@ -49,11 +49,6 @@ if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)

    set(LIBUSB_INCLUDE_DIRS "${LIBUSB_SRC_DIR}/libusb" CACHE PATH "libusb headers path" FORCE)

-    # MINGW: causes "externals/libusb/libusb/libusb/os/windows_winusb.c:1427:2: error: conversion to non-scalar type requested", so cannot statically link it for now.
-    if (NOT MINGW)
-        set(LIBUSB_CFLAGS "-DGUID_DEVINTERFACE_USB_DEVICE=\\(GUID\\){0xA5DCBF10,0x6530,0x11D2,{0x90,0x1F,0x00,0xC0,0x4F,0xB9,0x51,0xED}}")
-    endif()
-
    make_directory("${LIBUSB_PREFIX}")

    add_custom_command(
@ -146,8 +141,6 @@ else() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
            target_include_directories(usb BEFORE PRIVATE libusb/msvc)
        endif()

-        # Works around other libraries providing their own definition of USB GUIDs (e.g. SDL2)
-        target_compile_definitions(usb PRIVATE "-DGUID_DEVINTERFACE_USB_DEVICE=(GUID){ 0xA5DCBF10, 0x6530, 0x11D2, {0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED}}")
    else()
        target_include_directories(usb
            # turns out other projects also have "config.h", so make sure the
--- a/externals/libusb/libusb
+++ b/externals/libusb/libusb
--- a/externals/opus
+++ b/externals/opus
--- a/externals/opus/CMakeLists.txt
+++ b/externals/opus/CMakeLists.txt
@ -1,259 +0,0 @@
-# SPDX-FileCopyrightText: 2019 yuzu Emulator Project
-# SPDX-License-Identifier: GPL-2.0-or-later
-
-cmake_minimum_required(VERSION 3.8)
-
-project(opus)
-
-option(OPUS_STACK_PROTECTOR "Use stack protection" OFF)
-option(OPUS_USE_ALLOCA "Use alloca for stack arrays (on non-C99 compilers)" OFF)
-option(OPUS_CUSTOM_MODES "Enable non-Opus modes, e.g. 44.1 kHz & 2^n frames" OFF)
-option(OPUS_FIXED_POINT "Compile as fixed-point (for machines without a fast enough FPU)" OFF)
-option(OPUS_ENABLE_FLOAT_API "Compile with the floating point API (for machines with float library" ON)
-
-include(opus/opus_functions.cmake)
-
-if(OPUS_STACK_PROTECTOR)
-    if(NOT MSVC) # GC on by default on MSVC
-        check_and_set_flag(STACK_PROTECTION_STRONG -fstack-protector-strong)
-    endif()
-else()
-    if(MSVC)
-        check_and_set_flag(BUFFER_SECURITY_CHECK /GS-)
-    endif()
-endif()
-
-add_library(opus
-    # CELT sources
-    opus/celt/bands.c
-    opus/celt/celt.c
-    opus/celt/celt_decoder.c
-    opus/celt/celt_encoder.c
-    opus/celt/celt_lpc.c
-    opus/celt/cwrs.c
-    opus/celt/entcode.c
-    opus/celt/entdec.c
-    opus/celt/entenc.c
-    opus/celt/kiss_fft.c
-    opus/celt/laplace.c
-    opus/celt/mathops.c
-    opus/celt/mdct.c
-    opus/celt/modes.c
-    opus/celt/pitch.c
-    opus/celt/quant_bands.c
-    opus/celt/rate.c
-    opus/celt/vq.c
-
-    # SILK sources
-    opus/silk/A2NLSF.c
-    opus/silk/CNG.c
-    opus/silk/HP_variable_cutoff.c
-    opus/silk/LPC_analysis_filter.c
-    opus/silk/LPC_fit.c
-    opus/silk/LPC_inv_pred_gain.c
-    opus/silk/LP_variable_cutoff.c
-    opus/silk/NLSF2A.c
-    opus/silk/NLSF_VQ.c
-    opus/silk/NLSF_VQ_weights_laroia.c
-    opus/silk/NLSF_decode.c
-    opus/silk/NLSF_del_dec_quant.c
-    opus/silk/NLSF_encode.c
-    opus/silk/NLSF_stabilize.c
-    opus/silk/NLSF_unpack.c
-    opus/silk/NSQ.c
-    opus/silk/NSQ_del_dec.c
-    opus/silk/PLC.c
-    opus/silk/VAD.c
-    opus/silk/VQ_WMat_EC.c
-    opus/silk/ana_filt_bank_1.c
-    opus/silk/biquad_alt.c
-    opus/silk/bwexpander.c
-    opus/silk/bwexpander_32.c
-    opus/silk/check_control_input.c
-    opus/silk/code_signs.c
-    opus/silk/control_SNR.c
-    opus/silk/control_audio_bandwidth.c
-    opus/silk/control_codec.c
-    opus/silk/dec_API.c
-    opus/silk/decode_core.c
-    opus/silk/decode_frame.c
-    opus/silk/decode_indices.c
-    opus/silk/decode_parameters.c
-    opus/silk/decode_pitch.c
-    opus/silk/decode_pulses.c
-    opus/silk/decoder_set_fs.c
-    opus/silk/enc_API.c
-    opus/silk/encode_indices.c
-    opus/silk/encode_pulses.c
-    opus/silk/gain_quant.c
-    opus/silk/init_decoder.c
-    opus/silk/init_encoder.c
-    opus/silk/inner_prod_aligned.c
-    opus/silk/interpolate.c
-    opus/silk/lin2log.c
-    opus/silk/log2lin.c
-    opus/silk/pitch_est_tables.c
-    opus/silk/process_NLSFs.c
-    opus/silk/quant_LTP_gains.c
-    opus/silk/resampler.c
-    opus/silk/resampler_down2.c
-    opus/silk/resampler_down2_3.c
-    opus/silk/resampler_private_AR2.c
-    opus/silk/resampler_private_IIR_FIR.c
-    opus/silk/resampler_private_down_FIR.c
-    opus/silk/resampler_private_up2_HQ.c
-    opus/silk/resampler_rom.c
-    opus/silk/shell_coder.c
-    opus/silk/sigm_Q15.c
-    opus/silk/sort.c
-    opus/silk/stereo_LR_to_MS.c
-    opus/silk/stereo_MS_to_LR.c
-    opus/silk/stereo_decode_pred.c
-    opus/silk/stereo_encode_pred.c
-    opus/silk/stereo_find_predictor.c
-    opus/silk/stereo_quant_pred.c
-    opus/silk/sum_sqr_shift.c
-    opus/silk/table_LSF_cos.c
-    opus/silk/tables_LTP.c
-    opus/silk/tables_NLSF_CB_NB_MB.c
-    opus/silk/tables_NLSF_CB_WB.c
-    opus/silk/tables_gain.c
-    opus/silk/tables_other.c
-    opus/silk/tables_pitch_lag.c
-    opus/silk/tables_pulses_per_block.c
-
-    # Opus sources
-    opus/src/analysis.c
-    opus/src/mapping_matrix.c
-    opus/src/mlp.c
-    opus/src/mlp_data.c
-    opus/src/opus.c
-    opus/src/opus_decoder.c
-    opus/src/opus_encoder.c
-    opus/src/opus_multistream.c
-    opus/src/opus_multistream_decoder.c
-    opus/src/opus_multistream_encoder.c
-    opus/src/opus_projection_decoder.c
-    opus/src/opus_projection_encoder.c
-    opus/src/repacketizer.c
-)
-
-if (DEBUG)
-    target_sources(opus PRIVATE opus/silk/debug.c)
-endif()
-
-if (OPUS_FIXED_POINT)
-    target_sources(opus PRIVATE
-        opus/silk/fixed/LTP_analysis_filter_FIX.c
-        opus/silk/fixed/LTP_scale_ctrl_FIX.c
-        opus/silk/fixed/apply_sine_window_FIX.c
-        opus/silk/fixed/autocorr_FIX.c
-        opus/silk/fixed/burg_modified_FIX.c
-        opus/silk/fixed/corrMatrix_FIX.c
-        opus/silk/fixed/encode_frame_FIX.c
-        opus/silk/fixed/find_LPC_FIX.c
-        opus/silk/fixed/find_LTP_FIX.c
-        opus/silk/fixed/find_pitch_lags_FIX.c
-        opus/silk/fixed/find_pred_coefs_FIX.c
-        opus/silk/fixed/k2a_FIX.c
-        opus/silk/fixed/k2a_Q16_FIX.c
-        opus/silk/fixed/noise_shape_analysis_FIX.c
-        opus/silk/fixed/pitch_analysis_core_FIX.c
-        opus/silk/fixed/prefilter_FIX.c
-        opus/silk/fixed/process_gains_FIX.c
-        opus/silk/fixed/regularize_correlations_FIX.c
-        opus/silk/fixed/residual_energy16_FIX.c
-        opus/silk/fixed/residual_energy_FIX.c
-        opus/silk/fixed/schur64_FIX.c
-        opus/silk/fixed/schur_FIX.c
-        opus/silk/fixed/solve_LS_FIX.c
-        opus/silk/fixed/vector_ops_FIX.c
-        opus/silk/fixed/warped_autocorrelation_FIX.c
-    )
-else()
-    target_sources(opus PRIVATE
-        opus/silk/float/LPC_analysis_filter_FLP.c
-        opus/silk/float/LPC_inv_pred_gain_FLP.c
-        opus/silk/float/LTP_analysis_filter_FLP.c
-        opus/silk/float/LTP_scale_ctrl_FLP.c
-        opus/silk/float/apply_sine_window_FLP.c
-        opus/silk/float/autocorrelation_FLP.c
-        opus/silk/float/burg_modified_FLP.c
-        opus/silk/float/bwexpander_FLP.c
-        opus/silk/float/corrMatrix_FLP.c
-        opus/silk/float/encode_frame_FLP.c
-        opus/silk/float/energy_FLP.c
-        opus/silk/float/find_LPC_FLP.c
-        opus/silk/float/find_LTP_FLP.c
-        opus/silk/float/find_pitch_lags_FLP.c
-        opus/silk/float/find_pred_coefs_FLP.c
-        opus/silk/float/inner_product_FLP.c
-        opus/silk/float/k2a_FLP.c
-        opus/silk/float/noise_shape_analysis_FLP.c
-        opus/silk/float/pitch_analysis_core_FLP.c
-        opus/silk/float/process_gains_FLP.c
-        opus/silk/float/regularize_correlations_FLP.c
-        opus/silk/float/residual_energy_FLP.c
-        opus/silk/float/scale_copy_vector_FLP.c
-        opus/silk/float/scale_vector_FLP.c
-        opus/silk/float/schur_FLP.c
-        opus/silk/float/sort_FLP.c
-        opus/silk/float/warped_autocorrelation_FLP.c
-        opus/silk/float/wrappers_FLP.c
-    )
-endif()
-
-target_compile_definitions(opus PRIVATE OPUS_BUILD ENABLE_HARDENING)
-
-if(NOT MSVC)
-    if(MINGW)
-        target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=0)
-    else()
-        target_compile_definitions(opus PRIVATE _FORTIFY_SOURCE=2)
-    endif()
-endif()
-
-# It is strongly recommended to uncomment one of these VAR_ARRAYS: Use C99
-# variable-length arrays for stack allocation USE_ALLOCA: Use alloca() for stack
-# allocation If none is defined, then the fallback is a non-threadsafe global
-# array
-if(OPUS_USE_ALLOCA OR MSVC)
-    target_compile_definitions(opus PRIVATE USE_ALLOCA)
-else()
-    target_compile_definitions(opus PRIVATE VAR_ARRAYS)
-endif()
-
-if(OPUS_CUSTOM_MODES)
-    target_compile_definitions(opus PRIVATE CUSTOM_MODES)
-endif()
-
-if(NOT OPUS_ENABLE_FLOAT_API)
-    target_compile_definitions(opus PRIVATE DISABLE_FLOAT_API)
-endif()
-
-target_compile_definitions(opus
-PUBLIC
-    -DOPUS_VERSION="\\"1.3.1\\""
-
-PRIVATE
-    # Use C99 intrinsics to speed up float-to-int conversion
-    HAVE_LRINTF
-)
-
-if (FIXED_POINT)
-    target_compile_definitions(opus PRIVATE -DFIXED_POINT=1 -DDISABLE_FLOAT_API)
-endif()
-
-target_include_directories(opus
-PUBLIC
-    opus/include
-
-PRIVATE
-    opus/celt
-    opus/silk
-    opus/silk/fixed
-    opus/silk/float
-    opus/src
-)
-
-add_library(Opus::opus ALIAS opus)
--- a/externals/opus/opus
+++ b/externals/opus/opus
--- a/externals/vcpkg
+++ b/externals/vcpkg
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt
@ -5,6 +5,7 @@ package org.yuzu.yuzu_emu

 import android.app.Dialog
 import android.content.DialogInterface
+import android.net.Uri
 import android.os.Bundle
 import android.text.Html
 import android.text.method.LinkMovementMethod
@ -16,7 +17,7 @@ import androidx.fragment.app.DialogFragment
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import java.lang.ref.WeakReference
 import org.yuzu.yuzu_emu.activities.EmulationActivity
-import org.yuzu.yuzu_emu.utils.DocumentsTree.Companion.isNativePath
+import org.yuzu.yuzu_emu.utils.DocumentsTree
 import org.yuzu.yuzu_emu.utils.FileUtil
 import org.yuzu.yuzu_emu.utils.Log
 import org.yuzu.yuzu_emu.utils.SerializableHelper.serializable
@ -68,7 +69,7 @@ object NativeLibrary {
    @Keep
    @JvmStatic
    fun openContentUri(path: String?, openmode: String?): Int {
-        return if (isNativePath(path!!)) {
+        return if (DocumentsTree.isNativePath(path!!)) {
            YuzuApplication.documentsTree!!.openContentUri(path, openmode)
        } else {
            FileUtil.openContentUri(path, openmode)
@ -78,7 +79,7 @@ object NativeLibrary {
    @Keep
    @JvmStatic
    fun getSize(path: String?): Long {
-        return if (isNativePath(path!!)) {
+        return if (DocumentsTree.isNativePath(path!!)) {
            YuzuApplication.documentsTree!!.getFileSize(path)
        } else {
            FileUtil.getFileSize(path)
@ -88,23 +89,41 @@ object NativeLibrary {
    @Keep
    @JvmStatic
    fun exists(path: String?): Boolean {
-        return if (isNativePath(path!!)) {
+        return if (DocumentsTree.isNativePath(path!!)) {
            YuzuApplication.documentsTree!!.exists(path)
        } else {
-            FileUtil.exists(path)
+            FileUtil.exists(path, suppressLog = true)
        }
    }

    @Keep
    @JvmStatic
    fun isDirectory(path: String?): Boolean {
-        return if (isNativePath(path!!)) {
+        return if (DocumentsTree.isNativePath(path!!)) {
            YuzuApplication.documentsTree!!.isDirectory(path)
        } else {
            FileUtil.isDirectory(path)
        }
    }

+    @Keep
+    @JvmStatic
+    fun getParentDirectory(path: String): String =
+        if (DocumentsTree.isNativePath(path)) {
+            YuzuApplication.documentsTree!!.getParentDirectory(path)
+        } else {
+            path
+        }
+
+    @Keep
+    @JvmStatic
+    fun getFilename(path: String): String =
+        if (DocumentsTree.isNativePath(path)) {
+            YuzuApplication.documentsTree!!.getFilename(path)
+        } else {
+            FileUtil.getFilename(Uri.parse(path))
+        }
+
    /**
     * Returns true if pro controller isn't available and handheld is
     */
@ -215,32 +234,6 @@ object NativeLibrary {

    external fun initGameIni(gameID: String?)

-    /**
-     * Gets the embedded icon within the given ROM.
-     *
-     * @param filename the file path to the ROM.
-     * @return a byte array containing the JPEG data for the icon.
-     */
-    external fun getIcon(filename: String): ByteArray
-
-    /**
-     * Gets the embedded title of the given ISO/ROM.
-     *
-     * @param filename The file path to the ISO/ROM.
-     * @return the embedded title of the ISO/ROM.
-     */
-    external fun getTitle(filename: String): String
-
-    external fun getDescription(filename: String): String
-
-    external fun getGameId(filename: String): String
-
-    external fun getRegions(filename: String): String
-
-    external fun getCompany(filename: String): String
-
-    external fun isHomebrew(filename: String): Boolean
-
    external fun setAppDirectory(directory: String)

    /**
@ -293,11 +286,6 @@ object NativeLibrary {
     */
    external fun stopEmulation()

-    /**
-     * Resets the in-memory ROM metadata cache.
-     */
-    external fun resetRomMetadata()
-
    /**
     * Returns true if emulation is running (or is paused).
     */
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/GameAdapter.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/GameAdapter.kt
@ -147,7 +147,7 @@ class GameAdapter(private val activity: AppCompatActivity) :

    private class DiffCallback : DiffUtil.ItemCallback<Game>() {
        override fun areItemsTheSame(oldItem: Game, newItem: Game): Boolean {
-            return oldItem.gameId == newItem.gameId
+            return oldItem.programId == newItem.programId
        }

        override fun areContentsTheSame(oldItem: Game, newItem: Game): Boolean {
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt
@ -15,6 +15,7 @@ import android.net.Uri
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
+import android.os.SystemClock
 import android.view.*
 import android.widget.TextView
 import android.widget.Toast
@ -25,6 +26,7 @@ import androidx.core.graphics.Insets
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.drawerlayout.widget.DrawerLayout
+import androidx.drawerlayout.widget.DrawerLayout.DrawerListener
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
 import androidx.lifecycle.Lifecycle
@ -156,6 +158,32 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
        binding.showFpsText.setTextColor(Color.YELLOW)
        binding.doneControlConfig.setOnClickListener { stopConfiguringControls() }

+        binding.drawerLayout.addDrawerListener(object : DrawerListener {
+            override fun onDrawerSlide(drawerView: View, slideOffset: Float) {
+                binding.surfaceInputOverlay.dispatchTouchEvent(
+                    MotionEvent.obtain(
+                        SystemClock.uptimeMillis(),
+                        SystemClock.uptimeMillis() + 100,
+                        MotionEvent.ACTION_UP,
+                        0f,
+                        0f,
+                        0
+                    )
+                )
+            }
+
+            override fun onDrawerOpened(drawerView: View) {
+                // No op
+            }
+
+            override fun onDrawerClosed(drawerView: View) {
+                // No op
+            }
+
+            override fun onDrawerStateChanged(newState: Int) {
+                // No op
+            }
+        })
        binding.drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_LOCKED_CLOSED)
        binding.inGameMenu.getHeaderView(0).findViewById<TextView>(R.id.text_game_title).text =
            game.title
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/Game.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/Game.kt
@ -12,15 +12,14 @@ import kotlinx.serialization.Serializable
@Serializable
 class Game(
    val title: String,
-    val description: String,
-    val regions: String,
    val path: String,
-    val gameId: String,
-    val company: String,
+    val programId: String,
+    val developer: String,
+    val version: String,
    val isHomebrew: Boolean
 ) : Parcelable {
-    val keyAddedToLibraryTime get() = "${gameId}_AddedToLibraryTime"
-    val keyLastPlayedTime get() = "${gameId}_LastPlayed"
+    val keyAddedToLibraryTime get() = "${programId}_AddedToLibraryTime"
+    val keyLastPlayedTime get() = "${programId}_LastPlayed"

    override fun equals(other: Any?): Boolean {
        if (other !is Game) {
@ -32,11 +31,9 @@ class Game(

    override fun hashCode(): Int {
        var result = title.hashCode()
-        result = 31 * result + description.hashCode()
-        result = 31 * result + regions.hashCode()
        result = 31 * result + path.hashCode()
-        result = 31 * result + gameId.hashCode()
-        result = 31 * result + company.hashCode()
+        result = 31 * result + programId.hashCode()
+        result = 31 * result + developer.hashCode()
        result = 31 * result + isHomebrew.hashCode()
        return result
    }
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/model/GamesViewModel.kt
@ -14,15 +14,13 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
-import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.MissingFieldException
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.json.Json
 import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.YuzuApplication
 import org.yuzu.yuzu_emu.utils.GameHelper
+import org.yuzu.yuzu_emu.utils.GameMetadata

-@OptIn(ExperimentalSerializationApi::class)
 class GamesViewModel : ViewModel() {
    val games: StateFlow<List<Game>> get() = _games
    private val _games = MutableStateFlow(emptyList<Game>())
@ -49,26 +47,34 @@ class GamesViewModel : ViewModel() {
        // Retrieve list of cached games
        val storedGames = PreferenceManager.getDefaultSharedPreferences(YuzuApplication.appContext)
            .getStringSet(GameHelper.KEY_GAMES, emptySet())
-        if (storedGames!!.isNotEmpty()) {
-            val deserializedGames = mutableSetOf<Game>()
-            storedGames.forEach {
-                val game: Game
-                try {
-                    game = Json.decodeFromString(it)
-                } catch (e: MissingFieldException) {
-                    return@forEach
-                }

-                val gameExists =
-                    DocumentFile.fromSingleUri(YuzuApplication.appContext, Uri.parse(game.path))
-                        ?.exists()
-                if (gameExists == true) {
-                    deserializedGames.add(game)
+        viewModelScope.launch {
+            withContext(Dispatchers.IO) {
+                if (storedGames!!.isNotEmpty()) {
+                    val deserializedGames = mutableSetOf<Game>()
+                    storedGames.forEach {
+                        val game: Game
+                        try {
+                            game = Json.decodeFromString(it)
+                        } catch (e: Exception) {
+                            // We don't care about any errors related to parsing the game cache
+                            return@forEach
+                        }
+
+                        val gameExists =
+                            DocumentFile.fromSingleUri(
+                                YuzuApplication.appContext,
+                                Uri.parse(game.path)
+                            )?.exists()
+                        if (gameExists == true) {
+                            deserializedGames.add(game)
+                        }
+                    }
+                    setGames(deserializedGames.toList())
                }
+                reloadGames(false)
            }
-            setGames(deserializedGames.toList())
        }
-        reloadGames(false)
    }

    fun setGames(games: List<Game>) {
@ -106,7 +112,7 @@ class GamesViewModel : ViewModel() {

        viewModelScope.launch {
            withContext(Dispatchers.IO) {
-                NativeLibrary.resetRomMetadata()
+                GameMetadata.resetMetadata()
                setGames(GameHelper.getGames())
                _isReloading.value = false

--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/DocumentsTree.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/DocumentsTree.kt
@ -42,6 +42,23 @@ class DocumentsTree {
        return node != null && node.isDirectory
    }

+    fun getParentDirectory(filepath: String): String {
+        val node = resolvePath(filepath)!!
+        val parentNode = node.parent
+        if (parentNode != null && parentNode.isDirectory) {
+            return parentNode.uri!!.toString()
+        }
+        return node.uri!!.toString()
+    }
+
+    fun getFilename(filepath: String): String {
+        val node = resolvePath(filepath)
+        if (node != null) {
+            return node.name!!
+        }
+        return filepath
+    }
+
    private fun resolvePath(filepath: String): DocumentsNode? {
        val tokens = StringTokenizer(filepath, File.separator, false)
        var iterator = root
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/FileUtil.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/FileUtil.kt
@ -144,7 +144,7 @@ object FileUtil {
     * @param path Native content uri path
     * @return bool
     */
-    fun exists(path: String?): Boolean {
+    fun exists(path: String?, suppressLog: Boolean = false): Boolean {
        var c: Cursor? = null
        try {
            val mUri = Uri.parse(path)
@ -152,7 +152,9 @@ object FileUtil {
            c = context.contentResolver.query(mUri, columns, null, null, null)
            return c!!.count > 0
        } catch (e: Exception) {
-            Log.info("[FileUtil] Cannot find file from given path, error: " + e.message)
+            if (!suppressLog) {
+                Log.info("[FileUtil] Cannot find file from given path, error: " + e.message)
+            }
        } finally {
            closeQuietly(c)
        }
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameHelper.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameHelper.kt
@ -71,27 +71,26 @@ object GameHelper {

    fun getGame(uri: Uri, addedToLibrary: Boolean): Game {
        val filePath = uri.toString()
-        var name = NativeLibrary.getTitle(filePath)
+        var name = GameMetadata.getTitle(filePath)

        // If the game's title field is empty, use the filename.
        if (name.isEmpty()) {
            name = FileUtil.getFilename(uri)
        }
-        var gameId = NativeLibrary.getGameId(filePath)
+        var programId = GameMetadata.getProgramId(filePath)

        // If the game's ID field is empty, use the filename without extension.
-        if (gameId.isEmpty()) {
-            gameId = name.substring(0, name.lastIndexOf("."))
+        if (programId.isEmpty()) {
+            programId = name.substring(0, name.lastIndexOf("."))
        }

        val newGame = Game(
            name,
-            NativeLibrary.getDescription(filePath).replace("\n", " "),
-            NativeLibrary.getRegions(filePath),
            filePath,
-            gameId,
-            NativeLibrary.getCompany(filePath),
-            NativeLibrary.isHomebrew(filePath)
+            programId,
+            GameMetadata.getDeveloper(filePath),
+            GameMetadata.getVersion(filePath),
+            GameMetadata.getIsHomebrew(filePath)
        )

        if (addedToLibrary) {
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameIconUtils.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameIconUtils.kt
@ -18,7 +18,6 @@ import coil.key.Keyer
 import coil.memory.MemoryCache
 import coil.request.ImageRequest
 import coil.request.Options
-import org.yuzu.yuzu_emu.NativeLibrary
 import org.yuzu.yuzu_emu.R
 import org.yuzu.yuzu_emu.YuzuApplication
 import org.yuzu.yuzu_emu.model.Game
@ -36,7 +35,7 @@ class GameIconFetcher(
    }

    private fun decodeGameIcon(uri: String): Bitmap? {
-        val data = NativeLibrary.getIcon(uri)
+        val data = GameMetadata.getIcon(uri)
        return BitmapFactory.decodeByteArray(
            data,
            0,
--- a/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameMetadata.kt
+++ b/src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/GameMetadata.kt
@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package org.yuzu.yuzu_emu.utils
+
+object GameMetadata {
+    external fun getTitle(path: String): String
+
+    external fun getProgramId(path: String): String
+
+    external fun getDeveloper(path: String): String
+
+    external fun getVersion(path: String): String
+
+    external fun getIcon(path: String): ByteArray
+
+    external fun getIsHomebrew(path: String): Boolean
+
+    external fun resetMetadata()
+}
--- a/src/android/app/src/main/jni/CMakeLists.txt
+++ b/src/android/app/src/main/jni/CMakeLists.txt
@ -14,8 +14,10 @@ add_library(yuzu-android SHARED
    id_cache.cpp
    id_cache.h
    native.cpp
+    native.h
    native_config.cpp
    uisettings.cpp
+    game_metadata.cpp
 )

 set_property(TARGET yuzu-android PROPERTY IMPORTED_LOCATION ${FFmpeg_LIBRARY_DIR})
--- a/src/android/app/src/main/jni/game_metadata.cpp
+++ b/src/android/app/src/main/jni/game_metadata.cpp
@ -0,0 +1,112 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <core/core.h>
+#include <core/file_sys/patch_manager.h>
+#include <core/loader/nro.h>
+#include <jni.h>
+#include "core/loader/loader.h"
+#include "jni/android_common/android_common.h"
+#include "native.h"
+
+struct RomMetadata {
+    std::string title;
+    u64 programId;
+    std::string developer;
+    std::string version;
+    std::vector<u8> icon;
+    bool isHomebrew;
+};
+
+std::unordered_map<std::string, RomMetadata> m_rom_metadata_cache;
+
+RomMetadata CacheRomMetadata(const std::string& path) {
+    const auto file =
+        Core::GetGameFileFromPath(EmulationSession::GetInstance().System().GetFilesystem(), path);
+    auto loader = Loader::GetLoader(EmulationSession::GetInstance().System(), file, 0, 0);
+
+    RomMetadata entry;
+    loader->ReadTitle(entry.title);
+    loader->ReadProgramId(entry.programId);
+    loader->ReadIcon(entry.icon);
+
+    const FileSys::PatchManager pm{
+        entry.programId, EmulationSession::GetInstance().System().GetFileSystemController(),
+        EmulationSession::GetInstance().System().GetContentProvider()};
+    const auto control = pm.GetControlMetadata();
+
+    if (control.first != nullptr) {
+        entry.developer = control.first->GetDeveloperName();
+        entry.version = control.first->GetVersionString();
+    } else {
+        FileSys::NACP nacp;
+        if (loader->ReadControlData(nacp) == Loader::ResultStatus::Success) {
+            entry.developer = nacp.GetDeveloperName();
+        } else {
+            entry.developer = "";
+        }
+
+        entry.version = "1.0.0";
+    }
+
+    if (loader->GetFileType() == Loader::FileType::NRO) {
+        auto loader_nro = reinterpret_cast<Loader::AppLoader_NRO*>(loader.get());
+        entry.isHomebrew = loader_nro->IsHomebrew();
+    } else {
+        entry.isHomebrew = false;
+    }
+
+    m_rom_metadata_cache[path] = entry;
+
+    return entry;
+}
+
+RomMetadata GetRomMetadata(const std::string& path) {
+    if (auto search = m_rom_metadata_cache.find(path); search != m_rom_metadata_cache.end()) {
+        return search->second;
+    }
+
+    return CacheRomMetadata(path);
+}
+
+extern "C" {
+
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getTitle(JNIEnv* env, jobject obj,
+                                                            jstring jpath) {
+    return ToJString(env, GetRomMetadata(GetJString(env, jpath)).title);
+}
+
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getProgramId(JNIEnv* env, jobject obj,
+                                                                jstring jpath) {
+    return ToJString(env, std::to_string(GetRomMetadata(GetJString(env, jpath)).programId));
+}
+
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getDeveloper(JNIEnv* env, jobject obj,
+                                                                jstring jpath) {
+    return ToJString(env, GetRomMetadata(GetJString(env, jpath)).developer);
+}
+
+jstring Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getVersion(JNIEnv* env, jobject obj,
+                                                              jstring jpath) {
+    return ToJString(env, GetRomMetadata(GetJString(env, jpath)).version);
+}
+
+jbyteArray Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIcon(JNIEnv* env, jobject obj,
+                                                              jstring jpath) {
+    auto icon_data = GetRomMetadata(GetJString(env, jpath)).icon;
+    jbyteArray icon = env->NewByteArray(static_cast<jsize>(icon_data.size()));
+    env->SetByteArrayRegion(icon, 0, env->GetArrayLength(icon),
+                            reinterpret_cast<jbyte*>(icon_data.data()));
+    return icon;
+}
+
+jboolean Java_org_yuzu_yuzu_1emu_utils_GameMetadata_getIsHomebrew(JNIEnv* env, jobject obj,
+                                                                  jstring jpath) {
+    return static_cast<jboolean>(GetRomMetadata(GetJString(env, jpath)).isHomebrew);
+}
+
+void Java_org_yuzu_yuzu_1emu_utils_GameMetadata_resetMetadata(JNIEnv* env, jobject obj) {
+    return m_rom_metadata_cache.clear();
+}
+
+} // extern "C"
--- a/src/android/app/src/main/jni/native.cpp
+++ b/src/android/app/src/main/jni/native.cpp
@ -33,7 +33,6 @@
 #include "core/crypto/key_manager.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/content_archive.h"
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/submission_package.h"
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_real.h"
@ -48,514 +47,416 @@
 #include "core/hid/emulated_controller.h"
 #include "core/hid/hid_core.h"
 #include "core/hid/hid_types.h"
-#include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
 #include "core/hle/service/am/applets/applets.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
-#include "core/perf_stats.h"
 #include "jni/android_common/android_common.h"
-#include "jni/applets/software_keyboard.h"
 #include "jni/config.h"
-#include "jni/emu_window/emu_window.h"
 #include "jni/id_cache.h"
-#include "video_core/rasterizer_interface.h"
+#include "jni/native.h"
 #include "video_core/renderer_base.h"

 #define jconst [[maybe_unused]] const auto
 #define jauto [[maybe_unused]] auto

-namespace {
+static EmulationSession s_instance;

-class EmulationSession final {
-public:
-    EmulationSession() {
-        m_vfs = std::make_shared<FileSys::RealVfsFilesystem>();
-    }
+EmulationSession::EmulationSession() {
+    m_vfs = std::make_shared<FileSys::RealVfsFilesystem>();
+}

-    ~EmulationSession() = default;
+EmulationSession& EmulationSession::GetInstance() {
+    return s_instance;
+}

-    static EmulationSession& GetInstance() {
-        return s_instance;
-    }
+const Core::System& EmulationSession::System() const {
+    return m_system;
+}

-    const Core::System& System() const {
-        return m_system;
-    }
+Core::System& EmulationSession::System() {
+    return m_system;
+}

-    Core::System& System() {
-        return m_system;
-    }
+const EmuWindow_Android& EmulationSession::Window() const {
+    return *m_window;
+}

-    const EmuWindow_Android& Window() const {
-        return *m_window;
-    }
+EmuWindow_Android& EmulationSession::Window() {
+    return *m_window;
+}

-    EmuWindow_Android& Window() {
-        return *m_window;
-    }
+ANativeWindow* EmulationSession::NativeWindow() const {
+    return m_native_window;
+}

-    ANativeWindow* NativeWindow() const {
-        return m_native_window;
-    }
+void EmulationSession::SetNativeWindow(ANativeWindow* native_window) {
+    m_native_window = native_window;
+}

-    void SetNativeWindow(ANativeWindow* native_window) {
-        m_native_window = native_window;
-    }
-
-    int InstallFileToNand(std::string filename, std::string file_extension) {
-        jconst copy_func = [](const FileSys::VirtualFile& src, const FileSys::VirtualFile& dest,
-                              std::size_t block_size) {
-            if (src == nullptr || dest == nullptr) {
-                return false;
-            }
-            if (!dest->Resize(src->GetSize())) {
-                return false;
-            }
-
-            using namespace Common::Literals;
-            [[maybe_unused]] std::vector<u8> buffer(1_MiB);
-
-            for (std::size_t i = 0; i < src->GetSize(); i += buffer.size()) {
-                jconst read = src->Read(buffer.data(), buffer.size(), i);
-                dest->Write(buffer.data(), read, i);
-            }
-            return true;
-        };
-
-        enum InstallResult {
-            Success = 0,
-            SuccessFileOverwritten = 1,
-            InstallError = 2,
-            ErrorBaseGame = 3,
-            ErrorFilenameExtension = 4,
-        };
-
-        m_system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
-        m_system.GetFileSystemController().CreateFactories(*m_vfs);
-
-        [[maybe_unused]] std::shared_ptr<FileSys::NSP> nsp;
-        if (file_extension == "nsp") {
-            nsp = std::make_shared<FileSys::NSP>(m_vfs->OpenFile(filename, FileSys::Mode::Read));
-            if (nsp->IsExtractedType()) {
-                return InstallError;
-            }
-        } else {
-            return ErrorFilenameExtension;
+int EmulationSession::InstallFileToNand(std::string filename, std::string file_extension) {
+    jconst copy_func = [](const FileSys::VirtualFile& src, const FileSys::VirtualFile& dest,
+                          std::size_t block_size) {
+        if (src == nullptr || dest == nullptr) {
+            return false;
        }
-
-        if (!nsp) {
-            return InstallError;
-        }
-
-        if (nsp->GetStatus() != Loader::ResultStatus::Success) {
-            return InstallError;
-        }
-
-        jconst res = m_system.GetFileSystemController().GetUserNANDContents()->InstallEntry(
-            *nsp, true, copy_func);
-
-        switch (res) {
-        case FileSys::InstallResult::Success:
-            return Success;
-        case FileSys::InstallResult::OverwriteExisting:
-            return SuccessFileOverwritten;
-        case FileSys::InstallResult::ErrorBaseInstall:
-            return ErrorBaseGame;
-        default:
-            return InstallError;
-        }
-    }
-
-    void InitializeGpuDriver(const std::string& hook_lib_dir, const std::string& custom_driver_dir,
-                             const std::string& custom_driver_name,
-                             const std::string& file_redirect_dir) {
-#ifdef ARCHITECTURE_arm64
-        void* handle{};
-        const char* file_redirect_dir_{};
-        int featureFlags{};
-
-        // Enable driver file redirection when renderer debugging is enabled.
-        if (Settings::values.renderer_debug && file_redirect_dir.size()) {
-            featureFlags |= ADRENOTOOLS_DRIVER_FILE_REDIRECT;
-            file_redirect_dir_ = file_redirect_dir.c_str();
-        }
-
-        // Try to load a custom driver.
-        if (custom_driver_name.size()) {
-            handle = adrenotools_open_libvulkan(
-                RTLD_NOW, featureFlags | ADRENOTOOLS_DRIVER_CUSTOM, nullptr, hook_lib_dir.c_str(),
-                custom_driver_dir.c_str(), custom_driver_name.c_str(), file_redirect_dir_, nullptr);
-        }
-
-        // Try to load the system driver.
-        if (!handle) {
-            handle =
-                adrenotools_open_libvulkan(RTLD_NOW, featureFlags, nullptr, hook_lib_dir.c_str(),
-                                           nullptr, nullptr, file_redirect_dir_, nullptr);
-        }
-
-        m_vulkan_library = std::make_shared<Common::DynamicLibrary>(handle);
-#endif
-    }
-
-    bool IsRunning() const {
-        return m_is_running;
-    }
-
-    bool IsPaused() const {
-        return m_is_running && m_is_paused;
-    }
-
-    const Core::PerfStatsResults& PerfStats() const {
-        std::scoped_lock m_perf_stats_lock(m_perf_stats_mutex);
-        return m_perf_stats;
-    }
-
-    void SurfaceChanged() {
-        if (!IsRunning()) {
-            return;
-        }
-        m_window->OnSurfaceChanged(m_native_window);
-    }
-
-    void ConfigureFilesystemProvider(const std::string& filepath) {
-        const auto file = m_system.GetFilesystem()->OpenFile(filepath, FileSys::Mode::Read);
-        if (!file) {
-            return;
-        }
-
-        auto loader = Loader::GetLoader(m_system, file);
-        if (!loader) {
-            return;
-        }
-
-        const auto file_type = loader->GetFileType();
-        if (file_type == Loader::FileType::Unknown || file_type == Loader::FileType::Error) {
-            return;
-        }
-
-        u64 program_id = 0;
-        const auto res2 = loader->ReadProgramId(program_id);
-        if (res2 == Loader::ResultStatus::Success && file_type == Loader::FileType::NCA) {
-            m_manual_provider->AddEntry(FileSys::TitleType::Application,
-                                        FileSys::GetCRTypeFromNCAType(FileSys::NCA{file}.GetType()),
-                                        program_id, file);
-        } else if (res2 == Loader::ResultStatus::Success &&
-                   (file_type == Loader::FileType::XCI || file_type == Loader::FileType::NSP)) {
-            const auto nsp = file_type == Loader::FileType::NSP
-                                 ? std::make_shared<FileSys::NSP>(file)
-                                 : FileSys::XCI{file}.GetSecurePartitionNSP();
-            for (const auto& title : nsp->GetNCAs()) {
-                for (const auto& entry : title.second) {
-                    m_manual_provider->AddEntry(entry.first.first, entry.first.second, title.first,
-                                                entry.second->GetBaseFile());
-                }
-            }
-        }
-    }
-
-    Core::SystemResultStatus InitializeEmulation(const std::string& filepath) {
-        std::scoped_lock lock(m_mutex);
-
-        // Create the render window.
-        m_window = std::make_unique<EmuWindow_Android>(&m_input_subsystem, m_native_window,
-                                                       m_vulkan_library);
-
-        m_system.SetFilesystem(m_vfs);
-        m_system.GetUserChannel().clear();
-
-        // Initialize system.
-        jauto android_keyboard = std::make_unique<SoftwareKeyboard::AndroidKeyboard>();
-        m_software_keyboard = android_keyboard.get();
-        m_system.SetShuttingDown(false);
-        m_system.ApplySettings();
-        Settings::LogSettings();
-        m_system.HIDCore().ReloadInputDevices();
-        m_system.SetAppletFrontendSet({
-            nullptr,                     // Amiibo Settings
-            nullptr,                     // Controller Selector
-            nullptr,                     // Error Display
-            nullptr,                     // Mii Editor
-            nullptr,                     // Parental Controls
-            nullptr,                     // Photo Viewer
-            nullptr,                     // Profile Selector
-            std::move(android_keyboard), // Software Keyboard
-            nullptr,                     // Web Browser
-        });
-
-        // Initialize filesystem.
-        m_manual_provider = std::make_unique<FileSys::ManualContentProvider>();
-        m_system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
-        m_system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::FrontendManual,
-                                         m_manual_provider.get());
-        m_system.GetFileSystemController().CreateFactories(*m_vfs);
-        ConfigureFilesystemProvider(filepath);
-
-        // Initialize account manager
-        m_profile_manager = std::make_unique<Service::Account::ProfileManager>();
-
-        // Load the ROM.
-        m_load_result = m_system.Load(EmulationSession::GetInstance().Window(), filepath);
-        if (m_load_result != Core::SystemResultStatus::Success) {
-            return m_load_result;
-        }
-
-        // Complete initialization.
-        m_system.GPU().Start();
-        m_system.GetCpuManager().OnGpuReady();
-        m_system.RegisterExitCallback([&] { HaltEmulation(); });
-
-        return Core::SystemResultStatus::Success;
-    }
-
-    void ShutdownEmulation() {
-        std::scoped_lock lock(m_mutex);
-
-        m_is_running = false;
-
-        // Unload user input.
-        m_system.HIDCore().UnloadInputDevices();
-
-        // Shutdown the main emulated process
-        if (m_load_result == Core::SystemResultStatus::Success) {
-            m_system.DetachDebugger();
-            m_system.ShutdownMainProcess();
-            m_detached_tasks.WaitForAllTasks();
-            m_load_result = Core::SystemResultStatus::ErrorNotInitialized;
-            m_window.reset();
-            OnEmulationStopped(Core::SystemResultStatus::Success);
-            return;
-        }
-
-        // Tear down the render window.
-        m_window.reset();
-    }
-
-    void PauseEmulation() {
-        std::scoped_lock lock(m_mutex);
-        m_system.Pause();
-        m_is_paused = true;
-    }
-
-    void UnPauseEmulation() {
-        std::scoped_lock lock(m_mutex);
-        m_system.Run();
-        m_is_paused = false;
-    }
-
-    void HaltEmulation() {
-        std::scoped_lock lock(m_mutex);
-        m_is_running = false;
-        m_cv.notify_one();
-    }
-
-    void RunEmulation() {
-        {
-            std::scoped_lock lock(m_mutex);
-            m_is_running = true;
-        }
-
-        // Load the disk shader cache.
-        if (Settings::values.use_disk_shader_cache.GetValue()) {
-            LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
-            m_system.Renderer().ReadRasterizer()->LoadDiskResources(
-                m_system.GetApplicationProcessProgramID(), std::stop_token{},
-                LoadDiskCacheProgress);
-            LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Complete, 0, 0);
-        }
-
-        void(m_system.Run());
-
-        if (m_system.DebuggerEnabled()) {
-            m_system.InitializeDebugger();
-        }
-
-        OnEmulationStarted();
-
-        while (true) {
-            {
-                [[maybe_unused]] std::unique_lock lock(m_mutex);
-                if (m_cv.wait_for(lock, std::chrono::milliseconds(800),
-                                  [&]() { return !m_is_running; })) {
-                    // Emulation halted.
-                    break;
-                }
-            }
-            {
-                // Refresh performance stats.
-                std::scoped_lock m_perf_stats_lock(m_perf_stats_mutex);
-                m_perf_stats = m_system.GetAndResetPerfStats();
-            }
-        }
-    }
-
-    std::string GetRomTitle(const std::string& path) {
-        return GetRomMetadata(path).title;
-    }
-
-    std::vector<u8> GetRomIcon(const std::string& path) {
-        return GetRomMetadata(path).icon;
-    }
-
-    bool GetIsHomebrew(const std::string& path) {
-        return GetRomMetadata(path).isHomebrew;
-    }
-
-    void ResetRomMetadata() {
-        m_rom_metadata_cache.clear();
-    }
-
-    bool IsHandheldOnly() {
-        jconst npad_style_set = m_system.HIDCore().GetSupportedStyleTag();
-
-        if (npad_style_set.fullkey == 1) {
+        if (!dest->Resize(src->GetSize())) {
            return false;
        }

-        if (npad_style_set.handheld == 0) {
-            return false;
+        using namespace Common::Literals;
+        [[maybe_unused]] std::vector<u8> buffer(1_MiB);
+
+        for (std::size_t i = 0; i < src->GetSize(); i += buffer.size()) {
+            jconst read = src->Read(buffer.data(), buffer.size(), i);
+            dest->Write(buffer.data(), read, i);
        }
-
-        return !Settings::IsDockedMode();
-    }
-
-    void SetDeviceType([[maybe_unused]] int index, int type) {
-        jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
-        controller->SetNpadStyleIndex(static_cast<Core::HID::NpadStyleIndex>(type));
-    }
-
-    void OnGamepadConnectEvent([[maybe_unused]] int index) {
-        jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
-
-        // Ensure that player1 is configured correctly and handheld disconnected
-        if (controller->GetNpadIdType() == Core::HID::NpadIdType::Player1) {
-            jauto handheld =
-                m_system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
-
-            if (controller->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::Handheld) {
-                handheld->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
-                controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
-                handheld->Disconnect();
-            }
-        }
-
-        // Ensure that handheld is configured correctly and player 1 disconnected
-        if (controller->GetNpadIdType() == Core::HID::NpadIdType::Handheld) {
-            jauto player1 =
-                m_system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
-
-            if (controller->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::Handheld) {
-                player1->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
-                controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
-                player1->Disconnect();
-            }
-        }
-
-        if (!controller->IsConnected()) {
-            controller->Connect();
-        }
-    }
-
-    void OnGamepadDisconnectEvent([[maybe_unused]] int index) {
-        jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
-        controller->Disconnect();
-    }
-
-    SoftwareKeyboard::AndroidKeyboard* SoftwareKeyboard() {
-        return m_software_keyboard;
-    }
-
-private:
-    struct RomMetadata {
-        std::string title;
-        std::vector<u8> icon;
-        bool isHomebrew;
+        return true;
    };

-    RomMetadata GetRomMetadata(const std::string& path) {
-        if (jauto search = m_rom_metadata_cache.find(path); search != m_rom_metadata_cache.end()) {
-            return search->second;
+    enum InstallResult {
+        Success = 0,
+        SuccessFileOverwritten = 1,
+        InstallError = 2,
+        ErrorBaseGame = 3,
+        ErrorFilenameExtension = 4,
+    };
+
+    m_system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
+    m_system.GetFileSystemController().CreateFactories(*m_vfs);
+
+    [[maybe_unused]] std::shared_ptr<FileSys::NSP> nsp;
+    if (file_extension == "nsp") {
+        nsp = std::make_shared<FileSys::NSP>(m_vfs->OpenFile(filename, FileSys::Mode::Read));
+        if (nsp->IsExtractedType()) {
+            return InstallError;
        }
-
-        return CacheRomMetadata(path);
+    } else {
+        return ErrorFilenameExtension;
    }

-    RomMetadata CacheRomMetadata(const std::string& path) {
-        jconst file = Core::GetGameFileFromPath(m_vfs, path);
-        jauto loader = Loader::GetLoader(EmulationSession::GetInstance().System(), file, 0, 0);
+    if (!nsp) {
+        return InstallError;
+    }

-        RomMetadata entry;
-        loader->ReadTitle(entry.title);
-        loader->ReadIcon(entry.icon);
-        if (loader->GetFileType() == Loader::FileType::NRO) {
-            jauto loader_nro = reinterpret_cast<Loader::AppLoader_NRO*>(loader.get());
-            entry.isHomebrew = loader_nro->IsHomebrew();
-        } else {
-            entry.isHomebrew = false;
+    if (nsp->GetStatus() != Loader::ResultStatus::Success) {
+        return InstallError;
+    }
+
+    jconst res = m_system.GetFileSystemController().GetUserNANDContents()->InstallEntry(*nsp, true,
+                                                                                        copy_func);
+
+    switch (res) {
+    case FileSys::InstallResult::Success:
+        return Success;
+    case FileSys::InstallResult::OverwriteExisting:
+        return SuccessFileOverwritten;
+    case FileSys::InstallResult::ErrorBaseInstall:
+        return ErrorBaseGame;
+    default:
+        return InstallError;
+    }
+}
+
+void EmulationSession::InitializeGpuDriver(const std::string& hook_lib_dir,
+                                           const std::string& custom_driver_dir,
+                                           const std::string& custom_driver_name,
+                                           const std::string& file_redirect_dir) {
+#ifdef ARCHITECTURE_arm64
+    void* handle{};
+    const char* file_redirect_dir_{};
+    int featureFlags{};
+
+    // Enable driver file redirection when renderer debugging is enabled.
+    if (Settings::values.renderer_debug && file_redirect_dir.size()) {
+        featureFlags |= ADRENOTOOLS_DRIVER_FILE_REDIRECT;
+        file_redirect_dir_ = file_redirect_dir.c_str();
+    }
+
+    // Try to load a custom driver.
+    if (custom_driver_name.size()) {
+        handle = adrenotools_open_libvulkan(
+            RTLD_NOW, featureFlags | ADRENOTOOLS_DRIVER_CUSTOM, nullptr, hook_lib_dir.c_str(),
+            custom_driver_dir.c_str(), custom_driver_name.c_str(), file_redirect_dir_, nullptr);
+    }
+
+    // Try to load the system driver.
+    if (!handle) {
+        handle = adrenotools_open_libvulkan(RTLD_NOW, featureFlags, nullptr, hook_lib_dir.c_str(),
+                                            nullptr, nullptr, file_redirect_dir_, nullptr);
+    }
+
+    m_vulkan_library = std::make_shared<Common::DynamicLibrary>(handle);
+#endif
+}
+
+bool EmulationSession::IsRunning() const {
+    return m_is_running;
+}
+
+bool EmulationSession::IsPaused() const {
+    return m_is_running && m_is_paused;
+}
+
+const Core::PerfStatsResults& EmulationSession::PerfStats() const {
+    std::scoped_lock m_perf_stats_lock(m_perf_stats_mutex);
+    return m_perf_stats;
+}
+
+void EmulationSession::SurfaceChanged() {
+    if (!IsRunning()) {
+        return;
+    }
+    m_window->OnSurfaceChanged(m_native_window);
+}
+
+void EmulationSession::ConfigureFilesystemProvider(const std::string& filepath) {
+    const auto file = m_system.GetFilesystem()->OpenFile(filepath, FileSys::Mode::Read);
+    if (!file) {
+        return;
+    }
+
+    auto loader = Loader::GetLoader(m_system, file);
+    if (!loader) {
+        return;
+    }
+
+    const auto file_type = loader->GetFileType();
+    if (file_type == Loader::FileType::Unknown || file_type == Loader::FileType::Error) {
+        return;
+    }
+
+    u64 program_id = 0;
+    const auto res2 = loader->ReadProgramId(program_id);
+    if (res2 == Loader::ResultStatus::Success && file_type == Loader::FileType::NCA) {
+        m_manual_provider->AddEntry(FileSys::TitleType::Application,
+                                    FileSys::GetCRTypeFromNCAType(FileSys::NCA{file}.GetType()),
+                                    program_id, file);
+    } else if (res2 == Loader::ResultStatus::Success &&
+               (file_type == Loader::FileType::XCI || file_type == Loader::FileType::NSP)) {
+        const auto nsp = file_type == Loader::FileType::NSP
+                             ? std::make_shared<FileSys::NSP>(file)
+                             : FileSys::XCI{file}.GetSecurePartitionNSP();
+        for (const auto& title : nsp->GetNCAs()) {
+            for (const auto& entry : title.second) {
+                m_manual_provider->AddEntry(entry.first.first, entry.first.second, title.first,
+                                            entry.second->GetBaseFile());
+            }
        }
+    }
+}

-        m_rom_metadata_cache[path] = entry;
+Core::SystemResultStatus EmulationSession::InitializeEmulation(const std::string& filepath) {
+    std::scoped_lock lock(m_mutex);

-        return entry;
+    // Create the render window.
+    m_window =
+        std::make_unique<EmuWindow_Android>(&m_input_subsystem, m_native_window, m_vulkan_library);
+
+    m_system.SetFilesystem(m_vfs);
+    m_system.GetUserChannel().clear();
+
+    // Initialize system.
+    jauto android_keyboard = std::make_unique<SoftwareKeyboard::AndroidKeyboard>();
+    m_software_keyboard = android_keyboard.get();
+    m_system.SetShuttingDown(false);
+    m_system.ApplySettings();
+    Settings::LogSettings();
+    m_system.HIDCore().ReloadInputDevices();
+    m_system.SetAppletFrontendSet({
+        nullptr,                     // Amiibo Settings
+        nullptr,                     // Controller Selector
+        nullptr,                     // Error Display
+        nullptr,                     // Mii Editor
+        nullptr,                     // Parental Controls
+        nullptr,                     // Photo Viewer
+        nullptr,                     // Profile Selector
+        std::move(android_keyboard), // Software Keyboard
+        nullptr,                     // Web Browser
+    });
+
+    // Initialize filesystem.
+    m_manual_provider = std::make_unique<FileSys::ManualContentProvider>();
+    m_system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
+    m_system.RegisterContentProvider(FileSys::ContentProviderUnionSlot::FrontendManual,
+                                     m_manual_provider.get());
+    m_system.GetFileSystemController().CreateFactories(*m_vfs);
+    ConfigureFilesystemProvider(filepath);
+
+    // Initialize account manager
+    m_profile_manager = std::make_unique<Service::Account::ProfileManager>();
+
+    // Load the ROM.
+    m_load_result = m_system.Load(EmulationSession::GetInstance().Window(), filepath);
+    if (m_load_result != Core::SystemResultStatus::Success) {
+        return m_load_result;
    }

-private:
-    static void LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress, int max) {
-        JNIEnv* env = IDCache::GetEnvForThread();
-        env->CallStaticVoidMethod(IDCache::GetDiskCacheProgressClass(),
-                                  IDCache::GetDiskCacheLoadProgress(), static_cast<jint>(stage),
-                                  static_cast<jint>(progress), static_cast<jint>(max));
+    // Complete initialization.
+    m_system.GPU().Start();
+    m_system.GetCpuManager().OnGpuReady();
+    m_system.RegisterExitCallback([&] { HaltEmulation(); });
+
+    return Core::SystemResultStatus::Success;
+}
+
+void EmulationSession::ShutdownEmulation() {
+    std::scoped_lock lock(m_mutex);
+
+    m_is_running = false;
+
+    // Unload user input.
+    m_system.HIDCore().UnloadInputDevices();
+
+    // Shutdown the main emulated process
+    if (m_load_result == Core::SystemResultStatus::Success) {
+        m_system.DetachDebugger();
+        m_system.ShutdownMainProcess();
+        m_detached_tasks.WaitForAllTasks();
+        m_load_result = Core::SystemResultStatus::ErrorNotInitialized;
+        m_window.reset();
+        OnEmulationStopped(Core::SystemResultStatus::Success);
+        return;
    }

-    static void OnEmulationStarted() {
-        JNIEnv* env = IDCache::GetEnvForThread();
-        env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(),
-                                  IDCache::GetOnEmulationStarted());
+    // Tear down the render window.
+    m_window.reset();
+}
+
+void EmulationSession::PauseEmulation() {
+    std::scoped_lock lock(m_mutex);
+    m_system.Pause();
+    m_is_paused = true;
+}
+
+void EmulationSession::UnPauseEmulation() {
+    std::scoped_lock lock(m_mutex);
+    m_system.Run();
+    m_is_paused = false;
+}
+
+void EmulationSession::HaltEmulation() {
+    std::scoped_lock lock(m_mutex);
+    m_is_running = false;
+    m_cv.notify_one();
+}
+
+void EmulationSession::RunEmulation() {
+    {
+        std::scoped_lock lock(m_mutex);
+        m_is_running = true;
    }

-    static void OnEmulationStopped(Core::SystemResultStatus result) {
-        JNIEnv* env = IDCache::GetEnvForThread();
-        env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(),
-                                  IDCache::GetOnEmulationStopped(), static_cast<jint>(result));
+    // Load the disk shader cache.
+    if (Settings::values.use_disk_shader_cache.GetValue()) {
+        LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
+        m_system.Renderer().ReadRasterizer()->LoadDiskResources(
+            m_system.GetApplicationProcessProgramID(), std::stop_token{}, LoadDiskCacheProgress);
+        LoadDiskCacheProgress(VideoCore::LoadCallbackStage::Complete, 0, 0);
    }

-private:
-    static EmulationSession s_instance;
+    void(m_system.Run());

-    // Frontend management
-    std::unordered_map<std::string, RomMetadata> m_rom_metadata_cache;
+    if (m_system.DebuggerEnabled()) {
+        m_system.InitializeDebugger();
+    }

-    // Window management
-    std::unique_ptr<EmuWindow_Android> m_window;
-    ANativeWindow* m_native_window{};
+    OnEmulationStarted();

-    // Core emulation
-    Core::System m_system;
-    InputCommon::InputSubsystem m_input_subsystem;
-    Common::DetachedTasks m_detached_tasks;
-    Core::PerfStatsResults m_perf_stats{};
-    std::shared_ptr<FileSys::VfsFilesystem> m_vfs;
-    Core::SystemResultStatus m_load_result{Core::SystemResultStatus::ErrorNotInitialized};
-    std::atomic<bool> m_is_running = false;
-    std::atomic<bool> m_is_paused = false;
-    SoftwareKeyboard::AndroidKeyboard* m_software_keyboard{};
-    std::unique_ptr<Service::Account::ProfileManager> m_profile_manager;
-    std::unique_ptr<FileSys::ManualContentProvider> m_manual_provider;
+    while (true) {
+        {
+            [[maybe_unused]] std::unique_lock lock(m_mutex);
+            if (m_cv.wait_for(lock, std::chrono::milliseconds(800),
+                              [&]() { return !m_is_running; })) {
+                // Emulation halted.
+                break;
+            }
+        }
+        {
+            // Refresh performance stats.
+            std::scoped_lock m_perf_stats_lock(m_perf_stats_mutex);
+            m_perf_stats = m_system.GetAndResetPerfStats();
+        }
+    }
+}

-    // GPU driver parameters
-    std::shared_ptr<Common::DynamicLibrary> m_vulkan_library;
+bool EmulationSession::IsHandheldOnly() {
+    jconst npad_style_set = m_system.HIDCore().GetSupportedStyleTag();

-    // Synchronization
-    std::condition_variable_any m_cv;
-    mutable std::mutex m_perf_stats_mutex;
-    mutable std::mutex m_mutex;
-};
+    if (npad_style_set.fullkey == 1) {
+        return false;
+    }

-/*static*/ EmulationSession EmulationSession::s_instance;
+    if (npad_style_set.handheld == 0) {
+        return false;
+    }

-} // Anonymous namespace
+    return !Settings::IsDockedMode();
+}
+
+void EmulationSession::SetDeviceType([[maybe_unused]] int index, int type) {
+    jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
+    controller->SetNpadStyleIndex(static_cast<Core::HID::NpadStyleIndex>(type));
+}
+
+void EmulationSession::OnGamepadConnectEvent([[maybe_unused]] int index) {
+    jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
+
+    // Ensure that player1 is configured correctly and handheld disconnected
+    if (controller->GetNpadIdType() == Core::HID::NpadIdType::Player1) {
+        jauto handheld = m_system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Handheld);
+
+        if (controller->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::Handheld) {
+            handheld->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
+            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::ProController);
+            handheld->Disconnect();
+        }
+    }
+
+    // Ensure that handheld is configured correctly and player 1 disconnected
+    if (controller->GetNpadIdType() == Core::HID::NpadIdType::Handheld) {
+        jauto player1 = m_system.HIDCore().GetEmulatedController(Core::HID::NpadIdType::Player1);
+
+        if (controller->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::Handheld) {
+            player1->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
+            controller->SetNpadStyleIndex(Core::HID::NpadStyleIndex::Handheld);
+            player1->Disconnect();
+        }
+    }
+
+    if (!controller->IsConnected()) {
+        controller->Connect();
+    }
+}
+
+void EmulationSession::OnGamepadDisconnectEvent([[maybe_unused]] int index) {
+    jauto controller = m_system.HIDCore().GetEmulatedControllerByIndex(index);
+    controller->Disconnect();
+}
+
+SoftwareKeyboard::AndroidKeyboard* EmulationSession::SoftwareKeyboard() {
+    return m_software_keyboard;
+}
+
+void EmulationSession::LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress,
+                                             int max) {
+    JNIEnv* env = IDCache::GetEnvForThread();
+    env->CallStaticVoidMethod(IDCache::GetDiskCacheProgressClass(),
+                              IDCache::GetDiskCacheLoadProgress(), static_cast<jint>(stage),
+                              static_cast<jint>(progress), static_cast<jint>(max));
+}
+
+void EmulationSession::OnEmulationStarted() {
+    JNIEnv* env = IDCache::GetEnvForThread();
+    env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(), IDCache::GetOnEmulationStarted());
+}
+
+void EmulationSession::OnEmulationStopped(Core::SystemResultStatus result) {
+    JNIEnv* env = IDCache::GetEnvForThread();
+    env->CallStaticVoidMethod(IDCache::GetNativeLibraryClass(), IDCache::GetOnEmulationStopped(),
+                              static_cast<jint>(result));
+}

 static Core::SystemResultStatus RunEmulation(const std::string& filepath) {
    Common::Log::Initialize();
@ -657,10 +558,6 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_stopEmulation(JNIEnv* env, jclass cla
    EmulationSession::GetInstance().HaltEmulation();
 }

-void Java_org_yuzu_yuzu_1emu_NativeLibrary_resetRomMetadata(JNIEnv* env, jclass clazz) {
-    EmulationSession::GetInstance().ResetRomMetadata();
-}
-
 jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_isRunning(JNIEnv* env, jclass clazz) {
    return static_cast<jboolean>(EmulationSession::GetInstance().IsRunning());
 }
@ -766,46 +663,6 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_onTouchReleased(JNIEnv* env, jclass c
    }
 }

-jbyteArray Java_org_yuzu_yuzu_1emu_NativeLibrary_getIcon(JNIEnv* env, jclass clazz,
-                                                         jstring j_filename) {
-    jauto icon_data = EmulationSession::GetInstance().GetRomIcon(GetJString(env, j_filename));
-    jbyteArray icon = env->NewByteArray(static_cast<jsize>(icon_data.size()));
-    env->SetByteArrayRegion(icon, 0, env->GetArrayLength(icon),
-                            reinterpret_cast<jbyte*>(icon_data.data()));
-    return icon;
-}
-
-jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getTitle(JNIEnv* env, jclass clazz,
-                                                       jstring j_filename) {
-    jauto title = EmulationSession::GetInstance().GetRomTitle(GetJString(env, j_filename));
-    return env->NewStringUTF(title.c_str());
-}
-
-jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getDescription(JNIEnv* env, jclass clazz,
-                                                             jstring j_filename) {
-    return j_filename;
-}
-
-jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getGameId(JNIEnv* env, jclass clazz,
-                                                        jstring j_filename) {
-    return j_filename;
-}
-
-jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getRegions(JNIEnv* env, jclass clazz,
-                                                         jstring j_filename) {
-    return env->NewStringUTF("");
-}
-
-jstring Java_org_yuzu_yuzu_1emu_NativeLibrary_getCompany(JNIEnv* env, jclass clazz,
-                                                         jstring j_filename) {
-    return env->NewStringUTF("");
-}
-
-jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_isHomebrew(JNIEnv* env, jclass clazz,
-                                                          jstring j_filename) {
-    return EmulationSession::GetInstance().GetIsHomebrew(GetJString(env, j_filename));
-}
-
 void Java_org_yuzu_yuzu_1emu_NativeLibrary_initializeEmulation(JNIEnv* env, jclass clazz) {
    // Create the default config.ini.
    Config{};
--- a/src/android/app/src/main/jni/native.h
+++ b/src/android/app/src/main/jni/native.h
@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <android/native_window_jni.h>
+#include "common/detached_tasks.h"
+#include "core/core.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/hle/service/acc/profile_manager.h"
+#include "core/perf_stats.h"
+#include "jni/applets/software_keyboard.h"
+#include "jni/emu_window/emu_window.h"
+#include "video_core/rasterizer_interface.h"
+
+#pragma once
+
+class EmulationSession final {
+public:
+    explicit EmulationSession();
+    ~EmulationSession() = default;
+
+    static EmulationSession& GetInstance();
+    const Core::System& System() const;
+    Core::System& System();
+
+    const EmuWindow_Android& Window() const;
+    EmuWindow_Android& Window();
+    ANativeWindow* NativeWindow() const;
+    void SetNativeWindow(ANativeWindow* native_window);
+    void SurfaceChanged();
+
+    int InstallFileToNand(std::string filename, std::string file_extension);
+    void InitializeGpuDriver(const std::string& hook_lib_dir, const std::string& custom_driver_dir,
+                             const std::string& custom_driver_name,
+                             const std::string& file_redirect_dir);
+
+    bool IsRunning() const;
+    bool IsPaused() const;
+    void PauseEmulation();
+    void UnPauseEmulation();
+    void HaltEmulation();
+    void RunEmulation();
+    void ShutdownEmulation();
+
+    const Core::PerfStatsResults& PerfStats() const;
+    void ConfigureFilesystemProvider(const std::string& filepath);
+    Core::SystemResultStatus InitializeEmulation(const std::string& filepath);
+
+    bool IsHandheldOnly();
+    void SetDeviceType([[maybe_unused]] int index, int type);
+    void OnGamepadConnectEvent([[maybe_unused]] int index);
+    void OnGamepadDisconnectEvent([[maybe_unused]] int index);
+    SoftwareKeyboard::AndroidKeyboard* SoftwareKeyboard();
+
+private:
+    static void LoadDiskCacheProgress(VideoCore::LoadCallbackStage stage, int progress, int max);
+    static void OnEmulationStarted();
+    static void OnEmulationStopped(Core::SystemResultStatus result);
+
+private:
+    // Window management
+    std::unique_ptr<EmuWindow_Android> m_window;
+    ANativeWindow* m_native_window{};
+
+    // Core emulation
+    Core::System m_system;
+    InputCommon::InputSubsystem m_input_subsystem;
+    Common::DetachedTasks m_detached_tasks;
+    Core::PerfStatsResults m_perf_stats{};
+    std::shared_ptr<FileSys::VfsFilesystem> m_vfs;
+    Core::SystemResultStatus m_load_result{Core::SystemResultStatus::ErrorNotInitialized};
+    std::atomic<bool> m_is_running = false;
+    std::atomic<bool> m_is_paused = false;
+    SoftwareKeyboard::AndroidKeyboard* m_software_keyboard{};
+    std::unique_ptr<Service::Account::ProfileManager> m_profile_manager;
+    std::unique_ptr<FileSys::ManualContentProvider> m_manual_provider;
+
+    // GPU driver parameters
+    std::shared_ptr<Common::DynamicLibrary> m_vulkan_library;
+
+    // Synchronization
+    std::condition_variable_any m_cv;
+    mutable std::mutex m_perf_stats_mutex;
+    mutable std::mutex m_mutex;
+};
--- a/src/android/app/src/main/res/layout/card_game.xml
+++ b/src/android/app/src/main/res/layout/card_game.xml
@ -1,63 +1,54 @@
 <?xml version="1.0" encoding="utf-8"?>
-<FrameLayout
-    xmlns:android="http://schemas.android.com/apk/res/android"
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <com.google.android.material.card.MaterialCardView
-        style="?attr/materialCardViewElevatedStyle"
        android:id="@+id/card_game"
+        style="?attr/materialCardViewElevatedStyle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
+        android:layout_gravity="center"
        android:background="?attr/selectableItemBackground"
        android:clickable="true"
        android:clipToPadding="false"
        android:focusable="true"
        android:transitionName="card_game"
-        android:layout_gravity="center"
-        app:cardElevation="0dp"
-        app:cardCornerRadius="12dp">
+        app:cardCornerRadius="4dp"
+        app:cardElevation="0dp">

        <androidx.constraintlayout.widget.ConstraintLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:padding="6dp">

-            <com.google.android.material.card.MaterialCardView
-                style="?attr/materialCardViewElevatedStyle"
-                android:id="@+id/card_game_art"
+            <com.google.android.material.imageview.ShapeableImageView
+                android:id="@+id/image_game_screen"
                android:layout_width="150dp"
                android:layout_height="150dp"
-                app:cardCornerRadius="4dp"
                app:layout_constraintEnd_toEndOf="parent"
                app:layout_constraintStart_toStartOf="parent"
-                app:layout_constraintTop_toTopOf="parent">
-
-                <ImageView
-                    android:id="@+id/image_game_screen"
-                    android:layout_width="match_parent"
-                    android:layout_height="match_parent"
-                    tools:src="@drawable/default_icon" />
-
-            </com.google.android.material.card.MaterialCardView>
+                app:layout_constraintTop_toTopOf="parent"
+                app:shapeAppearance="@style/ShapeAppearance.Material3.Corner.ExtraSmall"
+                tools:src="@drawable/default_icon" />

            <com.google.android.material.textview.MaterialTextView
-                style="@style/TextAppearance.Material3.TitleMedium"
                android:id="@+id/text_game_title"
+                style="@style/TextAppearance.Material3.TitleMedium"
                android:layout_width="0dp"
                android:layout_height="wrap_content"
                android:layout_marginTop="8dp"
+                android:ellipsize="none"
+                android:marqueeRepeatLimit="marquee_forever"
+                android:requiresFadingEdge="horizontal"
+                android:singleLine="true"
                android:textAlignment="center"
                android:textSize="14sp"
-                android:singleLine="true"
-                android:marqueeRepeatLimit="marquee_forever"
-                android:ellipsize="none"
-                android:requiresFadingEdge="horizontal"
-                app:layout_constraintEnd_toEndOf="@+id/card_game_art"
-                app:layout_constraintStart_toStartOf="@+id/card_game_art"
-                app:layout_constraintTop_toBottomOf="@+id/card_game_art"
+                app:layout_constraintEnd_toEndOf="@+id/image_game_screen"
+                app:layout_constraintStart_toStartOf="@+id/image_game_screen"
+                app:layout_constraintTop_toBottomOf="@+id/image_game_screen"
                tools:text="The Legend of Zelda: Skyward Sword" />

        </androidx.constraintlayout.widget.ConstraintLayout>
--- a/src/common/fs/fs_android.cpp
+++ b/src/common/fs/fs_android.cpp
@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include "common/fs/fs_android.h"
+#include "common/string_util.h"

 namespace Common::FS::Android {

@ -28,28 +29,35 @@ void RegisterCallbacks(JNIEnv* env, jclass clazz) {
    env->GetJavaVM(&g_jvm);
    native_library = clazz;

+#define FH(FunctionName, JMethodID, Caller, JMethodName, Signature)                                \
+    F(JMethodID, JMethodName, Signature)
 #define FR(FunctionName, ReturnValue, JMethodID, Caller, JMethodName, Signature)                   \
    F(JMethodID, JMethodName, Signature)
 #define FS(FunctionName, ReturnValue, Parameters, JMethodID, JMethodName, Signature)               \
    F(JMethodID, JMethodName, Signature)
 #define F(JMethodID, JMethodName, Signature)                                                       \
    JMethodID = env->GetStaticMethodID(native_library, JMethodName, Signature);
+    ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(FH)
    ANDROID_SINGLE_PATH_DETERMINE_FUNCTIONS(FR)
    ANDROID_STORAGE_FUNCTIONS(FS)
 #undef F
 #undef FS
 #undef FR
+#undef FH
 }

 void UnRegisterCallbacks() {
+#define FH(FunctionName, JMethodID, Caller, JMethodName, Signature) F(JMethodID)
 #define FR(FunctionName, ReturnValue, JMethodID, Caller, JMethodName, Signature) F(JMethodID)
 #define FS(FunctionName, ReturnValue, Parameters, JMethodID, JMethodName, Signature) F(JMethodID)
 #define F(JMethodID) JMethodID = nullptr;
+    ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(FH)
    ANDROID_SINGLE_PATH_DETERMINE_FUNCTIONS(FR)
    ANDROID_STORAGE_FUNCTIONS(FS)
 #undef F
 #undef FS
 #undef FR
+#undef FH
 }

 bool IsContentUri(const std::string& path) {
@ -95,4 +103,29 @@ ANDROID_SINGLE_PATH_DETERMINE_FUNCTIONS(FR)
 #undef F
 #undef FR

+#define FH(FunctionName, JMethodID, Caller, JMethodName, Signature)                                \
+    F(FunctionName, JMethodID, Caller)
+#define F(FunctionName, JMethodID, Caller)                                                         \
+    std::string FunctionName(const std::string& filepath) {                                        \
+        if (JMethodID == nullptr) {                                                                \
+            return 0;                                                                              \
+        }                                                                                          \
+        auto env = GetEnvForThread();                                                              \
+        jstring j_filepath = env->NewStringUTF(filepath.c_str());                                  \
+        jstring j_return =                                                                         \
+            static_cast<jstring>(env->Caller(native_library, JMethodID, j_filepath));              \
+        if (!j_return) {                                                                           \
+            return {};                                                                             \
+        }                                                                                          \
+        const jchar* jchars = env->GetStringChars(j_return, nullptr);                              \
+        const jsize length = env->GetStringLength(j_return);                                       \
+        const std::u16string_view string_view(reinterpret_cast<const char16_t*>(jchars), length);  \
+        const std::string converted_string = Common::UTF16ToUTF8(string_view);                     \
+        env->ReleaseStringChars(j_return, jchars);                                                 \
+        return converted_string;                                                                   \
+    }
+ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(FH)
+#undef F
+#undef FH
+
 } // namespace Common::FS::Android
--- a/src/common/fs/fs_android.h
+++ b/src/common/fs/fs_android.h
@ -17,19 +17,28 @@
      "(Ljava/lang/String;)Z")                                                                     \
    V(Exists, bool, file_exists, CallStaticBooleanMethod, "exists", "(Ljava/lang/String;)Z")

+#define ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(V)                                                    \
+    V(GetParentDirectory, get_parent_directory, CallStaticObjectMethod, "getParentDirectory",      \
+      "(Ljava/lang/String;)Ljava/lang/String;")                                                    \
+    V(GetFilename, get_filename, CallStaticObjectMethod, "getFilename",                            \
+      "(Ljava/lang/String;)Ljava/lang/String;")
+
 namespace Common::FS::Android {

 static JavaVM* g_jvm = nullptr;
 static jclass native_library = nullptr;

+#define FH(FunctionName, JMethodID, Caller, JMethodName, Signature) F(JMethodID)
 #define FR(FunctionName, ReturnValue, JMethodID, Caller, JMethodName, Signature) F(JMethodID)
 #define FS(FunctionName, ReturnValue, Parameters, JMethodID, JMethodName, Signature) F(JMethodID)
 #define F(JMethodID) static jmethodID JMethodID = nullptr;
+ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(FH)
 ANDROID_SINGLE_PATH_DETERMINE_FUNCTIONS(FR)
 ANDROID_STORAGE_FUNCTIONS(FS)
 #undef F
 #undef FS
 #undef FR
+#undef FH

 enum class OpenMode {
    Read,
@ -62,4 +71,10 @@ ANDROID_SINGLE_PATH_DETERMINE_FUNCTIONS(FR)
 #undef F
 #undef FR

+#define FH(FunctionName, JMethodID, Caller, JMethodName, Signature) F(FunctionName)
+#define F(FunctionName) std::string FunctionName(const std::string& filepath);
+ANDROID_SINGLE_PATH_HELPER_FUNCTIONS(FH)
+#undef F
+#undef FH
+
 } // namespace Common::FS::Android
--- a/src/common/fs/fs_paths.h
+++ b/src/common/fs/fs_paths.h
@ -13,6 +13,7 @@
 #define AMIIBO_DIR "amiibo"
 #define CACHE_DIR "cache"
 #define CONFIG_DIR "config"
+#define CRASH_DUMPS_DIR "crash_dumps"
 #define DUMP_DIR "dump"
 #define KEYS_DIR "keys"
 #define LOAD_DIR "load"
--- a/src/common/fs/path_util.cpp
+++ b/src/common/fs/path_util.cpp
@ -119,6 +119,7 @@ public:
        GenerateYuzuPath(YuzuPath::AmiiboDir, yuzu_path / AMIIBO_DIR);
        GenerateYuzuPath(YuzuPath::CacheDir, yuzu_path_cache);
        GenerateYuzuPath(YuzuPath::ConfigDir, yuzu_path_config);
+        GenerateYuzuPath(YuzuPath::CrashDumpsDir, yuzu_path / CRASH_DUMPS_DIR);
        GenerateYuzuPath(YuzuPath::DumpDir, yuzu_path / DUMP_DIR);
        GenerateYuzuPath(YuzuPath::KeysDir, yuzu_path / KEYS_DIR);
        GenerateYuzuPath(YuzuPath::LoadDir, yuzu_path / LOAD_DIR);
@ -400,6 +401,16 @@ std::string SanitizePath(std::string_view path_, DirectorySeparator directory_se
 }

 std::string_view GetParentPath(std::string_view path) {
+    if (path.empty()) {
+        return path;
+    }
+
+#ifdef ANDROID
+    if (path[0] != '/') {
+        std::string path_string{path};
+        return FS::Android::GetParentDirectory(path_string);
+    }
+#endif
    const auto name_bck_index = path.rfind('\\');
    const auto name_fwd_index = path.rfind('/');
    std::size_t name_index;
--- a/src/common/fs/path_util.h
+++ b/src/common/fs/path_util.h
@ -15,6 +15,7 @@ enum class YuzuPath {
    AmiiboDir,      // Where Amiibo backups are stored.
    CacheDir,       // Where cached filesystem data is stored.
    ConfigDir,      // Where config files are stored.
+    CrashDumpsDir,  // Where crash dumps are stored.
    DumpDir,        // Where dumped data is stored.
    KeysDir,        // Where key files are stored.
    LoadDir,        // Where cheat/mod files are stored.
--- a/src/common/settings.h
+++ b/src/common/settings.h
@ -505,7 +505,6 @@ struct Values {
        linkage, false, "use_auto_stub", Category::Debugging, Specialization::Default, false};
    Setting<bool> enable_all_controllers{linkage, false, "enable_all_controllers",
                                         Category::Debugging};
-    Setting<bool> create_crash_dumps{linkage, false, "create_crash_dumps", Category::Debugging};
    Setting<bool> perform_vulkan_check{linkage, true, "perform_vulkan_check", Category::Debugging};

    // Miscellaneous
--- a/src/common/string_util.cpp
+++ b/src/common/string_util.cpp
@ -14,6 +14,10 @@
 #include <windows.h>
 #endif

+#ifdef ANDROID
+#include <common/fs/fs_android.h>
+#endif
+
 namespace Common {

 /// Make a string lowercase
@ -63,6 +67,14 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
    if (full_path.empty())
        return false;

+#ifdef ANDROID
+    if (full_path[0] != '/') {
+        *_pPath = Common::FS::Android::GetParentDirectory(full_path);
+        *_pFilename = Common::FS::Android::GetFilename(full_path);
+        return true;
+    }
+#endif
+
    std::size_t dir_end = full_path.find_last_of("/"
 // windows needs the : included for something like just "C:" to be considered a directory
 #ifdef _WIN32
--- a/src/yuzu/CMakeLists.txt
+++ b/src/yuzu/CMakeLists.txt
@ -227,14 +227,14 @@ add_executable(yuzu
    yuzu.rc
 )

-if (WIN32 AND YUZU_CRASH_DUMPS)
+if (YUZU_CRASH_DUMPS)
    target_sources(yuzu PRIVATE
-        mini_dump.cpp
-        mini_dump.h
+        breakpad.cpp
+        breakpad.h
    )

-    target_link_libraries(yuzu PRIVATE ${DBGHELP_LIBRARY})
-    target_compile_definitions(yuzu PRIVATE -DYUZU_DBGHELP)
+    target_link_libraries(yuzu PRIVATE libbreakpad_client)
+    target_compile_definitions(yuzu PRIVATE YUZU_CRASH_DUMPS)
 endif()

 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
--- a/src/yuzu/breakpad.cpp
+++ b/src/yuzu/breakpad.cpp
@ -0,0 +1,77 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <algorithm>
+#include <ranges>
+
+#if defined(_WIN32)
+#include <client/windows/handler/exception_handler.h>
+#elif defined(__linux__)
+#include <client/linux/handler/exception_handler.h>
+#else
+#error Minidump creation not supported on this platform
+#endif
+
+#include "common/fs/fs_paths.h"
+#include "common/fs/path_util.h"
+#include "yuzu/breakpad.h"
+
+namespace Breakpad {
+
+static void PruneDumpDirectory(const std::filesystem::path& dump_path) {
+    // Code in this function should be exception-safe.
+    struct Entry {
+        std::filesystem::path path;
+        std::filesystem::file_time_type last_write_time;
+    };
+    std::vector<Entry> existing_dumps;
+
+    // Get existing entries.
+    std::error_code ec;
+    std::filesystem::directory_iterator dir(dump_path, ec);
+    for (auto& entry : dir) {
+        if (entry.is_regular_file()) {
+            existing_dumps.push_back(Entry{
+                .path = entry.path(),
+                .last_write_time = entry.last_write_time(ec),
+            });
+        }
+    }
+
+    // Sort descending by creation date.
+    std::ranges::stable_sort(existing_dumps, [](const auto& a, const auto& b) {
+        return a.last_write_time > b.last_write_time;
+    });
+
+    // Delete older dumps.
+    for (size_t i = 5; i < existing_dumps.size(); i++) {
+        std::filesystem::remove(existing_dumps[i].path, ec);
+    }
+}
+
+#if defined(__linux__)
+[[noreturn]] bool DumpCallback(const google_breakpad::MinidumpDescriptor& descriptor, void* context,
+                               bool succeeded) {
+    // Prevent time- and space-consuming core dumps from being generated, as we have
+    // already generated a minidump and a core file will not be useful anyway.
+    _exit(1);
+}
+#endif
+
+void InstallCrashHandler() {
+    // Write crash dumps to profile directory.
+    const auto dump_path = GetYuzuPath(Common::FS::YuzuPath::CrashDumpsDir);
+    PruneDumpDirectory(dump_path);
+
+#if defined(_WIN32)
+    // TODO: If we switch to MinGW builds for Windows, this needs to be wrapped in a C API.
+    static google_breakpad::ExceptionHandler eh{dump_path, nullptr, nullptr, nullptr,
+                                                google_breakpad::ExceptionHandler::HANDLER_ALL};
+#elif defined(__linux__)
+    static google_breakpad::MinidumpDescriptor descriptor{dump_path};
+    static google_breakpad::ExceptionHandler eh{descriptor, nullptr, DumpCallback,
+                                                nullptr,    true,    -1};
+#endif
+}
+
+} // namespace Breakpad
--- a/src/yuzu/breakpad.h
+++ b/src/yuzu/breakpad.h
@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+namespace Breakpad {
+
+void InstallCrashHandler();
+
+}
--- a/src/yuzu/configuration/configure_debug.cpp
+++ b/src/yuzu/configuration/configure_debug.cpp
@ -27,16 +27,6 @@ ConfigureDebug::ConfigureDebug(const Core::System& system_, QWidget* parent)

    connect(ui->toggle_gdbstub, &QCheckBox::toggled,
            [&]() { ui->gdbport_spinbox->setEnabled(ui->toggle_gdbstub->isChecked()); });
-
-    connect(ui->create_crash_dumps, &QCheckBox::stateChanged, [&](int) {
-        if (crash_dump_warning_shown) {
-            return;
-        }
-        QMessageBox::warning(this, tr("Restart Required"),
-                             tr("yuzu is required to restart in order to apply this setting."),
-                             QMessageBox::Ok, QMessageBox::Ok);
-        crash_dump_warning_shown = true;
-    });
 }

 ConfigureDebug::~ConfigureDebug() = default;
@ -89,13 +79,6 @@ void ConfigureDebug::SetConfiguration() {
    ui->disable_web_applet->setEnabled(false);
    ui->disable_web_applet->setText(tr("Web applet not compiled"));
 #endif
-
-#ifdef YUZU_DBGHELP
-    ui->create_crash_dumps->setChecked(Settings::values.create_crash_dumps.GetValue());
-#else
-    ui->create_crash_dumps->setEnabled(false);
-    ui->create_crash_dumps->setText(tr("MiniDump creation not compiled"));
-#endif
 }

 void ConfigureDebug::ApplyConfiguration() {
@ -107,7 +90,6 @@ void ConfigureDebug::ApplyConfiguration() {
    Settings::values.enable_fs_access_log = ui->fs_access_log->isChecked();
    Settings::values.reporting_services = ui->reporting_services->isChecked();
    Settings::values.dump_audio_commands = ui->dump_audio_commands->isChecked();
-    Settings::values.create_crash_dumps = ui->create_crash_dumps->isChecked();
    Settings::values.quest_flag = ui->quest_flag->isChecked();
    Settings::values.use_debug_asserts = ui->use_debug_asserts->isChecked();
    Settings::values.use_auto_stub = ui->use_auto_stub->isChecked();
--- a/src/yuzu/configuration/configure_debug.ui
+++ b/src/yuzu/configuration/configure_debug.ui
@ -471,13 +471,6 @@
           </property>
          </widget>
         </item>
-         <item row="4" column="0">
-          <widget class="QCheckBox" name="create_crash_dumps">
-           <property name="text">
-            <string>Create Minidump After Crash</string>
-           </property>
-          </widget>
-         </item>
         <item row="3" column="0">
          <widget class="QCheckBox" name="dump_audio_commands">
           <property name="toolTip">
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@ -159,8 +159,8 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "yuzu/util/clickable_label.h"
 #include "yuzu/vk_device_info.h"

-#ifdef YUZU_DBGHELP
-#include "yuzu/mini_dump.h"
+#ifdef YUZU_CRASH_DUMPS
+#include "yuzu/breakpad.h"
 #endif

 using namespace Common::Literals;
@ -1072,7 +1072,7 @@ void GMainWindow::InitializeWidgets() {
    });
    volume_popup->layout()->addWidget(volume_slider);

-    volume_button = new QPushButton();
+    volume_button = new VolumeButton();
    volume_button->setObjectName(QStringLiteral("TogglableStatusBarButton"));
    volume_button->setFocusPolicy(Qt::NoFocus);
    volume_button->setCheckable(true);
@ -1103,6 +1103,8 @@ void GMainWindow::InitializeWidgets() {
                context_menu.exec(volume_button->mapToGlobal(menu_location));
                volume_button->repaint();
            });
+    connect(volume_button, &VolumeButton::VolumeChanged, this, &GMainWindow::UpdateVolumeUI);
+
    statusBar()->insertPermanentWidget(0, volume_button);

    // setup AA button
@ -2906,7 +2908,7 @@ void GMainWindow::OnGameListCreateShortcut(u64 program_id, const std::string& ga

    const std::string game_file_name = std::filesystem::path(game_path).filename().string();
    // Determine full paths for icon and shortcut
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)
    const char* home = std::getenv("HOME");
    const std::filesystem::path home_path = (home == nullptr ? "~" : home);
    const char* xdg_data_home = std::getenv("XDG_DATA_HOME");
@ -2963,7 +2965,7 @@ void GMainWindow::OnGameListCreateShortcut(u64 program_id, const std::string& ga

    QImage icon_data =
        QImage::fromData(icon_image_file.data(), static_cast<int>(icon_image_file.size()));
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)
    // Convert and write the icon as a PNG
    if (!icon_data.save(QString::fromStdString(icon_path.string()))) {
        LOG_ERROR(Frontend, "Could not write icon as PNG to file");
@ -4002,7 +4004,7 @@ bool GMainWindow::CreateShortcut(const std::string& shortcut_path, const std::st
                                 const std::string& comment, const std::string& icon_path,
                                 const std::string& command, const std::string& arguments,
                                 const std::string& categories, const std::string& keywords) {
-#if defined(__linux__) || defined(__FreeBSD__)
+#if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)
    // This desktop file template was writing referencing
    // https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-1.0.html
    std::string shortcut_contents{};
@ -5126,6 +5128,32 @@ void GMainWindow::changeEvent(QEvent* event) {
    QWidget::changeEvent(event);
 }

+void VolumeButton::wheelEvent(QWheelEvent* event) {
+
+    int num_degrees = event->angleDelta().y() / 8;
+    int num_steps = (num_degrees / 15) * scroll_multiplier;
+    // Stated in QT docs: Most mouse types work in steps of 15 degrees, in which case the delta
+    // value is a multiple of 120; i.e., 120 units * 1/8 = 15 degrees.
+
+    if (num_steps > 0) {
+        Settings::values.volume.SetValue(
+            std::min(200, Settings::values.volume.GetValue() + num_steps));
+    } else {
+        Settings::values.volume.SetValue(
+            std::max(0, Settings::values.volume.GetValue() + num_steps));
+    }
+
+    scroll_multiplier = std::min(MaxMultiplier, scroll_multiplier * 2);
+    scroll_timer.start(100); // reset the multiplier if no scroll event occurs within 100 ms
+
+    emit VolumeChanged();
+    event->accept();
+}
+
+void VolumeButton::ResetMultiplier() {
+    scroll_multiplier = 1;
+}
+
 #ifdef main
 #undef main
 #endif
@ -5187,22 +5215,15 @@ int main(int argc, char* argv[]) {
        return 0;
    }

-#ifdef YUZU_DBGHELP
-    PROCESS_INFORMATION pi;
-    if (!is_child && Settings::values.create_crash_dumps.GetValue() &&
-        MiniDump::SpawnDebuggee(argv[0], pi)) {
-        // Delete the config object so that it doesn't save when the program exits
-        config.reset(nullptr);
-        MiniDump::DebugDebuggee(pi);
-        return 0;
-    }
-#endif
-
    if (StartupChecks(argv[0], &has_broken_vulkan,
                      Settings::values.perform_vulkan_check.GetValue())) {
        return 0;
    }

+#ifdef YUZU_CRASH_DUMPS
+    Breakpad::InstallCrashHandler();
+#endif
+
    Common::DetachedTasks detached_tasks;
    MicroProfileOnThreadCreate("Frontend");
    SCOPE_EXIT({ MicroProfileShutdown(); });
--- a/src/yuzu/main.h
+++ b/src/yuzu/main.h
@ -8,6 +8,7 @@

 #include <QMainWindow>
 #include <QMessageBox>
+#include <QPushButton>
 #include <QTimer>
 #include <QTranslator>

@ -137,6 +138,28 @@ namespace VkDeviceInfo {
 class Record;
 }

+class VolumeButton : public QPushButton {
+    Q_OBJECT
+public:
+    explicit VolumeButton(QWidget* parent = nullptr) : QPushButton(parent), scroll_multiplier(1) {
+        connect(&scroll_timer, &QTimer::timeout, this, &VolumeButton::ResetMultiplier);
+    }
+
+signals:
+    void VolumeChanged();
+
+protected:
+    void wheelEvent(QWheelEvent* event) override;
+
+private slots:
+    void ResetMultiplier();
+
+private:
+    int scroll_multiplier;
+    QTimer scroll_timer;
+    constexpr static int MaxMultiplier = 8;
+};
+
 class GMainWindow : public QMainWindow {
    Q_OBJECT

@ -481,7 +504,7 @@ private:
    QPushButton* dock_status_button = nullptr;
    QPushButton* filter_status_button = nullptr;
    QPushButton* aa_status_button = nullptr;
-    QPushButton* volume_button = nullptr;
+    VolumeButton* volume_button = nullptr;
    QWidget* volume_popup = nullptr;
    QSlider* volume_slider = nullptr;
    QTimer status_bar_update_timer;
--- a/src/yuzu/mini_dump.cpp
+++ b/src/yuzu/mini_dump.cpp
@ -1,202 +0,0 @@
-// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <cstdio>
-#include <cstring>
-#include <ctime>
-#include <filesystem>
-#include <fmt/format.h>
-#include <windows.h>
-#include "yuzu/mini_dump.h"
-#include "yuzu/startup_checks.h"
-
-// dbghelp.h must be included after windows.h
-#include <dbghelp.h>
-
-namespace MiniDump {
-
-void CreateMiniDump(HANDLE process_handle, DWORD process_id, MINIDUMP_EXCEPTION_INFORMATION* info,
-                    EXCEPTION_POINTERS* pep) {
-    char file_name[255];
-    const std::time_t the_time = std::time(nullptr);
-    std::strftime(file_name, 255, "yuzu-crash-%Y%m%d%H%M%S.dmp", std::localtime(&the_time));
-
-    // Open the file
-    HANDLE file_handle = CreateFileA(file_name, GENERIC_READ | GENERIC_WRITE, 0, nullptr,
-                                     CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
-
-    if (file_handle == nullptr || file_handle == INVALID_HANDLE_VALUE) {
-        fmt::print(stderr, "CreateFileA failed. Error: {}", GetLastError());
-        return;
-    }
-
-    // Create the minidump
-    const MINIDUMP_TYPE dump_type = MiniDumpNormal;
-
-    const bool write_dump_status = MiniDumpWriteDump(process_handle, process_id, file_handle,
-                                                     dump_type, (pep != 0) ? info : 0, 0, 0);
-
-    if (write_dump_status) {
-        fmt::print(stderr, "MiniDump created: {}", file_name);
-    } else {
-        fmt::print(stderr, "MiniDumpWriteDump failed. Error: {}", GetLastError());
-    }
-
-    // Close the file
-    CloseHandle(file_handle);
-}
-
-void DumpFromDebugEvent(DEBUG_EVENT& deb_ev, PROCESS_INFORMATION& pi) {
-    EXCEPTION_RECORD& record = deb_ev.u.Exception.ExceptionRecord;
-
-    HANDLE thread_handle = OpenThread(THREAD_GET_CONTEXT, false, deb_ev.dwThreadId);
-    if (thread_handle == nullptr) {
-        fmt::print(stderr, "OpenThread failed ({})", GetLastError());
-        return;
-    }
-
-    // Get child process context
-    CONTEXT context = {};
-    context.ContextFlags = CONTEXT_ALL;
-    if (!GetThreadContext(thread_handle, &context)) {
-        fmt::print(stderr, "GetThreadContext failed ({})", GetLastError());
-        return;
-    }
-
-    // Create exception pointers for minidump
-    EXCEPTION_POINTERS ep;
-    ep.ExceptionRecord = &record;
-    ep.ContextRecord = &context;
-
-    MINIDUMP_EXCEPTION_INFORMATION info;
-    info.ThreadId = deb_ev.dwThreadId;
-    info.ExceptionPointers = &ep;
-    info.ClientPointers = false;
-
-    CreateMiniDump(pi.hProcess, pi.dwProcessId, &info, &ep);
-
-    if (CloseHandle(thread_handle) == 0) {
-        fmt::print(stderr, "error: CloseHandle(thread_handle) failed ({})", GetLastError());
-    }
-}
-
-bool SpawnDebuggee(const char* arg0, PROCESS_INFORMATION& pi) {
-    std::memset(&pi, 0, sizeof(pi));
-
-    // Don't debug if we are already being debugged
-    if (IsDebuggerPresent()) {
-        return false;
-    }
-
-    if (!SpawnChild(arg0, &pi, 0)) {
-        fmt::print(stderr, "warning: continuing without crash dumps");
-        return false;
-    }
-
-    const bool can_debug = DebugActiveProcess(pi.dwProcessId);
-    if (!can_debug) {
-        fmt::print(stderr,
-                   "warning: DebugActiveProcess failed ({}), continuing without crash dumps",
-                   GetLastError());
-        return false;
-    }
-
-    return true;
-}
-
-static const char* ExceptionName(DWORD exception) {
-    switch (exception) {
-    case EXCEPTION_ACCESS_VIOLATION:
-        return "EXCEPTION_ACCESS_VIOLATION";
-    case EXCEPTION_DATATYPE_MISALIGNMENT:
-        return "EXCEPTION_DATATYPE_MISALIGNMENT";
-    case EXCEPTION_BREAKPOINT:
-        return "EXCEPTION_BREAKPOINT";
-    case EXCEPTION_SINGLE_STEP:
-        return "EXCEPTION_SINGLE_STEP";
-    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-        return "EXCEPTION_ARRAY_BOUNDS_EXCEEDED";
-    case EXCEPTION_FLT_DENORMAL_OPERAND:
-        return "EXCEPTION_FLT_DENORMAL_OPERAND";
-    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-        return "EXCEPTION_FLT_DIVIDE_BY_ZERO";
-    case EXCEPTION_FLT_INEXACT_RESULT:
-        return "EXCEPTION_FLT_INEXACT_RESULT";
-    case EXCEPTION_FLT_INVALID_OPERATION:
-        return "EXCEPTION_FLT_INVALID_OPERATION";
-    case EXCEPTION_FLT_OVERFLOW:
-        return "EXCEPTION_FLT_OVERFLOW";
-    case EXCEPTION_FLT_STACK_CHECK:
-        return "EXCEPTION_FLT_STACK_CHECK";
-    case EXCEPTION_FLT_UNDERFLOW:
-        return "EXCEPTION_FLT_UNDERFLOW";
-    case EXCEPTION_INT_DIVIDE_BY_ZERO:
-        return "EXCEPTION_INT_DIVIDE_BY_ZERO";
-    case EXCEPTION_INT_OVERFLOW:
-        return "EXCEPTION_INT_OVERFLOW";
-    case EXCEPTION_PRIV_INSTRUCTION:
-        return "EXCEPTION_PRIV_INSTRUCTION";
-    case EXCEPTION_IN_PAGE_ERROR:
-        return "EXCEPTION_IN_PAGE_ERROR";
-    case EXCEPTION_ILLEGAL_INSTRUCTION:
-        return "EXCEPTION_ILLEGAL_INSTRUCTION";
-    case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-        return "EXCEPTION_NONCONTINUABLE_EXCEPTION";
-    case EXCEPTION_STACK_OVERFLOW:
-        return "EXCEPTION_STACK_OVERFLOW";
-    case EXCEPTION_INVALID_DISPOSITION:
-        return "EXCEPTION_INVALID_DISPOSITION";
-    case EXCEPTION_GUARD_PAGE:
-        return "EXCEPTION_GUARD_PAGE";
-    case EXCEPTION_INVALID_HANDLE:
-        return "EXCEPTION_INVALID_HANDLE";
-    default:
-        return "unknown exception type";
-    }
-}
-
-void DebugDebuggee(PROCESS_INFORMATION& pi) {
-    DEBUG_EVENT deb_ev = {};
-
-    while (deb_ev.dwDebugEventCode != EXIT_PROCESS_DEBUG_EVENT) {
-        const bool wait_success = WaitForDebugEvent(&deb_ev, INFINITE);
-        if (!wait_success) {
-            fmt::print(stderr, "error: WaitForDebugEvent failed ({})", GetLastError());
-            return;
-        }
-
-        switch (deb_ev.dwDebugEventCode) {
-        case OUTPUT_DEBUG_STRING_EVENT:
-        case CREATE_PROCESS_DEBUG_EVENT:
-        case CREATE_THREAD_DEBUG_EVENT:
-        case EXIT_PROCESS_DEBUG_EVENT:
-        case EXIT_THREAD_DEBUG_EVENT:
-        case LOAD_DLL_DEBUG_EVENT:
-        case RIP_EVENT:
-        case UNLOAD_DLL_DEBUG_EVENT:
-            // Continue on all other debug events
-            ContinueDebugEvent(deb_ev.dwProcessId, deb_ev.dwThreadId, DBG_CONTINUE);
-            break;
-        case EXCEPTION_DEBUG_EVENT:
-            EXCEPTION_RECORD& record = deb_ev.u.Exception.ExceptionRecord;
-
-            // We want to generate a crash dump if we are seeing the same exception again.
-            if (!deb_ev.u.Exception.dwFirstChance) {
-                fmt::print(stderr, "Creating MiniDump on ExceptionCode: 0x{:08x} {}\n",
-                           record.ExceptionCode, ExceptionName(record.ExceptionCode));
-                DumpFromDebugEvent(deb_ev, pi);
-            }
-
-            // Continue without handling the exception.
-            // Lets the debuggee use its own exception handler.
-            // - If one does not exist, we will see the exception once more where we make a minidump
-            //     for. Then when it reaches here again, yuzu will probably crash.
-            // - DBG_CONTINUE on an exception that the debuggee does not handle can set us up for an
-            //     infinite loop of exceptions.
-            ContinueDebugEvent(deb_ev.dwProcessId, deb_ev.dwThreadId, DBG_EXCEPTION_NOT_HANDLED);
-            break;
-        }
-    }
-}
-
-} // namespace MiniDump
--- a/src/yuzu/mini_dump.h
+++ b/src/yuzu/mini_dump.h
@ -1,19 +0,0 @@
-// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <windows.h>
-
-#include <dbghelp.h>
-
-namespace MiniDump {
-
-void CreateMiniDump(HANDLE process_handle, DWORD process_id, MINIDUMP_EXCEPTION_INFORMATION* info,
-                    EXCEPTION_POINTERS* pep);
-
-void DumpFromDebugEvent(DEBUG_EVENT& deb_ev, PROCESS_INFORMATION& pi);
-bool SpawnDebuggee(const char* arg0, PROCESS_INFORMATION& pi);
-void DebugDebuggee(PROCESS_INFORMATION& pi);
-
-} // namespace MiniDump
--- a/vcpkg.json
+++ b/vcpkg.json
@ -33,10 +33,6 @@
            "description": "Compile tests",
            "dependencies": [ "catch2" ]
        },
-        "dbghelp": {
-            "description": "Compile Windows crash dump (Minidump) support",
-            "dependencies": [ "dbghelp" ]
-        },
        "web-service": {
            "description": "Enable web services (telemetry, etc.)",
            "dependencies": [
Author	SHA1	Message	Date
yuzubot	7684f37daa	Android #118	2023-10-31 00:57:24 +00:00
liamwhite	c60204e255	Merge pull request #11922 from t895/simplify-card-layout android: Simplify game card layout	2023-10-30 15:32:45 -04:00
liamwhite	5e69769356	Merge pull request #11903 from Macj0rdan/scrollable-volume-button Implemented wheel event for volume control in VolumeButton	2023-10-30 15:32:39 -04:00
liamwhite	22cac3a5e3	Merge pull request #11728 from liushuyu/update-deps Update external dependencies	2023-10-30 15:32:31 -04:00
Charles Lombardo	e867768316	android: Simplify game card layout Using a material card view to shape the image was just a waste of a layout pass. A shapeable image view does what we want and does it faster.	2023-10-30 13:28:52 -04:00
liamwhite	07276cf62a	Merge pull request #11908 from t895/log-spam android: Fix URI parsing in native code	2023-10-30 13:28:11 -04:00
Charles Lombardo	f04bc172ae	android: FileUtil: Add option to suppress log for native exists() calls We often check for the existence of files that only exist in ExeFS so this can spam logcat with useless messages when scanning for games.	2023-10-30 11:38:10 -04:00
Charles Lombardo	585b6e9d46	android: Fix resolving android URIs in native code	2023-10-30 11:38:10 -04:00
Charles Lombardo	a9e29a3972	android: Refactor game metadata collection to new file This also removes irrelevant data and adds new information from/to the Game data class and RomMetadata struct	2023-10-30 11:38:09 -04:00
Charles Lombardo	1e61c3e1e7	android: Use header for EmulationSession	2023-10-30 11:28:23 -04:00
liamwhite	79d3cef8db	Merge pull request #11920 from Termynat0r/master Fix macOS build	2023-10-30 10:01:03 -04:00
liamwhite	3e0da4f698	Merge pull request #11916 from t895/focus-fix android: Release touch on input overlay when opening in-game menu	2023-10-30 09:59:53 -04:00
liamwhite	789c16305d	Merge pull request #11915 from t895/startup-freeze android: Move game deserialization to another thread	2023-10-30 09:59:45 -04:00
liamwhite	1836e62d33	Merge pull request #11910 from liamwhite/surface-lost-on-creation renderer_vulkan: ensure exception on surface loss	2023-10-30 09:59:37 -04:00
Termynat0r	0bbbe80f75	Fix macOS build Added missing preprocessor macros for macOS analog to linux and freebsd	2023-10-30 10:49:39 +01:00
liamwhite	eec3d356b6	Merge pull request #11689 from liamwhite/breakpad qt: implement automatic crash dump support	2023-10-29 23:41:13 -04:00
Charles Lombardo	2c1d850b46	android: Release touch on input overlay when opening in-game menu	2023-10-29 21:42:47 -04:00
Charles Lombardo	2581590023	android: Move game deserialization to another thread Deserializing games from the cache in shared preferences was done on the main thread and could cause a stutter on startup.	2023-10-29 21:29:32 -04:00
Liam	8427b9d49d	renderer_vulkan: ensure exception on surface loss	2023-10-29 15:31:05 -04:00
FrozenAra	0bb1c7c804	Implemented wheel event for volume control in VolumeButton	2023-10-29 20:29:17 +01:00
liushuyu	a065dcdcd9	externals/opus: use CMakeLists shipped with Opus itself	2023-10-22 14:21:33 -06:00
liushuyu	d6bd16b2c0	externals/libusb: remove the GUID override workaround ... ... on Windows MSVC, it seems to have been fixed	2023-10-21 22:29:32 -06:00
liushuyu	a49b146ccc	externals: update libusb to c060e9ce30ac2e3ffb49d94209c4dae77b6642f7 ... ... this fixes an issue when compiling with newer MSVC	2023-10-21 22:29:19 -06:00
liushuyu	fd9e157184	externals: update VulkanMemoryAllocator to 2f382df218d7e8516dee3b3caccb819a62b571a2	2023-10-21 22:29:19 -06:00
liushuyu	6cbd4020e8	externals: update Vulkan-Headers to 1.3.265	2023-10-21 22:29:19 -06:00
liushuyu	3558b236cd	externals: update ffmpeg to 9c1294eaddb88cb0e044c675ccae059a85fc9c6c ... to fix build with binutils 2.41+	2023-10-21 22:29:19 -06:00
liushuyu	48e82c4138	externals: update vcpkg to ef2eef17340f3fbd679327d286fad06dd6e838ed	2023-10-21 22:29:19 -06:00
liushuyu	9eb70aea1d	externals: update SDL to 2.28.4	2023-10-21 22:29:19 -06:00
liushuyu	0460fbacc9	externals: update cpp-jwt to 10ef5735d842b31025f1257ae78899f50a40fb14	2023-10-21 22:29:19 -06:00
liushuyu	c73297e840	externals: update cpp-httplib to 0.14.1	2023-10-21 22:29:19 -06:00
liushuyu	633d869ff4	externals: update libusb to 1.0.26	2023-10-21 22:29:19 -06:00
liushuyu	e03f86cc54	externals: update inih to r57	2023-10-21 22:29:19 -06:00
liushuyu	a0a3566977	externals: update opus to 1.4	2023-10-21 22:29:19 -06:00
Liam	d3997bad9b	qt: implement automatic crash dump support	2023-10-08 11:35:53 -04:00