1 files changed, 43 insertions, 14 deletions

diff --git a/src/android/app/src/main/jni/config.cpp b/src/android/app/src/main/jni/config.cpp
index 43e8aa72a..81120ab0f 100644
--- a/src/android/app/src/main/jni/config.cpp
+++ b/src/android/app/src/main/jni/config.cpp
@@ -11,22 +11,25 @@
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
+#include "common/settings_enums.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "input_common/main.h"
 #include "jni/config.h"
 #include "jni/default_ini.h"
+#include "uisettings.h"
 
 namespace FS = Common::FS;
 
-Config::Config(std::optional<std::filesystem::path> config_path)
-    : config_loc{config_path.value_or(FS::GetYuzuPath(FS::YuzuPath::ConfigDir) / "config.ini")},
-      config{std::make_unique<INIReader>(FS::PathToUTF8String(config_loc))} {
-    Reload();
+Config::Config(const std::string& config_name, ConfigType config_type)
+    : type(config_type), global{config_type == ConfigType::GlobalConfig} {
+    Initialize(config_name);
 }
 
 Config::~Config() = default;
 
 bool Config::LoadINI(const std::string& default_contents, bool retry) {
+    void(FS::CreateParentDir(config_loc));
+    config = std::make_unique<INIReader>(FS::PathToUTF8String(config_loc));
     const auto config_loc_str = FS::PathToUTF8String(config_loc);
     if (config->ParseError() < 0) {
         if (retry) {
@@ -144,21 +147,25 @@ void Config::ReadValues() {
                                                     Service::Account::MAX_USERS - 1);
 
     // Disable docked mode by default on Android
-    Settings::values.use_docked_mode = config->GetBoolean("System", "use_docked_mode", false);
+    Settings::values.use_docked_mode.SetValue(config->GetBoolean("System", "use_docked_mode", false)
+                                                  ? Settings::ConsoleMode::Docked
+                                                  : Settings::ConsoleMode::Handheld);
 
     const auto rng_seed_enabled = config->GetBoolean("System", "rng_seed_enabled", false);
     if (rng_seed_enabled) {
         Settings::values.rng_seed.SetValue(config->GetInteger("System", "rng_seed", 0));
     } else {
-        Settings::values.rng_seed.SetValue(std::nullopt);
+        Settings::values.rng_seed.SetValue(0);
     }
+    Settings::values.rng_seed_enabled.SetValue(rng_seed_enabled);
 
     const auto custom_rtc_enabled = config->GetBoolean("System", "custom_rtc_enabled", false);
     if (custom_rtc_enabled) {
         Settings::values.custom_rtc = config->GetInteger("System", "custom_rtc", 0);
     } else {
-        Settings::values.custom_rtc = std::nullopt;
+        Settings::values.custom_rtc = 0;
     }
+    Settings::values.custom_rtc_enabled = custom_rtc_enabled;
 
     ReadSetting("System", Settings::values.language_index);
     ReadSetting("System", Settings::values.region_index);
@@ -167,7 +174,7 @@ void Config::ReadValues() {
 
     // Core
     ReadSetting("Core", Settings::values.use_multi_core);
-    ReadSetting("Core", Settings::values.use_unsafe_extended_memory_layout);
+    ReadSetting("Core", Settings::values.memory_layout_mode);
 
     // Cpu
     ReadSetting("Cpu", Settings::values.cpu_accuracy);
@@ -222,14 +229,17 @@ void Config::ReadValues() {
     ReadSetting("Renderer", Settings::values.bg_blue);
 
     // Use GPU accuracy normal by default on Android
-    Settings::values.gpu_accuracy = static_cast<Settings::GPUAccuracy>(config->GetInteger(
-        "Renderer", "gpu_accuracy", static_cast<u32>(Settings::GPUAccuracy::Normal)));
+    Settings::values.gpu_accuracy = static_cast<Settings::GpuAccuracy>(config->GetInteger(
+        "Renderer", "gpu_accuracy", static_cast<u32>(Settings::GpuAccuracy::Normal)));
 
     // Use GPU default anisotropic filtering on Android
-    Settings::values.max_anisotropy = config->GetInteger("Renderer", "max_anisotropy", 1);
+    Settings::values.max_anisotropy =
+        static_cast<Settings::AnisotropyMode>(config->GetInteger("Renderer", "max_anisotropy", 1));
 
     // Disable ASTC compute by default on Android
-    Settings::values.accelerate_astc = config->GetBoolean("Renderer", "accelerate_astc", false);
+    Settings::values.accelerate_astc.SetValue(
+        config->GetBoolean("Renderer", "accelerate_astc", false) ? Settings::AstcDecodeMode::Gpu
+                                                                 : Settings::AstcDecodeMode::Cpu);
 
     // Enable asynchronous presentation by default on Android
     Settings::values.async_presentation =
@@ -272,7 +282,7 @@ void Config::ReadValues() {
     std::stringstream ss(title_list);
     std::string line;
     while (std::getline(ss, line, '|')) {
-        const auto title_id = std::stoul(line, nullptr, 16);
+        const auto title_id = std::strtoul(line.c_str(), nullptr, 16);
         const auto disabled_list = config->Get("AddOns", "disabled_" + line, "");
 
         std::stringstream inner_ss(disabled_list);
@@ -293,9 +303,28 @@ void Config::ReadValues() {
 
     // Network
     ReadSetting("Network", Settings::values.network_interface);
+
+    // Android
+    ReadSetting("Android", AndroidSettings::values.picture_in_picture);
+    ReadSetting("Android", AndroidSettings::values.screen_layout);
 }
 
-void Config::Reload() {
+void Config::Initialize(const std::string& config_name) {
+    const auto 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);
+        break;
+    case ConfigType::PerGameConfig:
+        config_loc = FS::PathToUTF8String(fs_config_loc / "custom" / FS::ToU8String(config_file));
+        break;
+    case ConfigType::InputProfile:
+        config_loc = FS::PathToUTF8String(fs_config_loc / "input" / config_file);
+        LoadINI(DefaultINI::android_config_file);
+        return;
+    }
     LoadINI(DefaultINI::android_config_file);
     ReadValues();
 }