Merge branch 'dev/2.1.2/module' into develop

1 files changed, 129 insertions, 6 deletions

diff --git a/src/core/module/ModuleManager.cpp b/src/core/module/ModuleManager.cpp
index 83e7c1ff..e00c8c8c 100644
--- a/src/core/module/ModuleManager.cpp
+++ b/src/core/module/ModuleManager.cpp
@@ -29,16 +29,19 @@
 #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,13 +53,76 @@ 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());
+              if (!gmc_->RegisterModule(module)) return -1;
+
+              SettingsObject so(
+                  QString("module.%1.so").arg(module->GetModuleIdentifier()));
+              ModuleSO module_so(so);
+
+              // if user has set auto active enable
+              if (module_so.module_id == module->GetModuleIdentifier() &&
+                  module_so.module_hash == module->GetModuleHash() &&
+                  module_so.auto_activate) {
+                if (gmc_->ActiveModule(module->GetModuleIdentifier())) {
+                  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) ? 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 +139,16 @@ class ModuleManager::Impl {
             __func__, nullptr));
   }
 
+  auto SearchEvent(EventTriggerIdentifier trigger_id)
+      -> std::optional<EventRefrernce> {
+    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 +160,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 +196,16 @@ class ModuleManager::Impl {
     return gmc_->IsModuleActivated(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 +231,45 @@ 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);
+}
+
+auto ModuleManager::GetModuleListening(ModuleIdentifier module_id)
+    -> QList<EventIdentifier> {
+  return p_->GetModuleListening(module_id);
+}
+
 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);
 }
 
+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 +298,10 @@ auto ModuleManager::IsModuleActivated(ModuleIdentifier id) -> bool {
   return p_->IsModuleActivated(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