Add initial support for persisting a lsit inactive plugins

source/main.cpp

@@ -5,6 +5,7 @@
 #include "hooks.h"
 #include "patcher/hooks_patcher_static.h"
 #include "plugin/PluginDataFactory.h"
+#include "utils/WUPSBackendSettings.h"
 #include "utils/logger.h"
 #include "utils/utils.h"
 #include "version.h"
@@ -112,7 +113,9 @@ WUMS_APPLICATION_STARTS() {
 
         DEBUG_FUNCTION_LINE("Load plugins from %s", pluginPath.c_str());
 
-        const auto pluginData = PluginDataFactory::loadDir(pluginPath);
+        WUPSBackendSettings::LoadSettings();
+        auto &inactiveList    = WUPSBackendSettings::GetInactivePluginFilenames();
+        const auto pluginData = PluginDataFactory::loadDir(pluginPath, inactiveList);
         newLoadedPlugins      = PluginManagement::loadPlugins(pluginData, gTrampData);
     }
 

source/plugin/PluginDataFactory.cpp

@@ -26,7 +26,8 @@
 #include <set>
 #include <sys/dirent.h>
 
-std::vector<PluginLoadWrapper> PluginDataFactory::loadDir(std::string_view path) {
+
+std::vector<PluginLoadWrapper> PluginDataFactory::loadDir(std::string_view path, const std::vector<std::string> &inactivePluginsFilenames) {
     std::vector<PluginLoadWrapper> result;
     dirent *dp;
     DIR *dfd;
@@ -54,15 +55,9 @@ std::vector<PluginLoadWrapper> PluginDataFactory::loadDir(std::string_view path)
         DEBUG_FUNCTION_LINE("Loading plugin: %s", full_file_path.c_str());
 
         if (auto pluginData = load(full_file_path)) {
-            // TODO: This is only for testing. Remove me!c
-            bool shouldBeLoadedAndLinked = false;
-            if (full_file_path.ends_with("AromaBasePlugin.wps") ||
-                full_file_path.ends_with("drc_region_free.wps") ||
-                full_file_path.ends_with("regionfree.wps") ||
-                full_file_path.ends_with("ftpiiu.wps") ||
-                full_file_path.ends_with("wiiload.wps") ||
-                full_file_path.ends_with("homebrew_on_menu.wps")) {
-                shouldBeLoadedAndLinked = true;
+            bool shouldBeLoadedAndLinked = true;
+            if (std::ranges::find(inactivePluginsFilenames, dp->d_name) != inactivePluginsFilenames.end()) {
+                shouldBeLoadedAndLinked = false;
             }
             result.emplace_back(std::move(pluginData), shouldBeLoadedAndLinked);
         } else {

source/plugin/PluginDataFactory.h

@@ -25,7 +25,7 @@
 
 class PluginDataFactory {
 public:
-    static std::vector<PluginLoadWrapper> loadDir(std::string_view path);
+    static std::vector<PluginLoadWrapper> loadDir(std::string_view path, const std::vector<std::string> &inactivePluginsFilenames);
 
     static std::unique_ptr<PluginData> load(std::string_view path);
 

source/utils/WUPSBackendSettings.cpp

@@ -0,0 +1,77 @@
+#include "WUPSBackendSettings.h"
+#include "fs/CFile.hpp"
+#include "fs/FSUtils.h"
+#include "utils/logger.h"
+#include "utils/utils.h"
+#include <span>
+#include <string>
+#include <vector>
+
+namespace WUPSBackendSettings {
+    namespace {
+        std::vector<std::string> sInactivePlugins;
+    }
+
+#define INACTIVE_PLUGINS_KEY "inactive_plugins"
+
+    bool LoadSettings() {
+        nlohmann::json j       = nlohmann::json::object();
+        std::string folderPath = getModulePath() + "/configs/";
+        std::string filePath   = folderPath + "wupsbackend.json";
+
+        if (!ParseJsonFromFile(filePath, j)) {
+            sInactivePlugins.clear();
+            return false;
+        }
+
+        if (j.contains(INACTIVE_PLUGINS_KEY) && j[INACTIVE_PLUGINS_KEY].is_array()) {
+            for (auto &cur : j[INACTIVE_PLUGINS_KEY]) {
+                if (cur.is_string()) {
+                    sInactivePlugins.push_back(cur);
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool SaveSettings() {
+        std::string folderPath = getModulePath() + "/configs/";
+        std::string filePath   = folderPath + "wupsbackend.json";
+        if (!FSUtils::CreateSubfolder(folderPath)) {
+            return false;
+        }
+
+        CFile file(filePath, CFile::WriteOnly);
+        if (!file.isOpen()) {
+            DEBUG_FUNCTION_LINE_ERR("Cannot create file %s", filePath.c_str());
+            return false;
+        }
+
+        nlohmann::json j        = nlohmann::json::object();
+        j[INACTIVE_PLUGINS_KEY] = sInactivePlugins;
+
+        std::string jsonString = j.dump(4, ' ', false, nlohmann::json::error_handler_t::ignore);
+        auto writeResult       = file.write((const uint8_t *) jsonString.c_str(), jsonString.size());
+
+        file.close();
+
+        if (writeResult != (int32_t) jsonString.size()) {
+            return false;
+        }
+
+        return true;
+    }
+
+    void SetInactivePluginFilenames(std::span<std::string> filenames) {
+        sInactivePlugins.clear();
+        for (const auto &filename : filenames) {
+            sInactivePlugins.emplace_back(filename);
+        }
+    }
+
+    const std::vector<std::string> &GetInactivePluginFilenames() {
+        return sInactivePlugins;
+    }
+
+} // namespace WUPSBackendSettings

source/utils/WUPSBackendSettings.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <span>
+#include <string>
+#include <vector>
+
+namespace WUPSBackendSettings {
+    bool LoadSettings();
+
+    bool SaveSettings();
+
+    void SetInactivePluginFilenames(std::span<std::string> filenames);
+
+    const std::vector<std::string> &GetInactivePluginFilenames();
+}; // namespace WUPSBackendSettings

source/utils/config/ConfigDefines.h

@@ -25,5 +25,6 @@ struct StoredBuffer {
 enum ConfigSubState {
     SUB_STATE_RUNNING                   = 0,
     SUB_STATE_RETURN                    = 1,
+    SUB_STATE_RETURN_WITH_PLUGIN_RELOAD = 1,
     SUB_STATE_ERROR                     = 2,
 };

source/utils/config/ConfigRenderer.cpp

@@ -90,18 +90,16 @@ ConfigSubState ConfigRenderer::UpdateStateMain(const Input &input) {
         mCursorPos--;
     } else if (input.data.buttons_d & Input::eButtons::BUTTON_PLUS) {
         if (mSetActivePluginsMode) {
-            if (mActivePluginsDirty) {
-                for (const auto &cur : mConfigs) {
-                    gLoadOnNextLaunch.emplace_back(cur.getConfigInformation().pluginData, cur.isActivePlugin());
-                }
-                _SYSLaunchTitleWithStdArgsInNoSplash(OSGetTitleID(), nullptr);
-            }
             mNeedRedraw = true;
             mCategoryRenderer.reset();
-            return SUB_STATE_RETURN;
+            return SUB_STATE_RETURN_WITH_PLUGIN_RELOAD;
         }
     } else if (input.data.buttons_d & Input::eButtons::BUTTON_X) {
-        mSetActivePluginsMode = !mSetActivePluginsMode;
+        if (!mSetActivePluginsMode) {
+            mSetActivePluginsMode = true;
+            mNeedRedraw           = true;
+            return SUB_STATE_RUNNING;
+        }
     } else if (input.data.buttons_d & Input::eButtons::BUTTON_A) {
         if (mSetActivePluginsMode) {
             mActivePluginsDirty = true;
@@ -252,6 +250,18 @@ void ConfigRenderer::CallOnCloseCallback(const GeneralConfigInformation &info, c
     }
 }
 
+bool ConfigRenderer::GetActivePluginsIfChanged(std::vector<PluginLoadWrapper> &result) {
+    if (mActivePluginsDirty) {
+        std::vector<std::string> inactive_plugins;
+        result.clear();
+        for (const auto &cur : mConfigs) {
+            result.emplace_back(cur.getConfigInformation().pluginData, cur.isActivePlugin());
+        }
+        return true;
+    }
+    return false;
+}
+
 void ConfigRenderer::CallOnCloseCallback(const GeneralConfigInformation &info, const WUPSConfigAPIBackend::WUPSConfig &config) {
     CallOnCloseCallback(info, config.getCategories());
     for (const auto &item : config.getItems()) {

source/utils/config/ConfigRenderer.h

@@ -3,12 +3,13 @@
 #include "CategoryRenderer.h"
 #include "ConfigDefines.h"
 #include "ConfigDisplayItem.h"
+#include "plugin/PluginLoadWrapper.h"
 #include "utils/input/Input.h"
 
 #include <cstdint>
+#include <functional>
 #include <memory>
 #include <vector>
-#include <functional>
 #include <wups/config.h>
 
 class ConfigRenderer {
@@ -26,6 +27,8 @@ public:
 
     void ResetNeedsRedraw();
 
+    bool GetActivePluginsIfChanged(std::vector<PluginLoadWrapper> &result);
+
 private:
     ConfigSubState UpdateStateMain(const Input &input);
 

source/utils/config/ConfigUtils.cpp

@@ -2,7 +2,9 @@
 #include "ConfigRenderer.h"
 #include "config/WUPSConfigAPI.h"
 #include "hooks.h"
+#include "plugin/PluginLoadWrapper.h"
 #include "utils/DrawUtils.h"
+#include "utils/WUPSBackendSettings.h"
 #include "utils/dc.h"
 #include "utils/input/CombinedInput.h"
 #include "utils/input/Input.h"
@@ -13,9 +15,11 @@
 #include "version.h"
 
 #include <algorithm>
+#include <coreinit/title.h>
 #include <globals.h>
 #include <memory/mappedmemory.h>
 #include <memory>
+#include <sysapp/launch.h>
 #include <vector>
 #include <wups/config.h>
 
@@ -214,8 +218,42 @@ void ConfigUtils::displayMenu() {
     }
 
     startTime = OSGetTime();
-    renderBasicScreen("Saving configs...");
 
+    DEBUG_FUNCTION_LINE_INFO(".");
+    std::vector<PluginLoadWrapper> newActivePluginsList;
+
+    if (renderer.GetActivePluginsIfChanged(newActivePluginsList)) {
+        startTime = OSGetTime();
+        renderBasicScreen("Applying changes, app will now restart...");
+
+        // Get list of inactive plugins to save them in the config
+        // Note: this does only consider plugin loaded from the sd card.
+        std::vector<std::string> newInactivePluginsList;
+        for (const auto &cur : newActivePluginsList) {
+            if (!cur.isLoadAndLink()) {
+                auto &source = cur.getPluginData()->getSource();
+                // TODO: Make sure to only use plugins from the actual plugin directory?
+                // atm nothing (to my knowledge) is using the WUPS API to load any plugin from a path though
+                if (source.ends_with(".wps")) {
+                    std::size_t found    = source.find_last_of("/\\");
+                    std::string filename = source.substr(found + 1);
+                    newInactivePluginsList.push_back(filename);
+                }
+            }
+        }
+        gLoadOnNextLaunch = newActivePluginsList;
+        WUPSBackendSettings::SetInactivePluginFilenames(newInactivePluginsList);
+        WUPSBackendSettings::SaveSettings();
+
+        _SYSLaunchTitleWithStdArgsInNoSplash(OSGetTitleID(), nullptr);
+        // Make sure to wait at least 2 seconds so user can read the screen and
+        // are aware the app will restart now.
+        auto diffTime = OSTicksToMilliseconds(OSGetTime() - startTime);
+        if (diffTime < 2000) {
+            OSSleepTicks(OSTicksToMilliseconds(2000 - diffTime));
+        }
+    } else {
+        renderBasicScreen("Saving configs...");
         for (const auto &plugin : gLoadedPlugins) {
             const auto configData = plugin.getConfigData();
             if (configData) {
@@ -226,6 +264,7 @@ void ConfigUtils::displayMenu() {
                 CallHook(plugin, WUPS_LOADER_HOOK_CONFIG_CLOSED_DEPRECATED);
             }
         }
+    }
 
     WUPSConfigAPIBackend::Intern::CleanAllHandles();
 

source/utils/storage/StorageUtils.cpp

@@ -174,24 +174,10 @@ namespace StorageUtils {
 
         WUPSStorageError LoadFromFile(std::string_view plugin_id, nlohmann::json &outJson) {
             const std::string filePath = getPluginPath() + "/config/" + plugin_id.data() + ".json";
-            CFile file(filePath, CFile::ReadOnly);
-            if (!file.isOpen() || file.size() == 0) {
-                return WUPS_STORAGE_ERROR_NOT_FOUND;
+            if (ParseJsonFromFile(filePath, outJson)) {
+                return WUPS_STORAGE_ERROR_SUCCESS;
             }
-            auto *json_data = static_cast<uint8_t *>(memalign(0x40, ROUNDUP(file.size() + 1, 0x40)));
-            if (!json_data) {
-                return WUPS_STORAGE_ERROR_MALLOC_FAILED;
-            }
-            WUPSStorageError result = WUPS_STORAGE_ERROR_SUCCESS;
-            if (const uint64_t readRes = file.read(json_data, file.size()); readRes == file.size()) {
-                json_data[file.size()] = '\0';
-                outJson                = nlohmann::json::parse(json_data, nullptr, false);
-            } else {
-                result = WUPS_STORAGE_ERROR_IO_ERROR;
-            }
-            file.close();
-            free(json_data);
-            return result;
+            return WUPS_STORAGE_ERROR_IO_ERROR;
         }
 
         WUPSStorageError LoadFromFile(std::string_view plugin_id, StorageItemRoot &rootItem) {

source/utils/utils.cpp

@@ -1,30 +1,54 @@
 #include "utils.h"
+#include "fs/CFile.hpp"
 #include "globals.h"
+#include "json.hpp"
 #include "logger.h"
+
 #include <algorithm>
 #include <coreinit/ios.h>
 #include <malloc.h>
 #include <string>
+#include <wups/storage.h>
 
 static std::string sPluginPath;
-std::string getPluginPath() {
-    if (!sPluginPath.empty()) {
-        return sPluginPath;
+static std::string sModulePath;
+static std::string sEnvironmentPath;
+
+std::string getEnvironmentPath() {
+    if (!sEnvironmentPath.empty()) {
+        return sEnvironmentPath;
     }
     char environmentPath[0x100] = {};
 
     if (const auto handle = IOS_Open("/dev/mcp", IOS_OPEN_READ); handle >= 0) {
         int in = 0xF9; // IPC_CUSTOM_COPY_ENVIRONMENT_PATH
         if (IOS_Ioctl(handle, 100, &in, sizeof(in), environmentPath, sizeof(environmentPath)) != IOS_ERROR_OK) {
-            return "fs:/vol/external01/wiiu/plugins";
+            return "fs:/vol/external01/wiiu/environments/aroma";
         }
 
         IOS_Close(handle);
     }
-    sPluginPath = std::string(environmentPath).append("/plugins");
+    sEnvironmentPath = environmentPath;
+    return sEnvironmentPath;
+}
+std::string getPluginPath() {
+    if (!sPluginPath.empty()) {
         return sPluginPath;
     }
 
+    sPluginPath = getEnvironmentPath().append("/plugins");
+    return sPluginPath;
+}
+
+std::string getModulePath() {
+    if (!sModulePath.empty()) {
+        return sModulePath;
+    }
+
+    sModulePath = getEnvironmentPath().append("/modules");
+    return sModulePath;
+}
+
 // https://gist.github.com/ccbrown/9722406
 void dumpHex(const void *data, const size_t size) {
     char ascii[17];
@@ -87,3 +111,25 @@ void CustomDynLoadFree(void *addr) {
         gAllocatedAddresses.erase(it);
     }
 }
+
+bool ParseJsonFromFile(const std::string &filePath, nlohmann::json &outJson) {
+    CFile file(filePath, CFile::ReadOnly);
+    if (!file.isOpen() || file.size() == 0) {
+        return WUPS_STORAGE_ERROR_NOT_FOUND;
+    }
+    auto *json_data = (uint8_t *) memalign(0x40, ROUNDUP(file.size() + 1, 0x40));
+    if (!json_data) {
+        return WUPS_STORAGE_ERROR_MALLOC_FAILED;
+    }
+    bool result      = true;
+    uint64_t readRes = file.read(json_data, file.size());
+    if (readRes == file.size()) {
+        json_data[file.size()] = '\0';
+        outJson                = nlohmann::json::parse(json_data, nullptr, false);
+    } else {
+        result = false;
+    }
+    file.close();
+    free(json_data);
+    return result;
+}

source/utils/utils.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "json.hpp"
 #include <algorithm>
 #include <coreinit/dynload.h>
 #include <cstdint>
@@ -137,6 +138,10 @@ void append_move_all_values(Container &dest, Container &src) {
 
 std::string getPluginPath();
 
+std::string getModulePath();
+
 OSDynLoad_Error CustomDynLoadAlloc(int32_t size, int32_t align, void **outAddr);
 
 void CustomDynLoadFree(void *addr);
+
+bool ParseJsonFromFile(const std::string &filePath, nlohmann::json &outJson);