1 files changed, 153 insertions, 9 deletions

diff --git a/src/core/module/ModuleManager.cpp b/src/core/module/ModuleManager.cpp
index 83e7c1ff..d07ca989 100644
--- a/src/core/module/ModuleManager.cpp
+++ b/src/core/module/ModuleManager.cpp
@@ -29,16 +29,18 @@
 #include "ModuleManager.h"
 
 #include <memory>
+#include <utility>
 
-#include "GpgConstants.h"
+#include "core/function/SecureMemoryAllocator.h"
+#include "core/function/basic/GpgFunctionObject.h"
+#include "core/model/SettingsObject.h"
 #include "core/module/GlobalModuleContext.h"
 #include "core/module/GlobalRegisterTable.h"
 #include "core/module/Module.h"
+#include "core/struct/settings_object/ModuleSO.h"
 #include "core/thread/Task.h"
-#include "function/SecureMemoryAllocator.h"
-#include "function/basic/GpgFunctionObject.h"
-#include "thread/TaskRunnerGetter.h"
-#include "utils/MemoryUtils.h"
+#include "core/thread/TaskRunnerGetter.h"
+#include "core/utils/MemoryUtils.h"
 
 namespace GpgFrontend::Module {
 
@@ -50,19 +52,95 @@ class ModuleManager::Impl {
 
   ~Impl() = default;
 
+  auto LoadAndRegisterModule(const QString& module_library_path,
+                             bool integrated_module) -> void {
+    Thread::TaskRunnerGetter::GetInstance()
+        .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_Default)
+        ->PostTask(new Thread::Task(
+            [=](GpgFrontend::DataObjectPtr) -> int {
+              QLibrary module_library(module_library_path);
+              if (!module_library.load()) {
+                GF_CORE_LOG_WARN(
+                    "module manager failed to load module, "
+                    "reason: broken library: {} ",
+                    module_library.fileName());
+                return -1;
+              }
+
+              auto module = SecureCreateSharedObject<Module>(module_library);
+              if (!module->IsGood()) {
+                GF_CORE_LOG_WARN(
+                    "module manager failed to load module, "
+                    "reason: illegal module: {}",
+                    module_library.fileName());
+                return -1;
+              }
+
+              module->SetGPC(gmc_.get());
+              if (!gmc_->RegisterModule(module, integrated_module)) return -1;
+
+              const auto module_id = module->GetModuleIdentifier();
+              const auto module_hash = module->GetModuleHash();
+
+              SettingsObject so(QString("module.%1.so").arg(module_id));
+              ModuleSO module_so(so);
+
+              // reset module settings if necessary
+              if (module_so.module_id != module_id ||
+                  module_so.module_hash != module_hash) {
+                module_so.module_id = module_id;
+                module_so.module_hash = module_hash;
+                // auto active integrated module by default
+                module_so.auto_activate = integrated_module;
+                module_so.set_by_user = false;
+
+                so.Store(module_so.ToJson());
+              }
+
+              // if this module need auto active
+              if (module_so.auto_activate) {
+                if (!gmc_->ActiveModule(module_id)) {
+                  return -1;
+                }
+              }
+
+              return 0;
+            },
+            __func__, nullptr));
+  }
+
+  auto SearchModule(ModuleIdentifier module_id) -> ModulePtr {
+    return gmc_->SearchModule(std::move(module_id));
+  }
+
+  auto ListAllRegisteredModuleID() -> QList<ModuleIdentifier> {
+    return gmc_->ListAllRegisteredModuleID();
+  }
+
   void RegisterModule(const ModulePtr& module) {
     Thread::TaskRunnerGetter::GetInstance()
         .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_Default)
         ->PostTask(new Thread::Task(
             [=](GpgFrontend::DataObjectPtr) -> int {
               module->SetGPC(gmc_.get());
-              gmc_->RegisterModule(module);
+              return gmc_->RegisterModule(module, false) ? 0 : -1;
+            },
+            __func__, nullptr));
+  }
+
+  void ListenEvent(const ModuleIdentifier& module_id,
+                   const EventIdentifier& event_id) {
+    Thread::TaskRunnerGetter::GetInstance()
+        .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_Default)
+        ->PostTask(new Thread::Task(
+            [=](const GpgFrontend::DataObjectPtr&) -> int {
+              gmc_->ListenEvent(module_id, event_id);
               return 0;
             },
             __func__, nullptr));
   }
 
-  void TriggerEvent(const EventRefrernce& event) {
+  void TriggerEvent(const EventReference& event) {
     Thread::TaskRunnerGetter::GetInstance()
         .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_Default)
         ->PostTask(new Thread::Task(
@@ -73,6 +151,16 @@ class ModuleManager::Impl {
             __func__, nullptr));
   }
 
+  auto SearchEvent(EventTriggerIdentifier trigger_id)
+      -> std::optional<EventReference> {
+    return gmc_->SearchEvent(std::move(trigger_id));
+  }
+
+  auto GetModuleListening(ModuleIdentifier module_id)
+      -> QList<EventIdentifier> {
+    return gmc_->GetModuleListening(std::move(module_id));
+  }
+
   void ActiveModule(const ModuleIdentifier& identifier) {
     Thread::TaskRunnerGetter::GetInstance()
         .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_Default)
@@ -84,6 +172,17 @@ class ModuleManager::Impl {
             __func__, nullptr));
   }
 
+  void DeactiveModule(const ModuleIdentifier& identifier) {
+    Thread::TaskRunnerGetter::GetInstance()
+        .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_Default)
+        ->PostTask(new Thread::Task(
+            [=](const GpgFrontend::DataObjectPtr&) -> int {
+              gmc_->DeactivateModule(identifier);
+              return 0;
+            },
+            __func__, nullptr));
+  }
+
   auto GetTaskRunner(ModuleIdentifier module_id)
       -> std::optional<TaskRunnerPtr> {
     return gmc_->GetTaskRunner(std::move(module_id));
@@ -109,13 +208,20 @@ class ModuleManager::Impl {
     return gmc_->IsModuleActivated(id);
   }
 
+  auto IsIntegratedModule(ModuleIdentifier id) -> bool {
+    return gmc_->IsIntegratedModule(id);
+  }
+
+  auto GRT() -> GlobalRegisterTable* { return grt_.get(); }
+
  private:
   static ModuleMangerPtr global_module_manager;
   SecureUniquePtr<GlobalModuleContext> gmc_;
   SecureUniquePtr<GlobalRegisterTable> grt_;
+  QList<QLibrary> module_libraries_;
 };
 
-auto IsModuleAcivate(ModuleIdentifier id) -> bool {
+auto IsModuleActivate(ModuleIdentifier id) -> bool {
   return ModuleManager::GetInstance().IsModuleActivated(id);
 }
 
@@ -141,18 +247,46 @@ ModuleManager::ModuleManager(int channel)
 
 ModuleManager::~ModuleManager() = default;
 
+void ModuleManager::LoadModule(QString module_library_path,
+                               bool integrated_module) {
+  return p_->LoadAndRegisterModule(module_library_path, integrated_module);
+}
+
+auto ModuleManager::SearchModule(ModuleIdentifier module_id) -> ModulePtr {
+  return p_->SearchModule(std::move(module_id));
+}
+
 void ModuleManager::RegisterModule(ModulePtr module) {
   return p_->RegisterModule(module);
 }
 
-void ModuleManager::TriggerEvent(EventRefrernce event) {
+void ModuleManager::ListenEvent(ModuleIdentifier module,
+                                EventIdentifier event) {
+  return p_->ListenEvent(module, event);
+}
+
+auto ModuleManager::GetModuleListening(ModuleIdentifier module_id)
+    -> QList<EventIdentifier> {
+  return p_->GetModuleListening(module_id);
+}
+
+void ModuleManager::TriggerEvent(EventReference event) {
   return p_->TriggerEvent(event);
 }
 
+auto ModuleManager::SearchEvent(EventTriggerIdentifier trigger_id)
+    -> std::optional<EventReference> {
+  return p_->SearchEvent(std::move(trigger_id));
+}
+
 void ModuleManager::ActiveModule(ModuleIdentifier id) {
   return p_->ActiveModule(id);
 }
 
+void ModuleManager::DeactiveModule(ModuleIdentifier id) {
+  return p_->DeactiveModule(id);
+}
+
 auto ModuleManager::GetTaskRunner(ModuleIdentifier id)
     -> std::optional<TaskRunnerPtr> {
   return p_->GetTaskRunner(std::move(id));
@@ -181,4 +315,14 @@ auto ModuleManager::IsModuleActivated(ModuleIdentifier id) -> bool {
   return p_->IsModuleActivated(id);
 }
 
+auto ModuleManager::IsIntegratedModule(ModuleIdentifier id) -> bool {
+  return p_->IsIntegratedModule(id);
+}
+
+auto ModuleManager::ListAllRegisteredModuleID() -> QList<ModuleIdentifier> {
+  return p_->ListAllRegisteredModuleID();
+};
+
+auto ModuleManager::GRT() -> GlobalRegisterTable* { return p_->GRT(); }
+
 }  // namespace GpgFrontend::Module
\ No newline at end of file