diff --git a/interfaces/native/innerkits/event/include/plugin_stage.h b/interfaces/native/innerkits/event/include/plugin_stage.h
index 5a43f65aa6786ff01f7da5537cea986c221be887..71801a632a3873753ab9cc5b648d0bcef142ca95 100644
--- a/interfaces/native/innerkits/event/include/plugin_stage.h
+++ b/interfaces/native/innerkits/event/include/plugin_stage.h
@@ -62,7 +62,7 @@ enum class InputDispatchStage {
 struct IPluginContext {
     virtual int32_t AddTimer(std::function<void()> func, int32_t intervalMs, int32_t repeatCount) = 0;
     virtual int32_t RemoveTimer(int32_t id) = 0;
-    void DispatchEvent(std::shared_ptr<KeyEvent> keyEvent, InputDispatchStage  stage);
+    virtual void DispatchEvent(std::shared_ptr<KeyEvent> keyEvent, InputDispatchStage stage) = 0;
     void DispatchEvent(std::shared_ptr<PointerEvent> pointerEvent, InputDispatchStage stage);
     void DispatchEvent(std::shared_ptr<AxisEvent> AxisEvent, InputDispatchStage stage);
     virtual void DispatchEvent(libinput_event *event, int64_t frameTime) = 0;
diff --git a/service/module_loader/include/multimodal_input_plugin_manager.h b/service/module_loader/include/multimodal_input_plugin_manager.h
index c30ad29407704302261152712897c3e375cf25ce..43822d66613621bc2cf8f5d1ad39ccd81cbda176 100644
--- a/service/module_loader/include/multimodal_input_plugin_manager.h
+++ b/service/module_loader/include/multimodal_input_plugin_manager.h
@@ -51,14 +51,17 @@ public:
     int32_t Init(std::shared_ptr<IInputPlugin> pin);
     void UnInit();
     PluginResult HandleEvent(libinput_event *event, int64_t frameTime);
+    PluginResult HandleEvent(std::shared_ptr<KeyEvent> keyEvent, InputPluginStage stage);
 
     int32_t AddTimer(std::function<void()> func, int32_t intervalMs, int32_t repeatCount) override;
     int32_t RemoveTimer(int32_t id) override;
     void DispatchEvent(libinput_event *event, int64_t frameTime) override;
+    void DispatchEvent(std::shared_ptr<KeyEvent> keyEvent, InputDispatchStage stage) override;
 
     int32_t timerCnt_ = 0;
     int32_t prio_ = 200;
     std::function<void(libinput_event*, int64_t)> callback_;
+    std::function<void(std::shared_ptr<KeyEvent>)> keyEventCallback_;
     UnintPlugin unintPlugin_ = nullptr;
     std::shared_ptr<IInputPlugin> plugin_;
     std::string name_;
@@ -76,9 +79,12 @@ public:
     int32_t Init();
     void Dump(int fd);
     int32_t HandleEvent(libinput_event* event, int64_t frameTime, InputPluginStage stage);
+    int32_t HandleEvent(std::shared_ptr<KeyEvent> keyEvent, InputPluginStage stage);
     void PluginAssignmentCallBack(std::function<void(libinput_event*, int64_t)> callback, InputPluginStage stage);
+    void PluginAssignmentCallBack(std::function<void(std::shared_ptr<KeyEvent>)> callback, InputPluginStage stage);
     void PrintPlugins();
     int32_t DoHandleEvent(libinput_event *event, int64_t frameTime, InputPlugin *iplugin, InputPluginStage stage);
+    int32_t DoHandleEvent(std::shared_ptr<KeyEvent> keyEvent, InputPlugin *iplugin, InputPluginStage stage);
 
 private:
     bool IntermediateEndEvent(libinput_event *event);
diff --git a/service/module_loader/src/multimodal_input_plugin_manager.cpp b/service/module_loader/src/multimodal_input_plugin_manager.cpp
index 4d34f63d36a8587ad4d991191bf06c89d4d8d989..eefc2855c30e4e35b018484b8516b71b82879bfa 100644
--- a/service/module_loader/src/multimodal_input_plugin_manager.cpp
+++ b/service/module_loader/src/multimodal_input_plugin_manager.cpp
@@ -157,6 +157,20 @@ void InputPluginManager::PluginAssignmentCallBack(
     }
 }
 
+void InputPluginManager::PluginAssignmentCallBack(
+    std::function<void(std::shared_ptr<KeyEvent>)> callback, InputPluginStage stage)
+{
+    CALL_DEBUG_ENTER;
+    auto it = plugins_.find(stage);
+    if (it == plugins_.end()) {
+        MMI_HILOGI("plugins_ not stage:%{public}d.", stage);
+        return;
+    }
+    for (auto &plugin : it->second) {
+        plugin->keyEventCallback_ = callback;
+    }
+}
+
 int32_t InputPluginManager::HandleEvent(libinput_event *event, int64_t frameTime, InputPluginStage stage)
 {
     return DoHandleEvent(event, frameTime, nullptr, stage);
@@ -214,6 +228,59 @@ int32_t InputPluginManager::DoHandleEvent(
     return RET_NOTDO;
 }
 
+int32_t InputPluginManager::HandleEvent(std::shared_ptr<KeyEvent> keyEvent, InputPluginStage stage)
+{
+    return DoHandleEvent(keyEvent, nullptr, stage);
+}
+
+int32_t InputPluginManager::DoHandleEvent(
+    std::shared_ptr<KeyEvent> keyEvent, InputPlugin *iplugin, InputPluginStage stage)
+{
+    if (keyEvent == nullptr) {
+        return RET_NOTDO;
+    }
+    auto it = plugins_.find(stage);
+    if (it == plugins_.end()) {
+        return RET_NOTDO;
+    }
+    CALL_DEBUG_ENTER;
+    auto &plugins = it->second;
+    auto start_plugin = plugins.begin();
+    if (iplugin != nullptr) {
+        auto cur_plugin = std::find_if(plugins.begin(), plugins.end(),
+            [iplugin](const std::shared_ptr<InputPlugin> &plugin) { return plugin.get() == iplugin; });
+        if (cur_plugin == plugins.end()) {
+            return RET_NOTDO;
+        }
+        start_plugin = std::next(cur_plugin);
+    }
+    int64_t beginTime = 0;
+    PluginResult result;
+    int64_t endTime = 0;
+    int64_t lostTime = 0;
+    for (auto pluginIt = start_plugin; pluginIt != plugins.end(); ++pluginIt) {
+        if ((*pluginIt) == nullptr) {
+            continue;
+        }
+        beginTime = GetSysClockTime();
+        result = (*pluginIt)->HandleEvent(keyEvent, stage);
+        endTime = GetSysClockTime();
+        lostTime = endTime - beginTime;
+        if (lostTime >= TIMEOUT_US) {
+            MMI_HILOGE("pluginIt timeout name:%{public}s ,endTime:%{public}" PRId64 ",lostTime:%{public}" PRId64,
+                (*pluginIt)->name_.c_str(), endTime, lostTime);
+        }
+        if (result == PluginResult::UseNeedReissue) {
+            return RET_DO;
+        } else if (result == PluginResult::UseNoNeedReissue) {
+            return RET_DO;
+        } else if (result == PluginResult::Error) {
+            MMI_HILOGE("pluginIt err name:%{public}s", (*pluginIt)->name_.c_str());
+        }
+    }
+    return RET_NOTDO;
+}
+
 // LIBINPUT_EVENT_TABLET_TOOL_BUTTON、LIBINPUT_EVENT_TABLET_PAD_BUTTON、LIBINPUT_EVENT_TABLET_PAD_KEY
 // These few existence termination events are currently not used and will be supplemented after use
 bool InputPluginManager::IntermediateEndEvent(libinput_event *event)
@@ -303,12 +370,27 @@ void InputPlugin::DispatchEvent(libinput_event *event, int64_t frameTime)
     }
 }
 
+void InputPlugin::DispatchEvent(std::shared_ptr<KeyEvent> keyEvent, InputDispatchStage stage)
+{
+    int32_t result = InputPluginManager::GetInstance()->DoHandleEvent(keyEvent, this, stage_);
+    if (result == RET_NOTDO) {
+        CHKPV(keyEventCallback_);
+        keyEventCallback_(keyEvent);
+    }
+}
+
 PluginResult InputPlugin::HandleEvent(libinput_event *event, int64_t frameTime)
 {
     CHKPR(plugin_, PluginResult::NotUse);
     return plugin_->HandleEvent(event, frameTime);
 }
 
+PluginResult InputPlugin::HandleEvent(std::shared_ptr<KeyEvent> keyEvent, InputPluginStage stage)
+{
+    CHKPR(plugin_, PluginResult::NotUse);
+    return plugin_->HandleEvent(keyEvent, stage);
+}
+
 int32_t InputPlugin::AddTimer(std::function<void()> func, int32_t intervalMs, int32_t repeatCount)
 {
     if (timerCnt_ >= MAX_TIMER) {
diff --git a/service/monitor/src/event_pre_monitor_handler.cpp b/service/monitor/src/event_pre_monitor_handler.cpp
index 57ed0e2bbfb0af4d327d9105ded515d04c4bfb7c..7d8160a211e7596d1d09a27e39bcc1b3d0c3b922 100644
--- a/service/monitor/src/event_pre_monitor_handler.cpp
+++ b/service/monitor/src/event_pre_monitor_handler.cpp
@@ -18,6 +18,7 @@
 #include "input_event_data_transformation.h"
 #include "input_event_handler.h"
 #include "util_ex.h"
+#include "multimodal_input_plugin_manager.h"
 
 #undef MMI_LOG_DOMAIN
 #define MMI_LOG_DOMAIN MMI_LOG_HANDLER
@@ -32,7 +33,18 @@ void EventPreMonitorHandler::HandleKeyEvent(const std::shared_ptr<KeyEvent> keyE
     CHKPV(keyEvent);
     OnHandleEvent(keyEvent);
     CHKPV(nextHandler_);
-    nextHandler_->HandleKeyEvent(keyEvent);
+    auto callback = [this](std::shared_ptr<KeyEvent> keyEvent) {
+        this->nextHandler_->HandleKeyEvent(keyEvent);
+    };
+    auto manager = InputPluginManager::GetInstance();
+    if (manager != nullptr) {
+        manager->PluginAssignmentCallBack(callback, InputPluginStage::INPUT_BEFORE_KEYCOMMAND);
+        int32_t result = manager->HandleEvent(keyEvent, InputPluginStage::INPUT_BEFORE_KEYCOMMAND);
+        if (result != 0) {
+            return;
+        }
+    }
+    callback(keyEvent);
 }
 #endif // OHOS_BUILD_ENABLE_KEYBOARD