config: Unify config handling under frontend_common

Replaces every way of handling config for each frontend with SimpleIni. frontend_common's Config class is at the center where it saves and loads all of the cross-platform settings and provides a set of pure virtual functions for platform specific settings.

As a result of making config handling platform specific, several parts had to be moved to each platform's own config class or to other parts. Default keys were put in platform specific config classes and translatable strings for Qt were moved to shared_translation. Default hotkeys, default_theme, window geometry, and qt metatypes were moved to uisettings. Additionally, to reduce dependence on Qt, QStrings were converted to std::strings where applicable.

3 files changed, 1147 insertions, 0 deletions

diff --git a/src/frontend_common/CMakeLists.txt b/src/frontend_common/CMakeLists.txt
new file mode 100644
index 000000000..1537271fc
--- /dev/null
+++ b/src/frontend_common/CMakeLists.txt
@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+add_library(frontend_common STATIC
+    config.cpp
+    config.h
+)
+
+create_target_directory_groups(frontend_common)
+target_link_libraries(frontend_common PUBLIC core SimpleIni PRIVATE common Boost::headers)
diff --git a/src/frontend_common/config.cpp b/src/frontend_common/config.cpp
new file mode 100644
index 000000000..d317d81fd
--- /dev/null
+++ b/src/frontend_common/config.cpp
@@ -0,0 +1,931 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <algorithm>
+#include <array>
+#include "common/fs/fs.h"
+#include "common/fs/path_util.h"
+#include "common/settings.h"
+#include "common/settings_common.h"
+#include "common/settings_enums.h"
+#include "config.h"
+#include "core/core.h"
+#include "core/hle/service/acc/profile_manager.h"
+#include "core/hle/service/hid/controllers/npad.h"
+#include "network/network.h"
+
+#include <boost/algorithm/string/replace.hpp>
+
+namespace FS = Common::FS;
+
+Config::Config(const ConfigType config_type)
+    : type(config_type), global{config_type == ConfigType::GlobalConfig} {}
+
+void Config::Initialize(const std::string& config_name) {
+    const std::filesystem::path fs_config_loc = FS::GetYuzuPath(FS::YuzuPath::ConfigDir);
+    const auto config_file = fmt::format("{}.ini", config_name);
+
+    switch (type) {
+    case ConfigType::GlobalConfig:
+        config_loc = FS::PathToUTF8String(fs_config_loc / config_file);
+        void(FS::CreateParentDir(config_loc));
+        SetUpIni();
+        Reload();
+        break;
+    case ConfigType::PerGameConfig:
+        config_loc = FS::PathToUTF8String(fs_config_loc / "custom" / FS::ToU8String(config_file));
+        void(FS::CreateParentDir(config_loc));
+        SetUpIni();
+        Reload();
+        break;
+    case ConfigType::InputProfile:
+        config_loc = FS::PathToUTF8String(fs_config_loc / "input" / config_file);
+        void(FS::CreateParentDir(config_loc));
+        SetUpIni();
+        break;
+    }
+}
+
+void Config::Initialize(const std::optional<std::string> config_path) {
+    const std::filesystem::path default_sdl_config_path =
+        FS::GetYuzuPath(FS::YuzuPath::ConfigDir) / "sdl2-config.ini";
+    config_loc = config_path.value_or(FS::PathToUTF8String(default_sdl_config_path));
+    void(FS::CreateParentDir(config_loc));
+    SetUpIni();
+    Reload();
+}
+
+void Config::WriteToIni() const {
+    if (const SI_Error rc = config->SaveFile(config_loc.c_str()); rc < 0) {
+        LOG_ERROR(Frontend, "Config file could not be saved!");
+    }
+}
+
+void Config::SetUpIni() {
+    config = std::make_unique<CSimpleIniA>();
+    config->SetUnicode(true);
+    config->SetSpaces(false);
+    config->LoadFile(config_loc.c_str());
+}
+
+bool Config::IsCustomConfig() const {
+    return type == ConfigType::PerGameConfig;
+}
+
+void Config::ReadPlayerValues(const std::size_t player_index) {
+    std::string player_prefix;
+    if (type != ConfigType::InputProfile) {
+        player_prefix.append("player_").append(ToString(player_index)).append("_");
+    }
+
+    auto& player = Settings::values.players.GetValue()[player_index];
+    if (IsCustomConfig()) {
+        const auto profile_name =
+            ReadStringSetting(std::string(player_prefix).append("profile_name"));
+        if (profile_name.empty()) {
+            // Use the global input config
+            player = Settings::values.players.GetValue(true)[player_index];
+            return;
+        }
+        player.profile_name = profile_name;
+    }
+
+    if (player_prefix.empty() && Settings::IsConfiguringGlobal()) {
+        const auto controller = static_cast<Settings::ControllerType>(
+            ReadIntegerSetting(std::string(player_prefix).append("type"),
+                               static_cast<u8>(Settings::ControllerType::ProController)));
+
+        if (controller == Settings::ControllerType::LeftJoycon ||
+            controller == Settings::ControllerType::RightJoycon) {
+            player.controller_type = controller;
+        }
+    } else {
+        std::string connected_key = player_prefix;
+        player.connected = ReadBooleanSetting(connected_key.append("connected"),
+                                              std::make_optional(player_index == 0));
+
+        player.controller_type = static_cast<Settings::ControllerType>(
+            ReadIntegerSetting(std::string(player_prefix).append("type"),
+                               static_cast<u8>(Settings::ControllerType::ProController)));
+
+        player.vibration_enabled = ReadBooleanSetting(
+            std::string(player_prefix).append("vibration_enabled"), std::make_optional(true));
+
+        player.vibration_strength = static_cast<int>(
+            ReadIntegerSetting(std::string(player_prefix).append("vibration_strength"), 100));
+
+        player.body_color_left = static_cast<u32>(ReadIntegerSetting(
+            std::string(player_prefix).append("body_color_left"), Settings::JOYCON_BODY_NEON_BLUE));
+        player.body_color_right = static_cast<u32>(ReadIntegerSetting(
+            std::string(player_prefix).append("body_color_right"), Settings::JOYCON_BODY_NEON_RED));
+        player.button_color_left = static_cast<u32>(
+            ReadIntegerSetting(std::string(player_prefix).append("button_color_left"),
+                               Settings::JOYCON_BUTTONS_NEON_BLUE));
+        player.button_color_right = static_cast<u32>(
+            ReadIntegerSetting(std::string(player_prefix).append("button_color_right"),
+                               Settings::JOYCON_BUTTONS_NEON_RED));
+    }
+}
+
+void Config::ReadTouchscreenValues() {
+    Settings::values.touchscreen.enabled =
+        ReadBooleanSetting(std::string("touchscreen_enabled"), std::make_optional(true));
+    Settings::values.touchscreen.rotation_angle =
+        static_cast<u32>(ReadIntegerSetting(std::string("touchscreen_angle"), 0));
+    Settings::values.touchscreen.diameter_x =
+        static_cast<u32>(ReadIntegerSetting(std::string("touchscreen_diameter_x"), 15));
+    Settings::values.touchscreen.diameter_y =
+        static_cast<u32>(ReadIntegerSetting(std::string("touchscreen_diameter_y"), 15));
+}
+
+void Config::ReadAudioValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Audio));
+
+    ReadCategory(Settings::Category::Audio);
+    ReadCategory(Settings::Category::UiAudio);
+
+    EndGroup();
+}
+
+void Config::ReadControlValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    ReadCategory(Settings::Category::Controls);
+
+    Settings::values.players.SetGlobal(!IsCustomConfig());
+    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
+        ReadPlayerValues(p);
+    }
+
+    // Disable docked mode if handheld is selected
+    const auto controller_type = Settings::values.players.GetValue()[0].controller_type;
+    if (controller_type == Settings::ControllerType::Handheld) {
+        Settings::values.use_docked_mode.SetGlobal(!IsCustomConfig());
+        Settings::values.use_docked_mode.SetValue(Settings::ConsoleMode::Handheld);
+    }
+
+    if (IsCustomConfig()) {
+        EndGroup();
+        return;
+    }
+    ReadTouchscreenValues();
+    ReadMotionTouchValues();
+
+    EndGroup();
+}
+
+void Config::ReadMotionTouchValues() {
+    int num_touch_from_button_maps = BeginArray(std::string("touch_from_button_maps"));
+
+    if (num_touch_from_button_maps > 0) {
+        for (int i = 0; i < num_touch_from_button_maps; ++i) {
+            SetArrayIndex(i);
+
+            Settings::TouchFromButtonMap map;
+            map.name = ReadStringSetting(std::string("name"), std::string("default"));
+
+            const int num_touch_maps = BeginArray(std::string("entries"));
+            map.buttons.reserve(num_touch_maps);
+            for (int j = 0; j < num_touch_maps; j++) {
+                SetArrayIndex(j);
+                std::string touch_mapping = ReadStringSetting(std::string("bind"));
+                map.buttons.emplace_back(std::move(touch_mapping));
+            }
+            EndArray(); // entries
+            Settings::values.touch_from_button_maps.emplace_back(std::move(map));
+        }
+    } else {
+        Settings::values.touch_from_button_maps.emplace_back(
+            Settings::TouchFromButtonMap{"default", {}});
+        num_touch_from_button_maps = 1;
+    }
+    EndArray(); // touch_from_button_maps
+
+    Settings::values.touch_from_button_map_index = std::clamp(
+        Settings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1);
+}
+
+void Config::ReadCoreValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Core));
+
+    ReadCategory(Settings::Category::Core);
+
+    EndGroup();
+}
+
+void Config::ReadDataStorageValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::DataStorage));
+
+    FS::SetYuzuPath(FS::YuzuPath::NANDDir, ReadStringSetting(std::string("nand_directory")));
+    FS::SetYuzuPath(FS::YuzuPath::SDMCDir, ReadStringSetting(std::string("sdmc_directory")));
+    FS::SetYuzuPath(FS::YuzuPath::LoadDir, ReadStringSetting(std::string("load_directory")));
+    FS::SetYuzuPath(FS::YuzuPath::DumpDir, ReadStringSetting(std::string("dump_directory")));
+    FS::SetYuzuPath(FS::YuzuPath::TASDir, ReadStringSetting(std::string("tas_directory")));
+
+    ReadCategory(Settings::Category::DataStorage);
+
+    EndGroup();
+}
+
+void Config::ReadDebuggingValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Debugging));
+
+    // Intentionally not using the QT default setting as this is intended to be changed in the ini
+    Settings::values.record_frame_times =
+        ReadBooleanSetting(std::string("record_frame_times"), std::make_optional(false));
+
+    ReadCategory(Settings::Category::Debugging);
+    ReadCategory(Settings::Category::DebuggingGraphics);
+
+    EndGroup();
+}
+
+void Config::ReadServiceValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Services));
+
+    ReadCategory(Settings::Category::Services);
+
+    EndGroup();
+}
+
+void Config::ReadDisabledAddOnValues() {
+    // Custom config section
+    BeginGroup(std::string("DisabledAddOns"));
+
+    const int size = BeginArray(std::string(""));
+    for (int i = 0; i < size; ++i) {
+        SetArrayIndex(i);
+        const auto title_id = ReadIntegerSetting(std::string("title_id"), 0);
+        std::vector<std::string> out;
+        const int d_size = BeginArray("disabled");
+        for (int j = 0; j < d_size; ++j) {
+            SetArrayIndex(j);
+            out.push_back(ReadStringSetting(std::string("d"), std::string("")));
+        }
+        EndArray(); // d
+        Settings::values.disabled_addons.insert_or_assign(title_id, out);
+    }
+    EndArray(); // Base disabled addons array - Has no base key
+
+    EndGroup();
+}
+
+void Config::ReadMiscellaneousValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Miscellaneous));
+
+    ReadCategory(Settings::Category::Miscellaneous);
+
+    EndGroup();
+}
+
+void Config::ReadCpuValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Cpu));
+
+    ReadCategory(Settings::Category::Cpu);
+    ReadCategory(Settings::Category::CpuDebug);
+    ReadCategory(Settings::Category::CpuUnsafe);
+
+    EndGroup();
+}
+
+void Config::ReadRendererValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Renderer));
+
+    ReadCategory(Settings::Category::Renderer);
+    ReadCategory(Settings::Category::RendererAdvanced);
+    ReadCategory(Settings::Category::RendererDebug);
+
+    EndGroup();
+}
+
+void Config::ReadScreenshotValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Screenshots));
+
+    ReadCategory(Settings::Category::Screenshots);
+    FS::SetYuzuPath(FS::YuzuPath::ScreenshotsDir,
+                    ReadStringSetting(std::string("screenshot_path"),
+                                      FS::GetYuzuPathString(FS::YuzuPath::ScreenshotsDir)));
+
+    EndGroup();
+}
+
+void Config::ReadSystemValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::System));
+
+    ReadCategory(Settings::Category::System);
+    ReadCategory(Settings::Category::SystemAudio);
+
+    EndGroup();
+}
+
+void Config::ReadWebServiceValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::WebService));
+
+    ReadCategory(Settings::Category::WebService);
+
+    EndGroup();
+}
+
+void Config::ReadNetworkValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Services));
+
+    ReadCategory(Settings::Category::Network);
+
+    EndGroup();
+}
+
+void Config::ReadValues() {
+    if (global) {
+        ReadDataStorageValues();
+        ReadDebuggingValues();
+        ReadDisabledAddOnValues();
+        ReadNetworkValues();
+        ReadServiceValues();
+        ReadWebServiceValues();
+        ReadMiscellaneousValues();
+    }
+    ReadControlValues();
+    ReadCoreValues();
+    ReadCpuValues();
+    ReadRendererValues();
+    ReadAudioValues();
+    ReadSystemValues();
+}
+
+void Config::SavePlayerValues(const std::size_t player_index) {
+    std::string player_prefix;
+    if (type != ConfigType::InputProfile) {
+        player_prefix = std::string("player_").append(ToString(player_index)).append("_");
+    }
+
+    const auto& player = Settings::values.players.GetValue()[player_index];
+    if (IsCustomConfig()) {
+        if (player.profile_name.empty()) {
+            // No custom profile selected
+            return;
+        }
+        WriteSetting(std::string(player_prefix).append("profile_name"), player.profile_name,
+                     std::make_optional(std::string("")));
+    }
+
+    WriteSetting(std::string(player_prefix).append("type"), static_cast<u8>(player.controller_type),
+                 std::make_optional(static_cast<u8>(Settings::ControllerType::ProController)));
+
+    if (!player_prefix.empty() || !Settings::IsConfiguringGlobal()) {
+        WriteSetting(std::string(player_prefix).append("connected"), player.connected,
+                     std::make_optional(player_index == 0));
+        WriteSetting(std::string(player_prefix).append("vibration_enabled"),
+                     player.vibration_enabled, std::make_optional(true));
+        WriteSetting(std::string(player_prefix).append("vibration_strength"),
+                     player.vibration_strength, std::make_optional(100));
+        WriteSetting(std::string(player_prefix).append("body_color_left"), player.body_color_left,
+                     std::make_optional(Settings::JOYCON_BODY_NEON_BLUE));
+        WriteSetting(std::string(player_prefix).append("body_color_right"), player.body_color_right,
+                     std::make_optional(Settings::JOYCON_BODY_NEON_RED));
+        WriteSetting(std::string(player_prefix).append("button_color_left"),
+                     player.button_color_left,
+                     std::make_optional(Settings::JOYCON_BUTTONS_NEON_BLUE));
+        WriteSetting(std::string(player_prefix).append("button_color_right"),
+                     player.button_color_right,
+                     std::make_optional(Settings::JOYCON_BUTTONS_NEON_RED));
+    }
+}
+
+void Config::SaveTouchscreenValues() {
+    const auto& touchscreen = Settings::values.touchscreen;
+
+    WriteSetting(std::string("touchscreen_enabled"), touchscreen.enabled, std::make_optional(true));
+
+    WriteSetting(std::string("touchscreen_angle"), touchscreen.rotation_angle,
+                 std::make_optional(static_cast<u32>(0)));
+    WriteSetting(std::string("touchscreen_diameter_x"), touchscreen.diameter_x,
+                 std::make_optional(static_cast<u32>(15)));
+    WriteSetting(std::string("touchscreen_diameter_y"), touchscreen.diameter_y,
+                 std::make_optional(static_cast<u32>(15)));
+}
+
+void Config::SaveMotionTouchValues() {
+    BeginArray(std::string("touch_from_button_maps"));
+    for (std::size_t p = 0; p < Settings::values.touch_from_button_maps.size(); ++p) {
+        SetArrayIndex(static_cast<int>(p));
+        WriteSetting(std::string("name"), Settings::values.touch_from_button_maps[p].name,
+                     std::make_optional(std::string("default")));
+
+        BeginArray(std::string("entries"));
+        for (std::size_t q = 0; q < Settings::values.touch_from_button_maps[p].buttons.size();
+             ++q) {
+            SetArrayIndex(static_cast<int>(q));
+            WriteSetting(std::string("bind"),
+                         Settings::values.touch_from_button_maps[p].buttons[q]);
+        }
+        EndArray(); // entries
+    }
+    EndArray(); // touch_from_button_maps
+}
+
+void Config::SaveValues() {
+    if (global) {
+        SaveDataStorageValues();
+        SaveDebuggingValues();
+        SaveDisabledAddOnValues();
+        SaveNetworkValues();
+        SaveWebServiceValues();
+        SaveMiscellaneousValues();
+    }
+    SaveControlValues();
+    SaveCoreValues();
+    SaveCpuValues();
+    SaveRendererValues();
+    SaveAudioValues();
+    SaveSystemValues();
+
+    WriteToIni();
+}
+
+void Config::SaveAudioValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Audio));
+
+    WriteCategory(Settings::Category::Audio);
+    WriteCategory(Settings::Category::UiAudio);
+
+    EndGroup();
+}
+
+void Config::SaveControlValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
+
+    WriteCategory(Settings::Category::Controls);
+
+    Settings::values.players.SetGlobal(!IsCustomConfig());
+    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
+        SavePlayerValues(p);
+    }
+    if (IsCustomConfig()) {
+        EndGroup();
+        return;
+    }
+    SaveTouchscreenValues();
+    SaveMotionTouchValues();
+
+    EndGroup();
+}
+
+void Config::SaveCoreValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Core));
+
+    WriteCategory(Settings::Category::Core);
+
+    EndGroup();
+}
+
+void Config::SaveDataStorageValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::DataStorage));
+
+    WriteSetting(std::string("nand_directory"), FS::GetYuzuPathString(FS::YuzuPath::NANDDir),
+                 std::make_optional(FS::GetYuzuPathString(FS::YuzuPath::NANDDir)));
+    WriteSetting(std::string("sdmc_directory"), FS::GetYuzuPathString(FS::YuzuPath::SDMCDir),
+                 std::make_optional(FS::GetYuzuPathString(FS::YuzuPath::SDMCDir)));
+    WriteSetting(std::string("load_directory"), FS::GetYuzuPathString(FS::YuzuPath::LoadDir),
+                 std::make_optional(FS::GetYuzuPathString(FS::YuzuPath::LoadDir)));
+    WriteSetting(std::string("dump_directory"), FS::GetYuzuPathString(FS::YuzuPath::DumpDir),
+                 std::make_optional(FS::GetYuzuPathString(FS::YuzuPath::DumpDir)));
+    WriteSetting(std::string("tas_directory"), FS::GetYuzuPathString(FS::YuzuPath::TASDir),
+                 std::make_optional(FS::GetYuzuPathString(FS::YuzuPath::TASDir)));
+
+    WriteCategory(Settings::Category::DataStorage);
+
+    EndGroup();
+}
+
+void Config::SaveDebuggingValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Debugging));
+
+    // Intentionally not using the QT default setting as this is intended to be changed in the ini
+    WriteSetting(std::string("record_frame_times"), Settings::values.record_frame_times);
+
+    WriteCategory(Settings::Category::Debugging);
+    WriteCategory(Settings::Category::DebuggingGraphics);
+
+    EndGroup();
+}
+
+void Config::SaveNetworkValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Services));
+
+    WriteCategory(Settings::Category::Network);
+
+    EndGroup();
+}
+
+void Config::SaveDisabledAddOnValues() {
+    // Custom config section
+    BeginGroup(std::string("DisabledAddOns"));
+
+    int i = 0;
+    BeginArray(std::string(""));
+    for (const auto& elem : Settings::values.disabled_addons) {
+        SetArrayIndex(i);
+        WriteSetting(std::string("title_id"), elem.first, std::make_optional(static_cast<u64>(0)));
+        BeginArray(std::string("disabled"));
+        for (std::size_t j = 0; j < elem.second.size(); ++j) {
+            SetArrayIndex(static_cast<int>(j));
+            WriteSetting(std::string("d"), elem.second[j], std::make_optional(std::string("")));
+        }
+        EndArray(); // disabled
+        ++i;
+    }
+    EndArray(); // Base disabled addons array - Has no base key
+
+    EndGroup();
+}
+
+void Config::SaveMiscellaneousValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Miscellaneous));
+
+    WriteCategory(Settings::Category::Miscellaneous);
+
+    EndGroup();
+}
+
+void Config::SaveCpuValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Cpu));
+
+    WriteCategory(Settings::Category::Cpu);
+    WriteCategory(Settings::Category::CpuDebug);
+    WriteCategory(Settings::Category::CpuUnsafe);
+
+    EndGroup();
+}
+
+void Config::SaveRendererValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Renderer));
+
+    WriteCategory(Settings::Category::Renderer);
+    WriteCategory(Settings::Category::RendererAdvanced);
+    WriteCategory(Settings::Category::RendererDebug);
+
+    EndGroup();
+}
+
+void Config::SaveScreenshotValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Screenshots));
+
+    WriteSetting(std::string("screenshot_path"),
+                 FS::GetYuzuPathString(FS::YuzuPath::ScreenshotsDir));
+    WriteCategory(Settings::Category::Screenshots);
+
+    EndGroup();
+}
+
+void Config::SaveSystemValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::System));
+
+    WriteCategory(Settings::Category::System);
+    WriteCategory(Settings::Category::SystemAudio);
+
+    EndGroup();
+}
+
+void Config::SaveWebServiceValues() {
+    BeginGroup(Settings::TranslateCategory(Settings::Category::WebService));
+
+    WriteCategory(Settings::Category::WebService);
+
+    EndGroup();
+}
+
+bool Config::ReadBooleanSetting(const std::string& key, const std::optional<bool> default_value) {
+    std::string full_key = GetFullKey(key, false);
+    if (!default_value.has_value()) {
+        return config->GetBoolValue(GetSection().c_str(), full_key.c_str(), false);
+    }
+
+    if (config->GetBoolValue(GetSection().c_str(),
+                             std::string(full_key).append("\\default").c_str(), false)) {
+        return static_cast<bool>(default_value.value());
+    } else {
+        return config->GetBoolValue(GetSection().c_str(), full_key.c_str(),
+                                    static_cast<bool>(default_value.value()));
+    }
+}
+
+s64 Config::ReadIntegerSetting(const std::string& key, const std::optional<s64> default_value) {
+    std::string full_key = GetFullKey(key, false);
+    if (!default_value.has_value()) {
+        try {
+            return std::stoll(
+                std::string(config->GetValue(GetSection().c_str(), full_key.c_str(), "0")));
+        } catch (...) {
+            return 0;
+        }
+    }
+
+    s64 result = 0;
+    if (config->GetBoolValue(GetSection().c_str(),
+                             std::string(full_key).append("\\default").c_str(), true)) {
+        result = default_value.value();
+    } else {
+        try {
+            result = std::stoll(std::string(config->GetValue(
+                GetSection().c_str(), full_key.c_str(), ToString(default_value.value()).c_str())));
+        } catch (...) {
+            result = default_value.value();
+        }
+    }
+    return result;
+}
+
+double Config::ReadDoubleSetting(const std::string& key,
+                                 const std::optional<double> default_value) {
+    std::string full_key = GetFullKey(key, false);
+    if (!default_value.has_value()) {
+        return config->GetDoubleValue(GetSection().c_str(), full_key.c_str(), 0);
+    }
+
+    double result;
+    if (config->GetBoolValue(GetSection().c_str(),
+                             std::string(full_key).append("\\default").c_str(), true)) {
+        result = default_value.value();
+    } else {
+        result =
+            config->GetDoubleValue(GetSection().c_str(), full_key.c_str(), default_value.value());
+    }
+    return result;
+}
+
+std::string Config::ReadStringSetting(const std::string& key,
+                                      const std::optional<std::string> default_value) {
+    std::string result;
+    std::string full_key = GetFullKey(key, false);
+    if (!default_value.has_value()) {
+        result = config->GetValue(GetSection().c_str(), full_key.c_str(), "");
+        boost::replace_all(result, "\"", "");
+        return result;
+    }
+
+    if (config->GetBoolValue(GetSection().c_str(),
+                             std::string(full_key).append("\\default").c_str(), true)) {
+        result = default_value.value();
+    } else {
+        result =
+            config->GetValue(GetSection().c_str(), full_key.c_str(), default_value.value().c_str());
+    }
+    boost::replace_all(result, "\"", "");
+    boost::replace_all(result, "//", "/");
+    return result;
+}
+
+bool Config::Exists(const std::string& section, const std::string& key) const {
+    const std::string value = config->GetValue(section.c_str(), key.c_str(), "");
+    return !value.empty();
+}
+
+template <typename Type>
+void Config::WriteSetting(const std::string& key, const Type& value,
+                          const std::optional<Type>& default_value,
+                          const std::optional<bool>& use_global) {
+    std::string full_key = GetFullKey(key, false);
+
+    std::string saved_value;
+    std::string string_default;
+    if constexpr (std::is_same_v<Type, std::string>) {
+        saved_value.append(AdjustOutputString(value));
+        if (default_value.has_value()) {
+            string_default.append(AdjustOutputString(default_value.value()));
+        }
+    } else {
+        saved_value.append(AdjustOutputString(ToString(value)));
+        if (default_value.has_value()) {
+            string_default.append(ToString(default_value.value()));
+        }
+    }
+
+    if (default_value.has_value() && use_global.has_value()) {
+        if (!global) {
+            WriteSettingInternal(std::string(full_key).append("\\global"),
+                                 ToString(use_global.value()));
+        }
+        if (global || use_global.value() == false) {
+            WriteSettingInternal(std::string(full_key).append("\\default"),
+                                 ToString(string_default == saved_value));
+            WriteSettingInternal(full_key, saved_value);
+        }
+    } else if (default_value.has_value() && !use_global.has_value()) {
+        WriteSettingInternal(std::string(full_key).append("\\default"),
+                             ToString(string_default == saved_value));
+        WriteSettingInternal(full_key, saved_value);
+    } else {
+        WriteSettingInternal(full_key, saved_value);
+    }
+}
+
+void Config::WriteSettingInternal(const std::string& key, const std::string& value) {
+    config->SetValue(GetSection().c_str(), key.c_str(), value.c_str());
+}
+
+void Config::Reload() {
+    ReadValues();
+    // To apply default value changes
+    SaveValues();
+}
+
+void Config::Save() {
+    SaveValues();
+}
+
+void Config::ClearControlPlayerValues() const {
+    // If key is an empty string, all keys in the current group() are removed.
+    const char* section = Settings::TranslateCategory(Settings::Category::Controls);
+    CSimpleIniA::TNamesDepend keys;
+    config->GetAllKeys(section, keys);
+    for (const auto& key : keys) {
+        if (std::string(config->GetValue(section, key.pItem)).empty()) {
+            config->Delete(section, key.pItem);
+        }
+    }
+}
+
+const std::string& Config::GetConfigFilePath() const {
+    return config_loc;
+}
+
+void Config::ReadCategory(const Settings::Category category) {
+    const auto& settings = FindRelevantList(category);
+    std::ranges::for_each(settings, [&](const auto& setting) { ReadSettingGeneric(setting); });
+}
+
+void Config::WriteCategory(const Settings::Category category) {
+    const auto& settings = FindRelevantList(category);
+    std::ranges::for_each(settings, [&](const auto& setting) { WriteSettingGeneric(setting); });
+}
+
+void Config::ReadSettingGeneric(Settings::BasicSetting* const setting) {
+    if (!setting->Save() || (!setting->Switchable() && !global)) {
+        return;
+    }
+
+    const std::string key = AdjustKey(setting->GetLabel());
+    const std::string default_value(setting->DefaultToString());
+
+    bool use_global = true;
+    if (setting->Switchable() && !global) {
+        use_global =
+            ReadBooleanSetting(std::string(key).append("\\use_global"), std::make_optional(true));
+        setting->SetGlobal(use_global);
+    }
+
+    if (global || !use_global) {
+        const bool is_default =
+            ReadBooleanSetting(std::string(key).append("\\default"), std::make_optional(true));
+        if (!is_default) {
+            const std::string setting_string = ReadStringSetting(key, default_value);
+            setting->LoadString(setting_string);
+        } else {
+            // Empty string resets the Setting to default
+            setting->LoadString("");
+        }
+    }
+}
+
+void Config::WriteSettingGeneric(const Settings::BasicSetting* const setting) {
+    if (!setting->Save()) {
+        return;
+    }
+
+    std::string key = AdjustKey(setting->GetLabel());
+    if (setting->Switchable()) {
+        if (!global) {
+            WriteSetting(std::string(key).append("\\use_global"), setting->UsingGlobal());
+        }
+        if (global || !setting->UsingGlobal()) {
+            WriteSetting(std::string(key).append("\\default"),
+                         setting->ToString() == setting->DefaultToString());
+            WriteSetting(key, setting->ToString());
+        }
+    } else if (global) {
+        WriteSetting(std::string(key).append("\\default"),
+                     setting->ToString() == setting->DefaultToString());
+        WriteSetting(key, setting->ToString());
+    }
+}
+
+void Config::BeginGroup(const std::string& group) {
+    // You can't begin a group while reading/writing from a config array
+    ASSERT(array_stack.empty());
+
+    key_stack.push_back(AdjustKey(group));
+}
+
+void Config::EndGroup() {
+    // You can't end a group if you haven't started one yet
+    ASSERT(!key_stack.empty());
+
+    // You can't end a group when reading/writing from a config array
+    ASSERT(array_stack.empty());
+
+    key_stack.pop_back();
+}
+
+std::string Config::GetSection() {
+    if (key_stack.empty()) {
+        return std::string{""};
+    }
+
+    return key_stack.front();
+}
+
+std::string Config::GetGroup() const {
+    if (key_stack.size() <= 1) {
+        return std::string{""};
+    }
+
+    std::string key;
+    for (size_t i = 1; i < key_stack.size(); ++i) {
+        key.append(key_stack[i]).append("\\");
+    }
+    return key;
+}
+
+std::string Config::AdjustKey(const std::string& key) {
+    std::string adjusted_key(key);
+    boost::replace_all(adjusted_key, "/", "\\");
+    boost::replace_all(adjusted_key, " ", "%20");
+    return adjusted_key;
+}
+
+std::string Config::AdjustOutputString(const std::string& string) {
+    std::string adjusted_string(string);
+    boost::replace_all(adjusted_string, "\\", "/");
+    boost::replace_all(adjusted_string, "//", "/");
+
+    // Needed for backwards compatibility with QSettings deserialization
+    for (const auto& special_character : special_characters) {
+        if (adjusted_string.find(special_character) != std::string::npos) {
+            adjusted_string.insert(0, "\"");
+            adjusted_string.append("\"");
+            break;
+        }
+    }
+    return adjusted_string;
+}
+
+std::string Config::GetFullKey(const std::string& key, bool skipArrayIndex) {
+    if (array_stack.empty()) {
+        return std::string(GetGroup()).append(AdjustKey(key));
+    }
+
+    std::string array_key;
+    for (size_t i = 0; i < array_stack.size(); ++i) {
+        if (!array_stack[i].name.empty()) {
+            array_key.append(array_stack[i].name).append("\\");
+        }
+
+        if (!skipArrayIndex || (array_stack.size() - 1 != i && array_stack.size() > 1)) {
+            array_key.append(ToString(array_stack[i].index)).append("\\");
+        }
+    }
+    std::string final_key = std::string(GetGroup()).append(array_key).append(AdjustKey(key));
+    return final_key;
+}
+
+int Config::BeginArray(const std::string& array) {
+    array_stack.push_back(ConfigArray{AdjustKey(array), 0, 0});
+    const int size = config->GetLongValue(GetSection().c_str(),
+                                          GetFullKey(std::string("size"), true).c_str(), 0);
+    array_stack.back().size = size;
+    return size;
+}
+
+void Config::EndArray() {
+    // You can't end a config array before starting one
+    ASSERT(!array_stack.empty());
+
+    // Write out the size to config
+    if (key_stack.size() == 1 && array_stack.back().name.empty()) {
+        // Edge-case where the first array created doesn't have a name
+        config->SetValue(GetSection().c_str(), std::string("size").c_str(),
+                         ToString(array_stack.back().size).c_str());
+    } else {
+        const auto key = GetFullKey(std::string("size"), true);
+        config->SetValue(GetSection().c_str(), key.c_str(),
+                         ToString(array_stack.back().size).c_str());
+    }
+
+    array_stack.pop_back();
+}
+
+void Config::SetArrayIndex(const int index) {
+    // You can't set the array index if you haven't started one yet
+    ASSERT(!array_stack.empty());
+
+    const int array_index = index + 1;
+
+    // You can't exceed the known max size of the array by more than 1
+    ASSERT(array_stack.front().size + 1 >= array_index);
+
+    // Change the config array size to the current index since you may want
+    // to reduce the number of elements that you read back from the config
+    // in the future.
+    array_stack.back().size = array_index;
+    array_stack.back().index = array_index;
+}
diff --git a/src/frontend_common/config.h b/src/frontend_common/config.h
new file mode 100644
index 000000000..f741aa8bb
--- /dev/null
+++ b/src/frontend_common/config.h
@@ -0,0 +1,206 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include "common/settings.h"
+
+#include <SimpleIni.h>
+#include <boost/algorithm/string/replace.hpp>
+
+// Workaround for conflicting definition in libloaderapi.h caused by SimpleIni
+#undef LoadString
+#undef CreateFile
+#undef DeleteFile
+#undef CopyFile
+#undef CreateDirectory
+#undef MoveFile
+
+namespace Core {
+class System;
+}
+
+class Config {
+public:
+    enum class ConfigType {
+        GlobalConfig,
+        PerGameConfig,
+        InputProfile,
+    };
+
+    virtual ~Config() = default;
+
+    void ClearControlPlayerValues() const;
+
+    [[nodiscard]] const std::string& GetConfigFilePath() const;
+
+    [[nodiscard]] bool Exists(const std::string& section, const std::string& key) const;
+
+protected:
+    explicit Config(ConfigType config_type = ConfigType::GlobalConfig);
+
+    void Initialize(const std::string& config_name = "config");
+    void Initialize(std::optional<std::string> config_path);
+
+    void WriteToIni() const;
+
+    void SetUpIni();
+    [[nodiscard]] bool IsCustomConfig() const;
+
+    void Reload();
+    void Save();
+
+    /**
+     * Derived config classes must implement this so they can reload all platform-specific
+     * values and global ones.
+     */
+    virtual void ReloadAllValues() = 0;
+
+    /**
+     * Derived config classes must implement this so they can save all platform-specific
+     * and global values.
+     */
+    virtual void SaveAllValues() = 0;
+
+    void ReadValues();
+    void ReadPlayerValues(std::size_t player_index);
+
+    void ReadTouchscreenValues();
+    void ReadMotionTouchValues();
+
+    // Read functions bases off the respective config section names.
+    void ReadAudioValues();
+    void ReadControlValues();
+    void ReadCoreValues();
+    void ReadDataStorageValues();
+    void ReadDebuggingValues();
+    void ReadServiceValues();
+    void ReadDisabledAddOnValues();
+    void ReadMiscellaneousValues();
+    void ReadCpuValues();
+    void ReadRendererValues();
+    void ReadScreenshotValues();
+    void ReadSystemValues();
+    void ReadWebServiceValues();
+    void ReadNetworkValues();
+
+    // Read platform specific sections
+    virtual void ReadHidbusValues() = 0;
+    virtual void ReadDebugControlValues() = 0;
+    virtual void ReadPathValues() = 0;
+    virtual void ReadShortcutValues() = 0;
+    virtual void ReadUIValues() = 0;
+    virtual void ReadUIGamelistValues() = 0;
+    virtual void ReadUILayoutValues() = 0;
+    virtual void ReadMultiplayerValues() = 0;
+
+    void SaveValues();
+    void SavePlayerValues(std::size_t player_index);
+    void SaveTouchscreenValues();
+    void SaveMotionTouchValues();
+
+    // Save functions based off the respective config section names.
+    void SaveAudioValues();
+    void SaveControlValues();
+    void SaveCoreValues();
+    void SaveDataStorageValues();
+    void SaveDebuggingValues();
+    void SaveNetworkValues();
+    void SaveDisabledAddOnValues();
+    void SaveMiscellaneousValues();
+    void SaveCpuValues();
+    void SaveRendererValues();
+    void SaveScreenshotValues();
+    void SaveSystemValues();
+    void SaveWebServiceValues();
+
+    // Save platform specific sections
+    virtual void SaveHidbusValues() = 0;
+    virtual void SaveDebugControlValues() = 0;
+    virtual void SavePathValues() = 0;
+    virtual void SaveShortcutValues() = 0;
+    virtual void SaveUIValues() = 0;
+    virtual void SaveUIGamelistValues() = 0;
+    virtual void SaveUILayoutValues() = 0;
+    virtual void SaveMultiplayerValues() = 0;
+
+    virtual std::vector<Settings::BasicSetting*>& FindRelevantList(Settings::Category category) = 0;
+
+    /**
+     * Reads a setting from the qt_config.
+     *
+     * @param key The setting's identifier
+     * @param default_value The value to use when the setting is not already present in the config
+     */
+    bool ReadBooleanSetting(const std::string& key,
+                            std::optional<bool> default_value = std::nullopt);
+    s64 ReadIntegerSetting(const std::string& key, std::optional<s64> default_value = std::nullopt);
+    double ReadDoubleSetting(const std::string& key,
+                             std::optional<double> default_value = std::nullopt);
+    std::string ReadStringSetting(const std::string& key,
+                                  std::optional<std::string> default_value = std::nullopt);
+
+    /**
+     * Writes a setting to the qt_config.
+     *
+     * @param key The setting's idetentifier
+     * @param value Value of the setting
+     * @param default_value Default of the setting if not present in config
+     * @param use_global Specifies if the custom or global config should be in use, for custom
+     * configs
+     */
+    template <typename Type = int>
+    void WriteSetting(const std::string& key, const Type& value,
+                      const std::optional<Type>& default_value = std::nullopt,
+                      const std::optional<bool>& use_global = std::nullopt);
+    void WriteSettingInternal(const std::string& key, const std::string& value);
+
+    void ReadCategory(Settings::Category category);
+    void WriteCategory(Settings::Category category);
+    void ReadSettingGeneric(Settings::BasicSetting* setting);
+    void WriteSettingGeneric(const Settings::BasicSetting* setting);
+
+    template <typename T>
+    [[nodiscard]] std::string ToString(const T& value_) {
+        if constexpr (std::is_same_v<T, std::string>) {
+            return value_;
+        } else if constexpr (std::is_same_v<T, std::optional<u32>>) {
+            return value_.has_value() ? std::to_string(*value_) : "none";
+        } else if constexpr (std::is_same_v<T, bool>) {
+            return value_ ? "true" : "false";
+        } else {
+            return std::to_string(static_cast<s64>(value_));
+        }
+    }
+
+    void BeginGroup(const std::string& group);
+    void EndGroup();
+    std::string GetSection();
+    [[nodiscard]] std::string GetGroup() const;
+    static std::string AdjustKey(const std::string& key);
+    static std::string AdjustOutputString(const std::string& string);
+    std::string GetFullKey(const std::string& key, bool skipArrayIndex);
+    int BeginArray(const std::string& array);
+    void EndArray();
+    void SetArrayIndex(int index);
+
+    const ConfigType type;
+    std::unique_ptr<CSimpleIniA> config;
+    std::string config_loc;
+    const bool global;
+
+private:
+    inline static std::array<char, 19> special_characters = {'!', '#', '$',  '%',  '^', '&', '*',
+                                                             '|', ';', '\'', '\"', ',', '<', '.',
+                                                             '>', '?', '`',  '~',  '='};
+
+    struct ConfigArray {
+        std::string name;
+        int size;
+        int index;
+    };
+    std::vector<ConfigArray> array_stack;
+    std::vector<std::string> key_stack;
+};