1 files changed, 74 insertions, 5 deletions

diff --git a/src/core/module/ModuleManager.cpp b/src/core/module/ModuleManager.cpp
index 83e7c1ff..17191af2 100644
--- a/src/core/module/ModuleManager.cpp
+++ b/src/core/module/ModuleManager.cpp
@@ -29,16 +29,17 @@
 #include "ModuleManager.h"
 
 #include <memory>
+#include <utility>
 
 #include "GpgConstants.h"
+#include "core/function/SecureMemoryAllocator.h"
+#include "core/function/basic/GpgFunctionObject.h"
 #include "core/module/GlobalModuleContext.h"
 #include "core/module/GlobalRegisterTable.h"
 #include "core/module/Module.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,13 +51,57 @@ class ModuleManager::Impl {
 
   ~Impl() = default;
 
+  auto LoadAndRegisterModule(const QString& module_library_path) -> 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());
+              return gmc_->RegisterModule(module) ? 0 : -1;
+            },
+            __func__, nullptr));
+  }
+
+  auto SearchModule(ModuleIdentifier module_id) -> ModulePtr {
+    return gmc_->SearchModule(std::move(module_id));
+  }
+
   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) ? 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));
@@ -73,6 +118,11 @@ class ModuleManager::Impl {
             __func__, nullptr));
   }
 
+  auto SearchEvent(EventTriggerIdentifier trigger_id)
+      -> std::optional<EventRefrernce> {
+    return gmc_->SearchEvent(std::move(trigger_id));
+  }
+
   void ActiveModule(const ModuleIdentifier& identifier) {
     Thread::TaskRunnerGetter::GetInstance()
         .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_Default)
@@ -113,6 +163,7 @@ class ModuleManager::Impl {
   static ModuleMangerPtr global_module_manager;
   SecureUniquePtr<GlobalModuleContext> gmc_;
   SecureUniquePtr<GlobalRegisterTable> grt_;
+  QList<QLibrary> module_libraries_;
 };
 
 auto IsModuleAcivate(ModuleIdentifier id) -> bool {
@@ -141,14 +192,32 @@ ModuleManager::ModuleManager(int channel)
 
 ModuleManager::~ModuleManager() = default;
 
+void ModuleManager::LoadModule(QString module_library_path) {
+  return p_->LoadAndRegisterModule(module_library_path);
+}
+
+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::ListenEvent(ModuleIdentifier module,
+                                EventIdentifier event) {
+  return p_->ListenEvent(module, event);
+}
+
 void ModuleManager::TriggerEvent(EventRefrernce event) {
   return p_->TriggerEvent(event);
 }
 
+auto ModuleManager::SearchEvent(EventTriggerIdentifier trigger_id)
+    -> std::optional<EventRefrernce> {
+  return p_->SearchEvent(std::move(trigger_id));
+}
+
 void ModuleManager::ActiveModule(ModuleIdentifier id) {
   return p_->ActiveModule(id);
 }