openrgb/PluginManager.cpp at master · perjahn/openrgb · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#include "LogManager.h"
#include "PluginManager.h"

PluginManager::PluginManager(bool dark_theme_val)
{
    dark_theme = dark_theme_val;
}

void PluginManager::RegisterAddPluginTabCallback(AddPluginTabCallback new_callback, void * new_callback_arg)
{
    AddPluginTabCallbacks.push_back(new_callback);
    AddPluginTabCallbackArgs.push_back(new_callback_arg);
}

void PluginManager::ScanAndLoadPlugins()
{
    LOG_INFO("Loading plugins");

    const QDir plugins_dir = QString().fromStdString(ResourceManager::get()->GetConfigurationDirectory()) + "plugins/";

    std::vector<std::string> FileList;

    for(int i = 0; i < QDir(plugins_dir).entryList(QDir::Files).size(); i++)
    {
        /*--------------------------------------*\
        | Add all of the Plugin Files to a list  |
        \*--------------------------------------*/
        FileList.push_back(QDir(plugins_dir).entryList(QDir::Files)[i].toStdString());
    }

    for(const std::string &plugin_name : FileList)
    {
        const std::string plugin_path = plugins_dir.absoluteFilePath(QString().fromStdString(plugin_name)).toStdString();

        LoadPlugin(plugin_path);
    }
}

void PluginManager::LoadPlugin(std::string path)
{
    OpenRGBPluginInterface *OpenRGBPlugin = nullptr;

    LOG_VERBOSE("Attempting to load: %s", path.c_str());

    QPluginLoader loader(QString().fromStdString(path));

    if (QObject *instance = loader.instance())
    {
        if ((OpenRGBPlugin = qobject_cast<OpenRGBPluginInterface*>(instance)))
        {
            /*-----------------------------------------------------*\
            | Initialize the plugin                                 |
            \*-----------------------------------------------------*/
            OpenRGBPlugin->info = OpenRGBPlugin->Initialize(dark_theme, ResourceManager::get());

            /*-----------------------------------------------------*\
            | Search the settings to see if it is enabled           |
            \*-----------------------------------------------------*/
            std::string     name        = "";
            std::string     description = "";
            bool            enabled     = true;
            bool            found       = false;
            unsigned int    plugin_ct   = 0;

            /*-------------------------------------------------*\
            | Open device disable list and read in disabled     |
            | device strings                                    |
            \*-------------------------------------------------*/
            json plugin_settings = ResourceManager::get()->GetSettingsManager()->GetSettings("Plugins");

            if(plugin_settings.contains("plugins"))
            {
                plugin_ct = plugin_settings["plugins"].size();

                for(unsigned int plugin_idx = 0; plugin_idx < plugin_settings["plugins"].size(); plugin_idx++)
                {
                    if(plugin_settings["plugins"][plugin_idx].contains("name"))
                    {
                        name        = plugin_settings["plugins"][plugin_idx]["name"];
                    }

                    if(plugin_settings["plugins"][plugin_idx].contains("description"))
                    {
                        description = plugin_settings["plugins"][plugin_idx]["description"];
                    }

                    if(plugin_settings["plugins"][plugin_idx].contains("enabled"))
                    {
                        enabled     = plugin_settings["plugins"][plugin_idx]["enabled"];
                    }

                    if((OpenRGBPlugin->info.PluginName == name)
                     &&(OpenRGBPlugin->info.PluginDescription == description))
                    {
                        found = true;
                        break;
                    }
                }
            }

            if(!found)
            {
                plugin_settings["plugins"][plugin_ct]["name"]           = OpenRGBPlugin->info.PluginName;
                plugin_settings["plugins"][plugin_ct]["description"]    = OpenRGBPlugin->info.PluginDescription;
                plugin_settings["plugins"][plugin_ct]["enabled"]        = enabled;

                ResourceManager::get()->GetSettingsManager()->SetSettings("Plugins", plugin_settings);
                ResourceManager::get()->GetSettingsManager()->SaveSettings();
            }

            LOG_VERBOSE("Loaded plugin %s", OpenRGBPlugin->info.PluginName.c_str());

            OpenRGBPluginEntry entry;

            entry.plugin  = OpenRGBPlugin;
            entry.path    = path;
            entry.enabled = enabled;

            PluginManager::ActivePlugins.push_back(entry);

            /*-------------------------------------------------*\
            | Call the callbacks                                |
            \*-------------------------------------------------*/
            for(unsigned int callback_idx = 0; callback_idx < AddPluginTabCallbacks.size(); callback_idx++)
            {
                AddPluginTabCallbacks[callback_idx](AddPluginTabCallbackArgs[callback_idx], OpenRGBPlugin);
            }
        }
    }
    else
    {
        std::cout << loader.errorString().toStdString() << std::endl;
    }
}