fix: slove compile issues

16 files changed, 184 insertions, 184 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d50195ae..97069b29 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -401,26 +401,26 @@ set(QT_MOC_CONFIG 1)
 if (FULL_BUILD_APPLICATION)
     message("[-] Build Full Application")
     set(QT5_ENV_SUPPORT 1)
-    set(BUILD_CORE_MODULE 1)
-    set(BUILD_UI_MODULE 1)
-    set(BUILD_PLUGIN_MODULE 1)
+    set(BUILD_CORE 1)
+    set(BUILD_UI 1)
+    set(BUILD_MODULE 1)
     set(BUILD_APPLICATION 1)
     set(BASIC_ENV_CONFIG 1)
     set(SUPPORT_MULTI_LANG 1)
 elseif (MINIMUM_BUILD_APPLICATION)
     message("[-] Build Minimum Application")
     set(QT5_ENV_SUPPORT 1)
-    set(BUILD_CORE_MODULE 1)
-    set(BUILD_UI_MODULE 1)
-    set(BUILD_PLUGIN_MODULE 1)
+    set(BUILD_CORE 1)
+    set(BUILD_UI 1)
+    set(BUILD_MODULE 1)
     set(BUILD_APPLICATION 1)
     set(BASIC_ENV_CONFIG 1)
 elseif (STABLE_BUILD_APPLICATION)
     message("[-] Build Stable Application")
     set(QT5_ENV_SUPPORT 1)
-    set(BUILD_CORE_MODULE 1)
-    set(BUILD_UI_MODULE 1)
-    set(BUILD_PLUGIN_MODULE 1)
+    set(BUILD_CORE 1)
+    set(BUILD_UI 1)
+    set(BUILD_MODULE 1)
     set(BUILD_APPLICATION 1)
     set(BASIC_ENV_CONFIG 1)
     set(SUPPORT_MULTI_LANG 1)
@@ -430,7 +430,7 @@ elseif (TEST_CORE_BUILD)
     if (MODULES)
     else ()
         message(STATUS "Build Default Modules")
-        set(BUILD_CORE_MODULE 1)
+        set(BUILD_CORE 1)
     endif ()
 
 endif ()
diff --git a/src/main.cpp b/src/main.cpp
index 58cacc63..c4838060 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -132,7 +132,7 @@ int main(int argc, char* argv[]) {
   int return_from_event_loop_code;
   int restart_count = 0;
 
-  // load integrated plugins
+  // load integrated modules
   GpgFrontend::Module::LoadGpgFrontendIntegratedModules();
 
   do {
diff --git a/src/module/CMakeLists.txt b/src/module/CMakeLists.txt
index ab0a0e1d..1a618fc3 100644
--- a/src/module/CMakeLists.txt
+++ b/src/module/CMakeLists.txt
@@ -27,8 +27,8 @@ set(CMAKE_CXX_VISIBILITY_PRESET hidden)
 set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
 
 # define libgpgfrontend_module_system
-aux_source_directory(system PLUGIN_SYSTEM_SOURCE)
-add_library(gpgfrontend_module_system SHARED ${PLUGIN_SYSTEM_SOURCE})
+aux_source_directory(system MODULE_SYSTEM_SOURCE)
+add_library(gpgfrontend_module_system SHARED ${MODULE_SYSTEM_SOURCE})
 set(_export_file_system "${CMAKE_CURRENT_SOURCE_DIR}/system/GpgFrontendModuleSystemExport.h")
 generate_export_header(gpgfrontend_module_system EXPORT_FILE_NAME "${_export_file_system}")
 
diff --git a/src/module/GpgFrontendModule.h b/src/module/GpgFrontendModule.h
index 72eadc9a..91deda72 100644
--- a/src/module/GpgFrontendModule.h
+++ b/src/module/GpgFrontendModule.h
@@ -26,8 +26,8 @@
  *
  */
 
-#ifndef GPGFRONTEND_GPGFRONTENDPLUGIN_H
-#define GPGFRONTEND_GPGFRONTENDPLUGIN_H
+#ifndef GPGFRONTEND_GPGFRONTENDMODULE_H
+#define GPGFRONTEND_GPGFRONTENDMODULE_H
 
 /**
  * Project internal dependencies
@@ -36,4 +36,4 @@
 #include "GpgFrontendModuleExport.h"
 #include "core/GpgFrontendCore.h"
 
-#endif  // GPGFRONTEND_GPGFRONTENDPLUGIN_H
\ No newline at end of file
+#endif  // GPGFRONTEND_GPGFRONTENDMODULE_H
\ No newline at end of file
diff --git a/src/module/GpgFrontendModuleInit.cpp b/src/module/GpgFrontendModuleInit.cpp
index 53f71b71..234d0c18 100644
--- a/src/module/GpgFrontendModuleInit.cpp
+++ b/src/module/GpgFrontendModuleInit.cpp
@@ -36,16 +36,16 @@
 #include <memory>
 
 #include "core/function/GlobalSettingStation.h"
-#include "module/system/PluginManager.h"
+#include "module/system/ModuleManager.h"
 
-// integrated plugins
+// integrated modules
 #include "integrated/version_checking_module/VersionCheckingModule.h"
 
 namespace GpgFrontend::Module {
 
 void LoadGpgFrontendIntegratedModules() {
   SPDLOG_INFO("loading integrated module...");
-  ModuleManager::GetInstance()->RegisterPlugin(
+  ModuleManager::GetInstance()->RegisterModule(
       std::make_shared<
           Integrated::VersionCheckingModule::VersionCheckingModule>());
 }
@@ -70,7 +70,7 @@ void InitModuleLoggingSystem() {
 
   // logger
   auto module_logger = std::make_shared<spdlog::async_logger>(
-      "plugin", begin(sinks), end(sinks), spdlog::thread_pool());
+      "module", begin(sinks), end(sinks), spdlog::thread_pool());
   module_logger->set_pattern(
       "[%H:%M:%S.%e] [T:%t] [%=4n] %^[%=8l]%$ [%s:%#] [%!] -> %v (+%ius)");
 
diff --git a/src/module/GpgFrontendModuleInit.h b/src/module/GpgFrontendModuleInit.h
index 47380720..f00e9eff 100644
--- a/src/module/GpgFrontendModuleInit.h
+++ b/src/module/GpgFrontendModuleInit.h
@@ -26,15 +26,15 @@
  *
  */
 
-#ifndef GPGFRONTEND_GPGFRONTENDPLUGININIT_H
-#define GPGFRONTEND_GPGFRONTENDPLUGININIT_H
+#ifndef GPGFRONTEND_GPGFRONTENDMODULEINIT_H
+#define GPGFRONTEND_GPGFRONTENDMODULEINIT_H
 
 #include "module/GpgFrontendModule.h"
 
 namespace GpgFrontend::Module {
 
 /**
- * @brief init the plugin library
+ * @brief init the module library
  *
  */
 void GPGFRONTEND_MODULE_EXPORT LoadGpgFrontendIntegratedModules();
@@ -53,4 +53,4 @@ void GPGFRONTEND_MODULE_EXPORT ShutdownModuleLoggingSystem();
 
 };  // namespace GpgFrontend::Module
 
-#endif  // GPGFRONTEND_GPGFRONTENDPLUGININIT_H
+#endif  // GPGFRONTEND_GPGFRONTENDMODULEINIT_H
diff --git a/src/module/integrated/version_checking_module/CMakeLists.txt b/src/module/integrated/version_checking_module/CMakeLists.txt
index db1ba17f..ffe21c32 100644
--- a/src/module/integrated/version_checking_module/CMakeLists.txt
+++ b/src/module/integrated/version_checking_module/CMakeLists.txt
@@ -26,7 +26,7 @@
 
 aux_source_directory(. INTEGRATED_MODULE_SOURCE)
 
-# define libgpgfrontend_plugin
+# define libgpgfrontend_module
 add_library(gpgfrontend_integrated_module_version_checking SHARED ${INTEGRATED_MODULE_SOURCE})
 
 # link sdk
diff --git a/src/module/integrated/version_checking_module/VersionCheckTask.h b/src/module/integrated/version_checking_module/VersionCheckTask.h
index d30c6dd7..1fe39973 100644
--- a/src/module/integrated/version_checking_module/VersionCheckTask.h
+++ b/src/module/integrated/version_checking_module/VersionCheckTask.h
@@ -93,6 +93,6 @@ class VersionCheckTask : public Thread::Task {
 };
 
 }  // namespace GpgFrontend::Module::Integrated::VersionCheckingModule
-   // GpgFrontend::Module::Custom::IntegradedPlugin::VersionCheckingModule
+   // GpgFrontend::Module::Custom::IntegradedModule::VersionCheckingModule
 
 #endif  // GPGFRONTEND_VERSIONCHECKTHREAD_H
diff --git a/src/module/integrated/version_checking_module/VersionCheckingModule.cpp b/src/module/integrated/version_checking_module/VersionCheckingModule.cpp
index 3901a562..1524d876 100644
--- a/src/module/integrated/version_checking_module/VersionCheckingModule.cpp
+++ b/src/module/integrated/version_checking_module/VersionCheckingModule.cpp
@@ -33,24 +33,24 @@
 namespace GpgFrontend::Module::Integrated::VersionCheckingModule {
 
 VersionCheckingModule::VersionCheckingModule()
-    : Module("com.bktus.gpgfrontend.plugin.integrated.versionchecking", "1.0.0",
+    : Module("com.bktus.gpgfrontend.module.integrated.versionchecking", "1.0.0",
              ModuleMetaData{{"description", "try to check gpgfrontend version"},
                             {"author", "saturneric"}}) {}
 
 bool VersionCheckingModule::Register() {
-  SPDLOG_INFO("version checking plugin registering");
+  SPDLOG_INFO("version checking module registering");
   return true;
 }
 
 bool VersionCheckingModule::Active() {
-  SPDLOG_INFO("version checking plugin activating");
+  SPDLOG_INFO("version checking module activating");
 
   listenEvent("APPLICATION_STARTED");
   return true;
 }
 
 int VersionCheckingModule::Exec(EventRefrernce event) {
-  SPDLOG_INFO("version checking plugin ececuting");
+  SPDLOG_INFO("version checking module ececuting");
 
   getTaskRunner()->PostTask(new VersionCheckTask());
   return 0;
diff --git a/src/module/integrated/version_checking_module/VersionCheckingModule.h b/src/module/integrated/version_checking_module/VersionCheckingModule.h
index 5def5466..506f948d 100644
--- a/src/module/integrated/version_checking_module/VersionCheckingModule.h
+++ b/src/module/integrated/version_checking_module/VersionCheckingModule.h
@@ -26,8 +26,8 @@
  *
  */
 
-#ifndef GPGFRONTEND_MODULE_VERSIONCHECKINGPLUGIN_H
-#define GPGFRONTEND_MODULE_VERSIONCHECKINGPLUGIN_H
+#ifndef GPGFRONTEND_MODULE_VERSIONCHECKINGMODULE_H
+#define GPGFRONTEND_MODULE_VERSIONCHECKINGMODULE_H
 
 #include <module/sdk/GpgFrontendModuleSDK.h>
 
@@ -49,4 +49,4 @@ class GPGFRONTEND_MODULE_SDK_EXPORT VersionCheckingModule : public Module {
 };
 }  // namespace GpgFrontend::Module::Integrated::VersionCheckingModule
 
-#endif  // GPGFRONTEND_MODULE_VERSIONCHECKINGPLUGIN_H
\ No newline at end of file
+#endif  // GPGFRONTEND_MODULE_VERSIONCHECKINGMODULE_H
\ No newline at end of file
diff --git a/src/module/system/GlobalModuleContext.cpp b/src/module/system/GlobalModuleContext.cpp
index 6296250d..c1312af3 100644
--- a/src/module/system/GlobalModuleContext.cpp
+++ b/src/module/system/GlobalModuleContext.cpp
@@ -55,141 +55,141 @@ class GlobalModuleContext::Impl {
     acquired_channel_.insert(GPGFRONTEND_NON_ASCII_CHANNEL);
   }
 
-  int GetChannel(ModulePtr plugin) {
-    // Search for the plugin in the register table.
-    auto plugin_info_opt =
-        search_plugin_register_table(plugin->GetPluginIdentifier());
-    if (!plugin_info_opt.has_value()) {
+  int GetChannel(ModulePtr module) {
+    // Search for the module in the register table.
+    auto module_info_opt =
+        search_module_register_table(module->GetModuleIdentifier());
+    if (!module_info_opt.has_value()) {
       SPDLOG_ERROR(
-          "cannot find plugin id {} at register table, fallbacking to "
+          "cannot find module id {} at register table, fallbacking to "
           "default "
           "channel",
-          plugin->GetPluginIdentifier());
-      return GetDefaultChannel(plugin);
+          module->GetModuleIdentifier());
+      return GetDefaultChannel(module);
     }
 
-    auto plugin_info = plugin_info_opt.value();
-    return plugin_info->channel;
+    auto module_info = module_info_opt.value();
+    return module_info->channel;
   }
 
   int GetDefaultChannel(ModulePtr) { return GPGFRONTEND_DEFAULT_CHANNEL; }
 
-  std::optional<TaskRunnerPtr> GetTaskRunner(ModulePtr plugin) {
-    auto opt = search_plugin_register_table(plugin->GetPluginIdentifier());
+  std::optional<TaskRunnerPtr> GetTaskRunner(ModulePtr module) {
+    auto opt = search_module_register_table(module->GetModuleIdentifier());
     if (!opt.has_value()) {
       return std::nullopt;
     }
     return opt.value()->task_runner;
   }
 
-  std::optional<TaskRunnerPtr> GetTaskRunner(ModuleIdentifier plugin_id) {
-    // Search for the plugin in the register table.
-    auto plugin_info_opt = search_plugin_register_table(plugin_id);
-    if (!plugin_info_opt.has_value()) {
-      SPDLOG_ERROR("cannot find plugin id {} at register table", plugin_id);
+  std::optional<TaskRunnerPtr> GetTaskRunner(ModuleIdentifier module_id) {
+    // Search for the module in the register table.
+    auto module_info_opt = search_module_register_table(module_id);
+    if (!module_info_opt.has_value()) {
+      SPDLOG_ERROR("cannot find module id {} at register table", module_id);
       return std::nullopt;
     }
-    return plugin_info_opt.value()->task_runner;
+    return module_info_opt.value()->task_runner;
   }
 
   std::optional<TaskRunnerPtr> GetGlobalTaskRunner() {
     return default_task_runner_;
   }
 
-  bool RegisterPlugin(ModulePtr plugin) {
-    SPDLOG_DEBUG("attempting to register plugin: {}",
-                 plugin->GetPluginIdentifier());
-    // Check if the plugin is null or already registered.
-    if (plugin == nullptr ||
-        plugin_register_table_.find(plugin->GetPluginIdentifier()) !=
-            plugin_register_table_.end()) {
-      SPDLOG_ERROR("plugin is null or have already registered this plugin");
+  bool RegisterModule(ModulePtr module) {
+    SPDLOG_DEBUG("attempting to register module: {}",
+                 module->GetModuleIdentifier());
+    // Check if the module is null or already registered.
+    if (module == nullptr ||
+        module_register_table_.find(module->GetModuleIdentifier()) !=
+            module_register_table_.end()) {
+      SPDLOG_ERROR("module is null or have already registered this module");
       return false;
     }
 
-    if (!plugin->Register()) {
-      SPDLOG_ERROR("register plugin {} failed", plugin->GetPluginIdentifier());
+    if (!module->Register()) {
+      SPDLOG_ERROR("register module {} failed", module->GetModuleIdentifier());
       return false;
     }
 
-    PluginRegisterInfo register_info;
-    register_info.plugin = plugin;
+    ModuleRegisterInfo register_info;
+    register_info.module = module;
     register_info.channel = acquire_new_unique_channel();
     register_info.task_runner = std::make_shared<Thread::TaskRunner>();
 
-    // Register the plugin with its identifier.
-    plugin_register_table_[plugin->GetPluginIdentifier()] =
-        std::make_shared<PluginRegisterInfo>(std::move(register_info));
+    // Register the module with its identifier.
+    module_register_table_[module->GetModuleIdentifier()] =
+        std::make_shared<ModuleRegisterInfo>(std::move(register_info));
 
-    SPDLOG_DEBUG("successfully registered plugin: {}",
-                 plugin->GetPluginIdentifier());
+    SPDLOG_DEBUG("successfully registered module: {}",
+                 module->GetModuleIdentifier());
     return true;
   }
 
-  bool ActivePlugin(ModuleIdentifier plugin_id) {
-    SPDLOG_DEBUG("attempting to activate plugin: {}", plugin_id);
+  bool ActiveModule(ModuleIdentifier module_id) {
+    SPDLOG_DEBUG("attempting to activate module: {}", module_id);
 
-    // Search for the plugin in the register table.
-    auto plugin_info_opt = search_plugin_register_table(plugin_id);
-    if (!plugin_info_opt.has_value()) {
-      SPDLOG_ERROR("cannot find plugin id {} at register table", plugin_id);
+    // Search for the module in the register table.
+    auto module_info_opt = search_module_register_table(module_id);
+    if (!module_info_opt.has_value()) {
+      SPDLOG_ERROR("cannot find module id {} at register table", module_id);
       return false;
     }
 
-    auto plugin_info = plugin_info_opt.value();
-    // Activate the plugin if it is not already active.
-    if (plugin_info->activate && plugin_info->plugin->Active()) {
-      plugin_info->activate = true;
+    auto module_info = module_info_opt.value();
+    // Activate the module if it is not already active.
+    if (module_info->activate && module_info->module->Active()) {
+      module_info->activate = true;
     }
 
-    SPDLOG_DEBUG("plugin activation status: {}", plugin_info->activate);
-    return plugin_info->activate;
+    SPDLOG_DEBUG("module activation status: {}", module_info->activate);
+    return module_info->activate;
   }
 
-  bool ListenEvent(ModuleIdentifier plugin_id, EventIdentifier event) {
-    SPDLOG_DEBUG("plugin: {} is attempting to listen to event {}", plugin_id,
+  bool ListenEvent(ModuleIdentifier module_id, EventIdentifier event) {
+    SPDLOG_DEBUG("module: {} is attempting to listen to event {}", module_id,
                  event);
     // Check if the event exists, if not, create it.
-    auto it = plugin_events_table_.find(event);
-    if (it == plugin_events_table_.end()) {
-      plugin_events_table_[event] = std::unordered_set<ModuleIdentifier>();
-      it = plugin_events_table_.find(event);
-      SPDLOG_INFO("new event {} of plugin system created", event);
+    auto it = module_events_table_.find(event);
+    if (it == module_events_table_.end()) {
+      module_events_table_[event] = std::unordered_set<ModuleIdentifier>();
+      it = module_events_table_.find(event);
+      SPDLOG_INFO("new event {} of module system created", event);
     }
 
     auto& listeners_set = it->second;
-    // Add the listener (plugin) to the event.
+    // Add the listener (module) to the event.
     auto listener_it =
-        std::find(listeners_set.begin(), listeners_set.end(), plugin_id);
+        std::find(listeners_set.begin(), listeners_set.end(), module_id);
     if (listener_it == listeners_set.end()) {
-      listeners_set.insert(plugin_id);
+      listeners_set.insert(module_id);
     }
     return true;
   }
 
-  bool DeactivatePlugin(ModuleIdentifier plugin_id) {
-    // Search for the plugin in the register table.
-    auto plugin_info_opt = search_plugin_register_table(plugin_id);
-    if (!plugin_info_opt.has_value()) {
-      SPDLOG_ERROR("cannot find plugin id {} at register table", plugin_id);
+  bool DeactivateModule(ModuleIdentifier module_id) {
+    // Search for the module in the register table.
+    auto module_info_opt = search_module_register_table(module_id);
+    if (!module_info_opt.has_value()) {
+      SPDLOG_ERROR("cannot find module id {} at register table", module_id);
       return false;
     }
 
-    auto plugin_info = plugin_info_opt.value();
-    // Activate the plugin if it is not already deactive.
-    if (!plugin_info->activate && plugin_info->plugin->Deactive()) {
-      plugin_info->activate = false;
+    auto module_info = module_info_opt.value();
+    // Activate the module if it is not already deactive.
+    if (!module_info->activate && module_info->module->Deactive()) {
+      module_info->activate = false;
     }
 
-    return !plugin_info->activate;
+    return !module_info->activate;
   }
 
   bool TriggerEvent(EventRefrernce event) {
     SPDLOG_DEBUG("attempting to trigger event: {}", event->GetIdentifier());
 
     // Find the set of listeners associated with the given event in the table
-    auto it = plugin_events_table_.find(event->GetIdentifier());
-    if (it == plugin_events_table_.end()) {
+    auto it = module_events_table_.find(event->GetIdentifier());
+    if (it == module_events_table_.end()) {
       // Log a warning if the event is not registered and nobody is listening
       SPDLOG_WARN(
           "event {} is not listening by anyone and not registered as well",
@@ -212,48 +212,48 @@ class GlobalModuleContext::Impl {
     SPDLOG_DEBUG("event {}'s current listeners size: {}",
                  event->GetIdentifier(), listeners_set.size());
 
-    // Iterate through each listener and execute the corresponding plugin
-    for (auto& listener_plugin_id : listeners_set) {
-      // Search for the plugin's information in the registration table
-      auto plugin_info_opt = search_plugin_register_table(listener_plugin_id);
+    // Iterate through each listener and execute the corresponding module
+    for (auto& listener_module_id : listeners_set) {
+      // Search for the module's information in the registration table
+      auto module_info_opt = search_module_register_table(listener_module_id);
 
-      // Log an error if the plugin is not found in the registration table
-      if (!plugin_info_opt.has_value()) {
-        SPDLOG_ERROR("cannot find plugin id {} at register table",
-                     listener_plugin_id);
+      // Log an error if the module is not found in the registration table
+      if (!module_info_opt.has_value()) {
+        SPDLOG_ERROR("cannot find module id {} at register table",
+                     listener_module_id);
       }
 
-      // Retrieve the plugin's information
-      auto plugin_info = plugin_info_opt.value();
+      // Retrieve the module's information
+      auto module_info = module_info_opt.value();
 
-      // Check if the plugin is activated
-      if (!plugin_info->activate) continue;
+      // Check if the module is activated
+      if (!module_info->activate) continue;
 
-      // Execute the plugin and check if it fails
-      if (plugin_info->plugin->Exec(event)) {
-        // Log an error if the plugin execution fails
-        SPDLOG_ERROR("plugin {} executed failed", listener_plugin_id);
+      // Execute the module and check if it fails
+      if (module_info->module->Exec(event)) {
+        // Log an error if the module execution fails
+        SPDLOG_ERROR("module {} executed failed", listener_module_id);
       }
     }
 
-    // Return true to indicate successful execution of all plugins
+    // Return true to indicate successful execution of all modules
     return true;
   }
 
  private:
-  struct PluginRegisterInfo {
+  struct ModuleRegisterInfo {
     int channel;
     TaskRunnerPtr task_runner;
-    ModulePtr plugin;
+    ModulePtr module;
     bool activate;
   };
 
-  using PluginRegisterInfoPtr = std::shared_ptr<PluginRegisterInfo>;
+  using ModuleRegisterInfoPtr = std::shared_ptr<ModuleRegisterInfo>;
 
-  std::unordered_map<ModuleIdentifier, PluginRegisterInfoPtr>
-      plugin_register_table_;
+  std::unordered_map<ModuleIdentifier, ModuleRegisterInfoPtr>
+      module_register_table_;
   std::map<EventIdentifier, std::unordered_set<ModuleIdentifier>>
-      plugin_events_table_;
+      module_events_table_;
 
   std::set<int> acquired_channel_;
   boost::random::mt19937 random_gen_;
@@ -273,35 +273,35 @@ class GlobalModuleContext::Impl {
     return random_channel;
   }
 
-  // Function to search for a plugin in the register table.
-  std::optional<PluginRegisterInfoPtr> search_plugin_register_table(
+  // Function to search for a module in the register table.
+  std::optional<ModuleRegisterInfoPtr> search_module_register_table(
       ModuleIdentifier identifier) {
-    auto it = plugin_register_table_.find(identifier);
-    if (it == plugin_register_table_.end()) {
+    auto it = module_register_table_.find(identifier);
+    if (it == module_register_table_.end()) {
       return std::nullopt;
     }
     return it->second;
   }
 
-  std::list<ModuleIdentifier>& search_plugin_events_table(ModuleIdentifier);
+  std::list<ModuleIdentifier>& search_module_events_table(ModuleIdentifier);
 };
 
-// Constructor for GlobalPluginContext, takes a TaskRunnerPtr as an argument.
+// Constructor for GlobalModuleContext, takes a TaskRunnerPtr as an argument.
 GlobalModuleContext::GlobalModuleContext(TaskRunnerPtr task_runner)
     : p_(std::make_unique<Impl>(task_runner)) {}
 
 GlobalModuleContext::~GlobalModuleContext() = default;
 
-// Function to get the task runner associated with a plugin.
+// Function to get the task runner associated with a module.
 std::optional<TaskRunnerPtr> GlobalModuleContext::GetTaskRunner(
-    ModulePtr plugin) {
-  return p_->GetTaskRunner(plugin);
+    ModulePtr module) {
+  return p_->GetTaskRunner(module);
 }
 
-// Function to get the task runner associated with a plugin.
+// Function to get the task runner associated with a module.
 std::optional<TaskRunnerPtr> GlobalModuleContext::GetTaskRunner(
-    ModuleIdentifier plugin_id) {
-  return p_->GetTaskRunner(plugin_id);
+    ModuleIdentifier module_id) {
+  return p_->GetTaskRunner(module_id);
 }
 
 // Function to get the global task runner.
@@ -309,29 +309,29 @@ std::optional<TaskRunnerPtr> GlobalModuleContext::GetGlobalTaskRunner() {
   return p_->GetGlobalTaskRunner();
 }
 
-bool GlobalModuleContext::RegisterPlugin(ModulePtr plugin) {
-  return p_->RegisterPlugin(plugin);
+bool GlobalModuleContext::RegisterModule(ModulePtr module) {
+  return p_->RegisterModule(module);
 }
 
-bool GlobalModuleContext::ActivePlugin(ModuleIdentifier plugin_id) {
-  return p_->ActivePlugin(plugin_id);
+bool GlobalModuleContext::ActiveModule(ModuleIdentifier module_id) {
+  return p_->ActiveModule(module_id);
 }
 
-bool GlobalModuleContext::ListenEvent(ModuleIdentifier plugin_id,
+bool GlobalModuleContext::ListenEvent(ModuleIdentifier module_id,
                                       EventIdentifier event) {
-  return p_->ListenEvent(plugin_id, event);
+  return p_->ListenEvent(module_id, event);
 }
 
-bool GlobalModuleContext::DeactivatePlugin(ModuleIdentifier plugin_id) {
-  return p_->DeactivatePlugin(plugin_id);
+bool GlobalModuleContext::DeactivateModule(ModuleIdentifier module_id) {
+  return p_->DeactivateModule(module_id);
 }
 
 bool GlobalModuleContext::TriggerEvent(EventRefrernce event) {
   return p_->TriggerEvent(event);
 }
 
-int GlobalModuleContext::GetChannel(ModulePtr plugin) {
-  return p_->GetChannel(plugin);
+int GlobalModuleContext::GetChannel(ModulePtr module) {
+  return p_->GetChannel(module);
 }
 
 int GlobalModuleContext::GetDefaultChannel(ModulePtr _) {
diff --git a/src/module/system/GlobalModuleContext.h b/src/module/system/GlobalModuleContext.h
index 810961ea..a86a7c0f 100644
--- a/src/module/system/GlobalModuleContext.h
+++ b/src/module/system/GlobalModuleContext.h
@@ -26,8 +26,8 @@
  *
  */
 
-#ifndef GPGFRONTEND_GLOBALPLUGINCONTEXT_H
-#define GPGFRONTEND_GLOBALPLUGINCONTEXT_H
+#ifndef GPGFRONTEND_GLOBALMODULECONTEXT_H
+#define GPGFRONTEND_GLOBALMODULECONTEXT_H
 
 #include "GpgFrontendModuleSystemExport.h"
 #include "core/GpgFrontendCore.h"
@@ -60,15 +60,15 @@ class GPGFRONTEND_MODULE_SYSTEM_EXPORT GlobalModuleContext : public QObject {
 
   std::optional<TaskRunnerPtr> GetTaskRunner(ModulePtr);
 
-  std::optional<TaskRunnerPtr> GetTaskRunner(ModuleIdentifier plugin);
+  std::optional<TaskRunnerPtr> GetTaskRunner(ModuleIdentifier);
 
   std::optional<TaskRunnerPtr> GetGlobalTaskRunner();
 
-  bool RegisterPlugin(ModulePtr);
+  bool RegisterModule(ModulePtr);
 
-  bool ActivePlugin(ModuleIdentifier);
+  bool ActiveModule(ModuleIdentifier);
 
-  bool DeactivatePlugin(ModuleIdentifier);
+  bool DeactivateModule(ModuleIdentifier);
 
   bool ListenEvent(ModuleIdentifier, EventIdentifier);
 
@@ -81,4 +81,4 @@ class GPGFRONTEND_MODULE_SYSTEM_EXPORT GlobalModuleContext : public QObject {
 
 }  // namespace GpgFrontend::Module
 
-#endif  // GPGFRONTEND_GLOBALPLUGINCONTEXT_H
\ No newline at end of file
+#endif  // GPGFRONTEND_GLOBALMODULECONTEXT_H
\ No newline at end of file
diff --git a/src/module/system/Module.cpp b/src/module/system/Module.cpp
index c829b8aa..6aafa681 100644
--- a/src/module/system/Module.cpp
+++ b/src/module/system/Module.cpp
@@ -39,28 +39,28 @@ class Module::Impl {
   friend class GlobalModuleContext;
 
   Impl(ModuleIdentifier id, ModuleVersion version, ModuleMetaData meta_data)
-      : identifier_((boost::format("__plugin_%1%") % id).str()),
+      : identifier_((boost::format("__module_%1%") % id).str()),
         version_(version),
         meta_data_(meta_data) {}
 
   int GetChannel() {
-    return get_global_plugin_context()->GetChannel(self_shared_ptr_);
+    return get_global_module_context()->GetChannel(self_shared_ptr_);
   }
 
   int GetDefaultChannel() {
-    return get_global_plugin_context()->GetDefaultChannel(self_shared_ptr_);
+    return get_global_module_context()->GetDefaultChannel(self_shared_ptr_);
   }
 
   std::optional<TaskRunnerPtr> GetTaskRunner() {
-    return get_global_plugin_context()->GetTaskRunner(self_shared_ptr_);
+    return get_global_module_context()->GetTaskRunner(self_shared_ptr_);
   }
 
   bool ListenEvent(EventIdentifier event) {
-    return get_global_plugin_context()->ListenEvent(gpc_get_identifier(),
+    return get_global_module_context()->ListenEvent(gpc_get_identifier(),
                                                     event);
   }
 
-  ModuleIdentifier GetPluginIdentifier() const { return identifier_; }
+  ModuleIdentifier GetModuleIdentifier() const { return identifier_; }
 
   void SetGPC(GlobalModuleContextPtr gpc) { gpc_ = gpc; }
 
@@ -73,9 +73,9 @@ class Module::Impl {
 
   ModuleIdentifier gpc_get_identifier() { return identifier_; }
 
-  const GlobalModuleContextPtr get_global_plugin_context() {
+  const GlobalModuleContextPtr get_global_module_context() {
     if (gpc_ == nullptr) {
-      throw std::runtime_error("plugin is not registered by plugin manager");
+      throw std::runtime_error("module is not registered by module manager");
     }
     return gpc_;
   }
@@ -99,8 +99,8 @@ bool Module::listenEvent(EventIdentifier event) {
   return p_->ListenEvent(event);
 }
 
-ModuleIdentifier Module::GetPluginIdentifier() const {
-  return p_->GetPluginIdentifier();
+ModuleIdentifier Module::GetModuleIdentifier() const {
+  return p_->GetModuleIdentifier();
 }
 
 void Module::SetGPC(GlobalModuleContextPtr gpc) { p_->SetGPC(gpc); }
diff --git a/src/module/system/Module.h b/src/module/system/Module.h
index f8cfd230..9a2b7ade 100644
--- a/src/module/system/Module.h
+++ b/src/module/system/Module.h
@@ -65,7 +65,7 @@ class GPGFRONTEND_MODULE_SYSTEM_EXPORT Module : public QObject {
 
   virtual bool Deactive() = 0;
 
-  ModuleIdentifier GetPluginIdentifier() const;
+  ModuleIdentifier GetModuleIdentifier() const;
 
   void SetGPC(GlobalModuleContextPtr);
 
diff --git a/src/module/system/ModuleManager.cpp b/src/module/system/ModuleManager.cpp
index 8f0e7517..13e2b445 100644
--- a/src/module/system/ModuleManager.cpp
+++ b/src/module/system/ModuleManager.cpp
@@ -40,15 +40,15 @@ class ModuleManager::Impl {
  public:
   Impl()
       : task_runner_(std::make_shared<Thread::TaskRunner>()),
-        global_plugin_context_(
+        global_module_context_(
             std::make_shared<GlobalModuleContext>(task_runner_)) {
     task_runner_->start();
   }
 
-  void RegisterPlugin(ModulePtr plugin) {
+  void RegisterModule(ModulePtr module) {
     task_runner_->PostTask(new Thread::Task(
         std::move([=](GpgFrontend::Thread::DataObjectPtr) -> int {
-          global_plugin_context_->RegisterPlugin(plugin);
+          global_module_context_->RegisterModule(module);
           return 0;
         }),
         __func__, nullptr, true));
@@ -57,29 +57,29 @@ class ModuleManager::Impl {
   void TriggerEvent(EventRefrernce event) {
     task_runner_->PostTask(new Thread::Task(
         std::move([=](GpgFrontend::Thread::DataObjectPtr) -> int {
-          global_plugin_context_->TriggerEvent(event);
+          global_module_context_->TriggerEvent(event);
           return 0;
         }),
         __func__, nullptr, true));
   }
 
-  void ActivePlugin(ModuleIdentifier identifier) {
+  void ActiveModule(ModuleIdentifier identifier) {
     task_runner_->PostTask(new Thread::Task(
         std::move([=](GpgFrontend::Thread::DataObjectPtr) -> int {
-          global_plugin_context_->ActivePlugin(identifier);
+          global_module_context_->ActiveModule(identifier);
           return 0;
         }),
         __func__, nullptr, true));
   }
 
-  std::optional<TaskRunnerPtr> GetTaskRunner(ModuleIdentifier plugin_id) {
-    return global_plugin_context_->GetTaskRunner(plugin_id);
+  std::optional<TaskRunnerPtr> GetTaskRunner(ModuleIdentifier module_id) {
+    return global_module_context_->GetTaskRunner(module_id);
   }
 
  private:
-  static ModuleMangerPtr global_plugin_manager_;
+  static ModuleMangerPtr global_module_manager_;
   TaskRunnerPtr task_runner_;
-  GlobalModuleContextPtr global_plugin_context_;
+  GlobalModuleContextPtr global_module_context_;
 };
 
 ModuleManager::ModuleManager() : p_(std::make_unique<Impl>()) {}
@@ -91,21 +91,21 @@ ModuleMangerPtr ModuleManager::GetInstance() {
   return g_;
 }
 
-void ModuleManager::RegisterPlugin(ModulePtr plugin) {
-  return p_->RegisterPlugin(plugin);
+void ModuleManager::RegisterModule(ModulePtr module) {
+  return p_->RegisterModule(module);
 }
 
 void ModuleManager::TriggerEvent(EventRefrernce event) {
   return p_->TriggerEvent(event);
 }
 
-void ModuleManager::ActivePlugin(ModuleIdentifier identifier) {
-  return p_->ActivePlugin(identifier);
+void ModuleManager::ActiveModule(ModuleIdentifier identifier) {
+  return p_->ActiveModule(identifier);
 }
 
 std::optional<TaskRunnerPtr> ModuleManager::GetTaskRunner(
-    ModuleIdentifier plugin_id) {
-  return p_->GetTaskRunner(plugin_id);
+    ModuleIdentifier module_id) {
+  return p_->GetTaskRunner(module_id);
 }
 
 }  // namespace GpgFrontend::Module
\ No newline at end of file
diff --git a/src/module/system/ModuleManager.h b/src/module/system/ModuleManager.h
index 3520bbcf..fc046d1a 100644
--- a/src/module/system/ModuleManager.h
+++ b/src/module/system/ModuleManager.h
@@ -62,13 +62,13 @@ class GPGFRONTEND_MODULE_SYSTEM_EXPORT ModuleManager : public QObject {
 
   static ModuleMangerPtr GetInstance();
 
-  void RegisterPlugin(ModulePtr);
+  void RegisterModule(ModulePtr);
 
   void TriggerEvent(EventRefrernce);
 
-  void ActivePlugin(ModuleIdentifier);
+  void ActiveModule(ModuleIdentifier);
 
-  void DeactivePlugin(ModuleIdentifier);
+  void DeactiveModule(ModuleIdentifier);
 
   std::optional<TaskRunnerPtr> GetTaskRunner(ModuleIdentifier);