diff --git a/frameworks/core/components_ng/pattern/xcomponent/BUILD.gn b/frameworks/core/components_ng/pattern/xcomponent/BUILD.gn
index eb8679ab9540ea94ec4a8c6fea298f82fd63b72c..c01abdecb12a8255a493a390d82914ada68c9021 100644
--- a/frameworks/core/components_ng/pattern/xcomponent/BUILD.gn
+++ b/frameworks/core/components_ng/pattern/xcomponent/BUILD.gn
@@ -20,6 +20,7 @@ build_component_ng("xcomponent_pattern_ng") {
     "xcomponent_accessibility_provider.cpp",
     "xcomponent_accessibility_session_adapter.cpp",
     "xcomponent_controller_ng.cpp",
+    "xcomponent_event_manager.cpp",
     "xcomponent_ext_surface_callback_client.cpp",
     "xcomponent_layout_algorithm.cpp",
     "xcomponent_model_ng.cpp",
diff --git a/frameworks/core/components_ng/pattern/xcomponent/xcomponent_event_manager.cpp b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_event_manager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..03d95cd55e5947eee9f528141f89003ae9306c4d
--- /dev/null
+++ b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_event_manager.cpp
@@ -0,0 +1,523 @@
+/*
+ * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "core/components_ng/pattern/xcomponent/xcomponent_pattern.h"
+#include "core/components_ng/pattern/xcomponent/xcomponent_event_manager.h"
+
+#include "interfaces/native/event/ui_input_event_impl.h"
+#include "interfaces/native/ui_input_event.h"
+
+#include "base/utils/utils.h"
+#include "core/common/thread_checker.h"
+#include "core/components/xcomponent/native_interface_xcomponent_impl.h"
+#include "core/components_ng/event/focus_hub.h"
+#include "core/components_ng/event/input_event.h"
+#include "core/components_ng/event/gesture_event_hub.h"
+#include "core/components_ng/pattern/pattern.h"
+#include "core/components_ng/pattern/xcomponent/xcomponent_event_hub.h"
+
+#include "core/event/event_info_convertor.h"
+#include "core/event/key_event.h"
+#include "core/event/mouse_event.h"
+#include "core/event/touch_event.h"
+
+namespace OHOS::Ace::NG {
+
+OH_NativeXComponent_TouchEventType ConvertNativeXComponentTouchEvent(const TouchType& touchType)
+{
+    switch (touchType) {
+        case TouchType::DOWN:
+            return OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_DOWN;
+        case TouchType::UP:
+            return OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_UP;
+        case TouchType::MOVE:
+            return OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_MOVE;
+        case TouchType::CANCEL:
+            return OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_CANCEL;
+        default:
+            return OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_UNKNOWN;
+    }
+}
+
+OH_NativeXComponent_TouchPointToolType ConvertNativeXComponentTouchToolType(const SourceTool& toolType)
+{
+    switch (toolType) {
+        case SourceTool::FINGER:
+            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_FINGER;
+        case SourceTool::PEN:
+            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_PEN;
+        case SourceTool::RUBBER:
+            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_RUBBER;
+        case SourceTool::BRUSH:
+            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_BRUSH;
+        case SourceTool::PENCIL:
+            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_PENCIL;
+        case SourceTool::AIRBRUSH:
+            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_AIRBRUSH;
+        case SourceTool::MOUSE:
+            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_MOUSE;
+        case SourceTool::LENS:
+            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_LENS;
+        default:
+            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_UNKNOWN;
+    }
+}
+
+OH_NativeXComponent_KeyAction ConvertNativeXComponentKeyAction(const KeyAction& keyAction)
+{
+    switch (keyAction) {
+        case KeyAction::DOWN:
+            return OH_NativeXComponent_KeyAction::OH_NATIVEXCOMPONENT_KEY_ACTION_DOWN;
+        case KeyAction::UP:
+            return OH_NativeXComponent_KeyAction::OH_NATIVEXCOMPONENT_KEY_ACTION_UP;
+        default:
+            return OH_NativeXComponent_KeyAction::OH_NATIVEXCOMPONENT_KEY_ACTION_UNKNOWN;
+    }
+}
+
+OH_NativeXComponent_EventSourceType ConvertNativeXComponentEventSourceType(const SourceType& sourceType)
+{
+    switch (sourceType) {
+        case SourceType::MOUSE:
+            return OH_NativeXComponent_EventSourceType::OH_NATIVEXCOMPONENT_SOURCE_TYPE_MOUSE;
+        case SourceType::TOUCH:
+            return OH_NativeXComponent_EventSourceType::OH_NATIVEXCOMPONENT_SOURCE_TYPE_TOUCHSCREEN;
+        case SourceType::TOUCH_PAD:
+            return OH_NativeXComponent_EventSourceType::OH_NATIVEXCOMPONENT_SOURCE_TYPE_TOUCHPAD;
+        case SourceType::KEYBOARD:
+            return OH_NativeXComponent_EventSourceType::OH_NATIVEXCOMPONENT_SOURCE_TYPE_KEYBOARD;
+        default:
+            return OH_NativeXComponent_EventSourceType::OH_NATIVEXCOMPONENT_SOURCE_TYPE_UNKNOWN;
+    }
+}
+
+OH_NativeXComponent_KeyEvent ConvertNativeXComponentKeyEvent(const KeyEvent& event)
+{
+    OH_NativeXComponent_KeyEvent nativeKeyEvent;
+    nativeKeyEvent.action = ConvertNativeXComponentKeyAction(event.action);
+    nativeKeyEvent.code = static_cast<OH_NativeXComponent_KeyCode>(event.code);
+    nativeKeyEvent.sourceType = ConvertNativeXComponentEventSourceType(event.sourceType);
+    nativeKeyEvent.deviceId = event.deviceId;
+    nativeKeyEvent.timestamp = event.timeStamp.time_since_epoch().count();
+    return nativeKeyEvent;
+}
+
+XComponentEventManager::XComponentEventManager(const WeakPtr<XComponentPattern>& xComponentPattern) : weakPattern_(xComponentPattern) {
+    auto pattern = weakPattern_.Upgrade();
+    if (pattern) {
+        auto pair = pattern->GetNativeXComponent();
+        nativeXComponentImpl_ = pair.first;
+        nativeXComponent_ = pair.second.lock();
+    }
+}
+
+void XComponentEventManager::InitEvent()
+{
+    auto pattern = weakPattern_.Upgrade();
+    CHECK_NULL_VOID(pattern);
+    auto host = pattern->GetHost();
+    CHECK_NULL_VOID(host);
+    auto eventHub = host->GetEventHub<XComponentEventHub>();
+    CHECK_NULL_VOID(eventHub);
+    auto gestureHub = eventHub->GetOrCreateGestureEventHub();
+    CHECK_NULL_VOID(gestureHub);
+    InitTouchEvent(gestureHub);
+    InitOnTouchIntercept(gestureHub);
+    auto inputHub = eventHub->GetOrCreateInputEventHub();
+    InitMouseEvent(inputHub);
+    InitAxisEvent(inputHub);
+    InitMouseHoverEvent(inputHub);
+    auto focusHub = host->GetOrCreateFocusHub();
+    CHECK_NULL_VOID(focusHub);
+    InitFocusEvent(focusHub);
+}
+
+void XComponentEventManager::InitTouchEvent(const RefPtr<GestureEventHub>& gestureHub)
+{
+    CHECK_NULL_VOID(!touchEvent_);
+
+    auto touchTask = [weak = AceType::WeakClaim(this)](const TouchEventInfo& info) {
+        if (EventInfoConvertor::IsTouchEventNeedAbandoned(info)) {
+            return;
+        }
+        auto eventManager = weak.Upgrade();
+        CHECK_NULL_VOID(eventManager);
+        eventManager->HandleTouchEvent(info);
+    };
+
+    touchEvent_ = AceType::MakeRefPtr<TouchEventImpl>(std::move(touchTask));
+    gestureHub->AddTouchEvent(touchEvent_);
+}
+
+void XComponentEventManager::InitAxisEvent(const RefPtr<InputEventHub>& inputHub)
+{
+    CHECK_NULL_VOID(!axisEvent_);
+
+    auto axisTask = [weak = AceType::WeakClaim(this)](const AxisInfo& info) {
+        auto eventManager = weak.Upgrade();
+        CHECK_NULL_VOID(eventManager);
+        eventManager->HandleAxisEvent(info);
+    };
+
+    axisEvent_ = AceType::MakeRefPtr<InputEvent>(std::move(axisTask));
+    inputHub->AddOnAxisEvent(axisEvent_);
+}
+
+void XComponentEventManager::InitOnTouchIntercept(const RefPtr<GestureEventHub>& gestureHub)
+{
+    gestureHub->SetOnTouchIntercept(
+        [weak = AceType::WeakClaim(this), weakPattern = weakPattern_](
+            const TouchEventInfo& touchEvent) -> HitTestMode {
+            auto eventManager = weak.Upgrade();
+            CHECK_NULL_RETURN(eventManager, NG::HitTestMode::HTMDEFAULT);
+            auto pattern = weakPattern.Upgrade();
+            CHECK_NULL_RETURN(pattern, NG::HitTestMode::HTMDEFAULT);
+            auto hostNode = pattern->GetHost();
+            CHECK_NULL_RETURN(hostNode, NG::HitTestMode::HTMDEFAULT);
+            CHECK_NULL_RETURN(eventManager->GetNativeXComponentImpl(), hostNode->GetHitTestMode());
+            const auto onTouchInterceptCallback = eventManager->GetNativeXComponentImpl()->GetOnTouchInterceptCallback();
+            CHECK_NULL_RETURN(onTouchInterceptCallback, hostNode->GetHitTestMode());
+            auto event = touchEvent.ConvertToTouchEvent();
+            ArkUI_UIInputEvent uiEvent { ARKUI_UIINPUTEVENT_TYPE_TOUCH, TOUCH_EVENT_ID, &event };
+            return static_cast<NG::HitTestMode>(onTouchInterceptCallback(eventManager->GetNativeXComponent().get(), &uiEvent));
+        });
+}
+
+void XComponentEventManager::InitMouseEvent(const RefPtr<InputEventHub>& inputHub)
+{
+    CHECK_NULL_VOID(!mouseEvent_);
+
+    auto mouseTask = [weak = AceType::WeakClaim(this)](const MouseInfo& info) {
+        auto eventManager = weak.Upgrade();
+        CHECK_NULL_VOID(eventManager);
+        TouchEventInfo touchEventInfo("touchEvent");
+        if (EventInfoConvertor::ConvertMouseToTouchIfNeeded(info, touchEventInfo)) {
+            eventManager->HandleTouchEvent(touchEventInfo);
+            return;
+        }
+        TAG_LOGD(AceLogTag::ACE_XCOMPONENT, "HandleMouseEvent[%{public}f,%{public}f,%{public}d,%{public}d]",
+            info.GetLocalLocation().GetX(), info.GetLocalLocation().GetY(), info.GetAction(), info.GetButton());
+            eventManager->HandleMouseEvent(info);
+    };
+
+    mouseEvent_ = AceType::MakeRefPtr<InputEvent>(std::move(mouseTask));
+    inputHub->AddOnMouseEvent(mouseEvent_);
+}
+
+void XComponentEventManager::InitMouseHoverEvent(const RefPtr<InputEventHub>& inputHub)
+{
+    CHECK_NULL_VOID(!mouseHoverEvent_);
+
+    auto mouseHoverTask = [weak = AceType::WeakClaim(this)](bool isHover) {
+        auto eventManager = weak.Upgrade();
+        CHECK_NULL_VOID(eventManager);
+        eventManager->HandleMouseHoverEvent(isHover);
+    };
+    mouseHoverEvent_ = AceType::MakeRefPtr<InputEvent>(std::move(mouseHoverTask));
+    inputHub->AddOnHoverEvent(mouseHoverEvent_);
+}
+
+void XComponentEventManager::InitFocusEvent(const RefPtr<FocusHub>& focusHub)
+{
+#ifdef RENDER_EXTRACT_SUPPORTED
+    focusHub->SetFocusable(true);
+#endif
+
+    auto onFocusEvent = [weak = WeakClaim(this)]() {
+        auto eventManager = weak.Upgrade();
+        CHECK_NULL_VOID(eventManager);
+        return eventManager->HandleFocusEvent();
+    };
+    focusHub->SetOnFocusInternal(std::move(onFocusEvent));
+
+    auto onKeyEvent = [weak = WeakClaim(this)](const KeyEvent& event) -> bool {
+        auto eventManager = weak.Upgrade();
+        CHECK_NULL_RETURN(eventManager, false);
+        return eventManager->HandleKeyEvent(event);
+    };
+    focusHub->SetOnKeyEventInternal(std::move(onKeyEvent));
+
+    auto onBlurEvent = [weak = AceType::WeakClaim(this)]() {
+        auto eventManager = weak.Upgrade();
+        CHECK_NULL_VOID(eventManager);
+        return eventManager->HandleBlurEvent();
+    };
+    focusHub->SetOnBlurInternal(std::move(onBlurEvent));
+}
+
+void XComponentEventManager::HandleTouchEvent(const TouchEventInfo& info) {
+    auto touchInfoList = info.GetChangedTouches();
+    if (touchInfoList.empty()) {
+        return;
+    }
+    auto pattern = weakPattern_.Upgrade();
+    CHECK_NULL_VOID(pattern);
+    const auto& touchInfo = touchInfoList.front();
+    const auto& screenOffset = touchInfo.GetGlobalLocation();
+    const auto& localOffset = touchInfo.GetLocalLocation();
+    touchEventPoint_.id = touchInfo.GetFingerId();
+    touchEventPoint_.screenX = static_cast<float>(screenOffset.GetX());
+    touchEventPoint_.screenY = static_cast<float>(screenOffset.GetY());
+    touchEventPoint_.x = static_cast<float>(localOffset.GetX());
+    touchEventPoint_.y = static_cast<float>(localOffset.GetY());
+    touchEventPoint_.size = touchInfo.GetSize();
+    touchEventPoint_.force = touchInfo.GetForce();
+    touchEventPoint_.deviceId = touchInfo.GetTouchDeviceId();
+    const auto timeStamp = info.GetTimeStamp().time_since_epoch().count();
+    touchEventPoint_.timeStamp = timeStamp;
+    auto touchType = touchInfoList.front().GetTouchType();
+    touchEventPoint_.type = ConvertNativeXComponentTouchEvent(touchType);
+    TAG_LOGD(AceLogTag::ACE_XCOMPONENT, "HandleTouchEvent[%{public}f,%{public}f,%{public}d,%{public}zu,%{public}u]",
+             localOffset.GetX(), localOffset.GetY(), touchInfo.GetFingerId(), touchInfoList.front().GetTouchType(),
+             static_cast<uint32_t>(touchInfo.GetSize()));
+    ConvertTouchPoint(info.GetTouches(), timeStamp, touchType);
+
+    if (nativeXComponent_ && nativeXComponentImpl_) {
+        nativeXComponentImpl_->SetHistoricalPoint(ConvertHistoryPoint(info.GetHistory()));
+        nativeXComponentImpl_->SetCurrentSourceType(
+            { touchInfo.GetFingerId(), ConvertNativeXComponentEventSourceType(info.GetSourceDevice()) });
+    }
+    NativeXComponentDispatchTouchEvent(touchEventPoint_, nativeXComponentTouchPoints_);
+
+#ifdef RENDER_EXTRACT_SUPPORTED
+    if (touchType == TouchType::DOWN) {
+        pattern->RequestFocus();
+    }
+#endif
+}
+
+void XComponentEventManager::HandleFocusEvent()
+{
+    CHECK_NULL_VOID(nativeXComponent_);
+    CHECK_NULL_VOID(nativeXComponentImpl_);
+    auto* surface = const_cast<void*>(nativeXComponentImpl_->GetSurface());
+    const auto focusEventCallback = nativeXComponentImpl_->GetFocusEventCallback();
+    CHECK_NULL_VOID(focusEventCallback);
+    focusEventCallback(nativeXComponent_.get(), surface);
+}
+
+bool XComponentEventManager::HandleKeyEvent(const KeyEvent& event)
+{
+    CHECK_NULL_RETURN(nativeXComponent_, false);
+    CHECK_NULL_RETURN(nativeXComponentImpl_, false);
+
+    OH_NativeXComponent_KeyEvent keyEvent = ConvertNativeXComponentKeyEvent(event);
+    nativeXComponentImpl_->SetKeyEvent(keyEvent);
+
+    auto* surface = const_cast<void*>(nativeXComponentImpl_->GetSurface());
+    const auto keyEventCallbackWithResult = nativeXComponentImpl_->GetKeyEventCallbackWithResult();
+    if (keyEventCallbackWithResult) {
+        return keyEventCallbackWithResult(nativeXComponent_.get(), surface);
+    }
+    const auto keyEventCallback = nativeXComponentImpl_->GetKeyEventCallback();
+    CHECK_NULL_RETURN(keyEventCallback, false);
+    keyEventCallback(nativeXComponent_.get(), surface);
+    return false;
+}
+
+void XComponentEventManager::HandleBlurEvent()
+{
+    CHECK_NULL_VOID(nativeXComponent_);
+    CHECK_NULL_VOID(nativeXComponentImpl_);
+    auto* surface = const_cast<void*>(nativeXComponentImpl_->GetSurface());
+    const auto blurEventCallback = nativeXComponentImpl_->GetBlurEventCallback();
+    CHECK_NULL_VOID(blurEventCallback);
+    blurEventCallback(nativeXComponent_.get(), surface);
+}
+
+void XComponentEventManager::HandleMouseEvent(const MouseInfo& info) {
+    OH_NativeXComponent_MouseEvent mouseEventPoint;
+    mouseEventPoint.x = static_cast<float>(info.GetLocalLocation().GetX());
+    mouseEventPoint.y = static_cast<float>(info.GetLocalLocation().GetY());
+    mouseEventPoint.screenX = static_cast<float>(info.GetScreenLocation().GetX());
+    mouseEventPoint.screenY = static_cast<float>(info.GetScreenLocation().GetY());
+    switch (info.GetAction()) {
+        case MouseAction::PRESS:
+            mouseEventPoint.action = OH_NativeXComponent_MouseEventAction::OH_NATIVEXCOMPONENT_MOUSE_PRESS;
+            break;
+        case MouseAction::RELEASE:
+            mouseEventPoint.action = OH_NativeXComponent_MouseEventAction::OH_NATIVEXCOMPONENT_MOUSE_RELEASE;
+            break;
+        case MouseAction::MOVE:
+            mouseEventPoint.action = OH_NativeXComponent_MouseEventAction::OH_NATIVEXCOMPONENT_MOUSE_MOVE;
+            break;
+        case MouseAction::CANCEL:
+            mouseEventPoint.action = OH_NativeXComponent_MouseEventAction::OH_NATIVEXCOMPONENT_MOUSE_CANCEL;
+            break;
+        default:
+            mouseEventPoint.action = OH_NativeXComponent_MouseEventAction::OH_NATIVEXCOMPONENT_MOUSE_NONE;
+            break;
+    }
+    switch (info.GetButton()) {
+        case MouseButton::LEFT_BUTTON:
+            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_LEFT_BUTTON;
+            break;
+
+        case MouseButton::RIGHT_BUTTON:
+            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_RIGHT_BUTTON;
+            break;
+        case MouseButton::MIDDLE_BUTTON:
+            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_MIDDLE_BUTTON;
+            break;
+        case MouseButton::BACK_BUTTON:
+            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_BACK_BUTTON;
+            break;
+        case MouseButton::FORWARD_BUTTON:
+            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_FORWARD_BUTTON;
+            break;
+        default:
+            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_NONE_BUTTON;
+            break;
+    }
+    mouseEventPoint.timestamp = info.GetTimeStamp().time_since_epoch().count();
+    NativeXComponentDispatchMouseEvent(mouseEventPoint);
+}
+
+void XComponentEventManager::HandleAxisEvent(const AxisInfo& info) {
+    auto axisEvent = info.ConvertToAxisEvent();
+    NativeXComponentDispatchAxisEvent(&axisEvent);
+}
+
+void XComponentEventManager::HandleMouseHoverEvent(bool isHover) {
+    CHECK_RUN_ON(UI);
+    CHECK_NULL_VOID(nativeXComponent_);
+    CHECK_NULL_VOID(nativeXComponentImpl_);
+    const auto* callback = nativeXComponentImpl_->GetMouseEventCallback();
+    CHECK_NULL_VOID(callback);
+    CHECK_NULL_VOID(callback->DispatchHoverEvent);
+    callback->DispatchHoverEvent(nativeXComponent_.get(), isHover);
+}
+
+void XComponentEventManager::NativeXComponentDispatchTouchEvent(
+    const OH_NativeXComponent_TouchEvent& touchEvent, const std::vector<XComponentTouchPoint>& xComponentTouchPoints)
+{
+    CHECK_RUN_ON(UI);
+    CHECK_NULL_VOID(nativeXComponent_);
+    CHECK_NULL_VOID(nativeXComponentImpl_);
+    nativeXComponentImpl_->SetTouchEvent(touchEvent);
+    nativeXComponentImpl_->SetTouchPoint(xComponentTouchPoints);
+    auto* surface = const_cast<void*>(nativeXComponentImpl_->GetSurface());
+    const auto* callback = nativeXComponentImpl_->GetCallback();
+    CHECK_NULL_VOID(callback);
+    CHECK_NULL_VOID(callback->DispatchTouchEvent);
+    callback->DispatchTouchEvent(nativeXComponent_.get(), surface);
+}
+
+void XComponentEventManager::NativeXComponentDispatchMouseEvent(const OH_NativeXComponent_MouseEvent& mouseEvent)
+{
+    CHECK_RUN_ON(UI);
+    CHECK_NULL_VOID(nativeXComponent_);
+    CHECK_NULL_VOID(nativeXComponentImpl_);
+    nativeXComponentImpl_->SetMouseEvent(mouseEvent);
+    auto* surface = const_cast<void*>(nativeXComponentImpl_->GetSurface());
+    const auto* callback = nativeXComponentImpl_->GetMouseEventCallback();
+    CHECK_NULL_VOID(callback);
+    CHECK_NULL_VOID(callback->DispatchMouseEvent);
+    callback->DispatchMouseEvent(nativeXComponent_.get(), surface);
+}
+
+void XComponentEventManager::NativeXComponentDispatchAxisEvent(AxisEvent* axisEvent)
+{
+    CHECK_RUN_ON(UI);
+    CHECK_NULL_VOID(nativeXComponent_);
+    CHECK_NULL_VOID(nativeXComponentImpl_);
+    const auto callback = nativeXComponentImpl_->GetUIAxisEventCallback();
+    CHECK_NULL_VOID(callback);
+    ArkUI_UIInputEvent uiEvent { ARKUI_UIINPUTEVENT_TYPE_AXIS, AXIS_EVENT_ID, axisEvent };
+    callback(nativeXComponent_.get(), &uiEvent, ArkUI_UIInputEvent_Type::ARKUI_UIINPUTEVENT_TYPE_AXIS);
+}
+
+void XComponentEventManager::ConvertTouchPoint(
+    const std::list<TouchLocationInfo>& touchInfoList, const int64_t timeStamp, const TouchType& touchType)
+{
+    touchEventPoint_.numPoints =
+        touchInfoList.size() <= OH_MAX_TOUCH_POINTS_NUMBER ? touchInfoList.size() : OH_MAX_TOUCH_POINTS_NUMBER;
+    nativeXComponentTouchPoints_.clear();
+    uint32_t index = 0;
+    for (auto iterator = touchInfoList.begin(); iterator != touchInfoList.end() && index < OH_MAX_TOUCH_POINTS_NUMBER;
+         iterator++) {
+        OH_NativeXComponent_TouchPoint ohTouchPoint;
+        const auto& pointTouchInfo = *iterator;
+        const auto& pointWindowOffset = pointTouchInfo.GetGlobalLocation();
+        const auto& pointLocalOffset = pointTouchInfo.GetLocalLocation();
+        const auto& pointDisplayOffset = pointTouchInfo.GetScreenLocation();
+        ohTouchPoint.id = pointTouchInfo.GetFingerId();
+        // screenX and screenY implementation wrong but should not modify for maintaining compatibility
+        ohTouchPoint.screenX = static_cast<float>(pointWindowOffset.GetX());
+        ohTouchPoint.screenY = static_cast<float>(pointWindowOffset.GetY());
+        ohTouchPoint.x = static_cast<float>(pointLocalOffset.GetX());
+        ohTouchPoint.y = static_cast<float>(pointLocalOffset.GetY());
+        ohTouchPoint.type = ConvertNativeXComponentTouchEvent(touchType);
+        ohTouchPoint.size = pointTouchInfo.GetSize();
+        ohTouchPoint.force = pointTouchInfo.GetForce();
+        ohTouchPoint.timeStamp = timeStamp;
+        ohTouchPoint.isPressed = (touchType == TouchType::DOWN);
+        touchEventPoint_.touchPoints[index++] = ohTouchPoint;
+        // set tiltX, tiltY, windowX, windowY, displayX, displayY and sourceToolType
+        XComponentTouchPoint xcomponentTouchPoint;
+        xcomponentTouchPoint.tiltX = pointTouchInfo.GetTiltX().value_or(0.0f);
+        xcomponentTouchPoint.tiltY = pointTouchInfo.GetTiltY().value_or(0.0f);
+        xcomponentTouchPoint.windowX = static_cast<float>(pointWindowOffset.GetX());
+        xcomponentTouchPoint.windowY = static_cast<float>(pointWindowOffset.GetY());
+        xcomponentTouchPoint.displayX = static_cast<float>(pointDisplayOffset.GetX());
+        xcomponentTouchPoint.displayY = static_cast<float>(pointDisplayOffset.GetY());
+        xcomponentTouchPoint.sourceToolType = ConvertNativeXComponentTouchToolType(pointTouchInfo.GetSourceTool());
+        nativeXComponentTouchPoints_.emplace_back(xcomponentTouchPoint);
+    }
+    while (index < OH_MAX_TOUCH_POINTS_NUMBER) {
+        OH_NativeXComponent_TouchPoint ohTouchPoint;
+        ohTouchPoint.id = 0;
+        ohTouchPoint.screenX = 0;
+        ohTouchPoint.screenY = 0;
+        ohTouchPoint.x = 0;
+        ohTouchPoint.y = 0;
+        ohTouchPoint.type = OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_UNKNOWN;
+        ohTouchPoint.size = 0;
+        ohTouchPoint.force = 0;
+        ohTouchPoint.timeStamp = 0;
+        ohTouchPoint.isPressed = false;
+        touchEventPoint_.touchPoints[index++] = ohTouchPoint;
+    }
+}
+
+std::vector<OH_NativeXComponent_HistoricalPoint> XComponentEventManager::ConvertHistoryPoint(
+    const std::list<TouchLocationInfo>& touchInfoList)
+{
+    std::vector<OH_NativeXComponent_HistoricalPoint> historicalPoints;
+    for (auto&& item : touchInfoList) {
+        OH_NativeXComponent_HistoricalPoint point;
+        point.id = item.GetFingerId();
+        point.x = item.GetLocalLocation().GetX();
+        point.y = item.GetLocalLocation().GetY();
+        point.screenX = item.GetScreenLocation().GetX();
+        point.screenY = item.GetScreenLocation().GetY();
+        point.type = static_cast<OH_NativeXComponent_TouchEventType>(item.GetTouchType());
+        point.size = item.GetSize();
+        point.force = item.GetForce();
+        point.timeStamp = item.GetTimeStamp().time_since_epoch().count();
+        point.titlX = item.GetTiltX().value_or(0.0f);
+        point.titlY = item.GetTiltY().value_or(0.0f);
+        point.sourceTool = static_cast<OH_NativeXComponent_TouchEvent_SourceTool>(item.GetSourceTool());
+
+        historicalPoints.push_back(point);
+    }
+    return historicalPoints;
+}
+
+} // namespace OHOS::Ace::NG
diff --git a/frameworks/core/components_ng/pattern/xcomponent/xcomponent_event_manager.h b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_event_manager.h
new file mode 100644
index 0000000000000000000000000000000000000000..c871b007b27a9d9d0ab43a4b4b18c9dd2dc82dd9
--- /dev/null
+++ b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_event_manager.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_XCOMPONENT_XCOMPONENT_EVENT_MANAGER_H
+#define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_XCOMPONENT_XCOMPONENT_EVENT_MANAGER_H
+
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "base/memory/referenced.h"
+#include "base/memory/ace_type.h"
+#include "base/utils/utils.h"
+#include "core/common/thread_checker.h"
+#include "core/components/common/layout/constants.h"
+#include "core/components/xcomponent/native_interface_xcomponent_impl.h"
+#include "core/components_ng/event/focus_hub.h"
+#include "core/components_ng/event/input_event.h"
+#include "core/components_ng/pattern/xcomponent/xcomponent_event_hub.h"
+
+namespace OHOS::Ace::NG {
+class XComponentPattern;
+class XComponentEventManager : public AceType  {
+    DECLARE_ACE_TYPE(XComponentEventManager, AceType);
+public:
+    XComponentEventManager(const WeakPtr<XComponentPattern>& xComponentPattern);
+    ~XComponentEventManager() = default;
+    void InitEvent();
+    RefPtr<NativeXComponentImpl> GetNativeXComponentImpl() {
+        return nativeXComponentImpl_;
+    }
+
+    std::shared_ptr<OH_NativeXComponent> GetNativeXComponent() {
+        return nativeXComponent_;
+    }
+
+private:
+    void InitTouchEvent(const RefPtr<GestureEventHub>& gestureHub);
+    void InitOnTouchIntercept(const RefPtr<GestureEventHub>& gestureHub);
+    void InitAxisEvent(const RefPtr<InputEventHub>& inputHub);
+    void InitMouseEvent(const RefPtr<InputEventHub>& inputHub);
+    void InitMouseHoverEvent(const RefPtr<InputEventHub>& inputHub);
+    void InitFocusEvent(const RefPtr<FocusHub>& focusHub);
+
+    void HandleTouchEvent(const TouchEventInfo& info);
+    void HandleMouseEvent(const MouseInfo& info);
+    void HandleAxisEvent(const AxisInfo& info);
+    void HandleMouseHoverEvent(bool isHover);
+    void HandleFocusEvent();
+    bool HandleKeyEvent(const KeyEvent& event);
+    void HandleBlurEvent();
+
+    void ConvertTouchPoint(
+        const std::list<TouchLocationInfo>& touchInfoList, int64_t timeStamp, const TouchType& touchType);
+    std::vector<OH_NativeXComponent_HistoricalPoint> ConvertHistoryPoint(
+        const std::list<TouchLocationInfo>& touchInfoList);
+    void NativeXComponentDispatchTouchEvent(const OH_NativeXComponent_TouchEvent& touchEvent,
+        const std::vector<XComponentTouchPoint>& xComponentTouchPoints);
+    void NativeXComponentDispatchMouseEvent(const OH_NativeXComponent_MouseEvent& mouseEvent);
+    void NativeXComponentDispatchAxisEvent(AxisEvent* axisEvent);
+
+    WeakPtr<XComponentPattern> weakPattern_;
+    std::shared_ptr<OH_NativeXComponent> nativeXComponent_;
+    RefPtr<NativeXComponentImpl> nativeXComponentImpl_;
+
+    RefPtr<TouchEventImpl> touchEvent_;
+    OH_NativeXComponent_TouchEvent touchEventPoint_ = {};
+    RefPtr<InputEvent> mouseEvent_;
+    RefPtr<InputEvent> axisEvent_;
+    RefPtr<InputEvent> mouseHoverEvent_;
+    std::vector<XComponentTouchPoint> nativeXComponentTouchPoints_;
+};
+} // namespace OHOS::Ace::NG
+
+#endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_XCOMPONENT_XCOMPONENT_EVENT_MANAGER_H
diff --git a/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.cpp b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.cpp
index 8ba67f788d389906dadbc739f698efd388681870..d73ff8be45abc9a390db8833d2909b392d74663a 100644
--- a/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.cpp
+++ b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.cpp
@@ -50,6 +50,7 @@
 #include "core/components_ng/pattern/xcomponent/xcomponent_accessibility_child_tree_callback.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_accessibility_session_adapter.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_event_hub.h"
+// #include "core/components_ng/pattern/xcomponent/xcomponent_event_manager.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_ext_surface_callback_client.h"
 #include "core/event/event_info_convertor.h"
 #include "core/event/key_event.h"
@@ -71,85 +72,6 @@ std::string XComponentRenderFitToString(RenderFit renderFit)
     return renderFitStyles[static_cast<int>(renderFit)];
 }
 
-OH_NativeXComponent_TouchEventType ConvertNativeXComponentTouchEvent(const TouchType& touchType)
-{
-    switch (touchType) {
-        case TouchType::DOWN:
-            return OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_DOWN;
-        case TouchType::UP:
-            return OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_UP;
-        case TouchType::MOVE:
-            return OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_MOVE;
-        case TouchType::CANCEL:
-            return OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_CANCEL;
-        default:
-            return OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_UNKNOWN;
-    }
-}
-
-OH_NativeXComponent_TouchPointToolType ConvertNativeXComponentTouchToolType(const SourceTool& toolType)
-{
-    switch (toolType) {
-        case SourceTool::FINGER:
-            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_FINGER;
-        case SourceTool::PEN:
-            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_PEN;
-        case SourceTool::RUBBER:
-            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_RUBBER;
-        case SourceTool::BRUSH:
-            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_BRUSH;
-        case SourceTool::PENCIL:
-            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_PENCIL;
-        case SourceTool::AIRBRUSH:
-            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_AIRBRUSH;
-        case SourceTool::MOUSE:
-            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_MOUSE;
-        case SourceTool::LENS:
-            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_LENS;
-        default:
-            return OH_NativeXComponent_TouchPointToolType::OH_NATIVEXCOMPONENT_TOOL_TYPE_UNKNOWN;
-    }
-}
-
-OH_NativeXComponent_KeyAction ConvertNativeXComponentKeyAction(const KeyAction& keyAction)
-{
-    switch (keyAction) {
-        case KeyAction::DOWN:
-            return OH_NativeXComponent_KeyAction::OH_NATIVEXCOMPONENT_KEY_ACTION_DOWN;
-        case KeyAction::UP:
-            return OH_NativeXComponent_KeyAction::OH_NATIVEXCOMPONENT_KEY_ACTION_UP;
-        default:
-            return OH_NativeXComponent_KeyAction::OH_NATIVEXCOMPONENT_KEY_ACTION_UNKNOWN;
-    }
-}
-
-OH_NativeXComponent_EventSourceType ConvertNativeXComponentEventSourceType(const SourceType& sourceType)
-{
-    switch (sourceType) {
-        case SourceType::MOUSE:
-            return OH_NativeXComponent_EventSourceType::OH_NATIVEXCOMPONENT_SOURCE_TYPE_MOUSE;
-        case SourceType::TOUCH:
-            return OH_NativeXComponent_EventSourceType::OH_NATIVEXCOMPONENT_SOURCE_TYPE_TOUCHSCREEN;
-        case SourceType::TOUCH_PAD:
-            return OH_NativeXComponent_EventSourceType::OH_NATIVEXCOMPONENT_SOURCE_TYPE_TOUCHPAD;
-        case SourceType::KEYBOARD:
-            return OH_NativeXComponent_EventSourceType::OH_NATIVEXCOMPONENT_SOURCE_TYPE_KEYBOARD;
-        default:
-            return OH_NativeXComponent_EventSourceType::OH_NATIVEXCOMPONENT_SOURCE_TYPE_UNKNOWN;
-    }
-}
-
-OH_NativeXComponent_KeyEvent ConvertNativeXComponentKeyEvent(const KeyEvent& event)
-{
-    OH_NativeXComponent_KeyEvent nativeKeyEvent;
-    nativeKeyEvent.action = ConvertNativeXComponentKeyAction(event.action);
-    nativeKeyEvent.code = static_cast<OH_NativeXComponent_KeyCode>(event.code);
-    nativeKeyEvent.sourceType = ConvertNativeXComponentEventSourceType(event.sourceType);
-    nativeKeyEvent.deviceId = event.deviceId;
-    nativeKeyEvent.timestamp = event.timeStamp.time_since_epoch().count();
-    return nativeKeyEvent;
-}
-
 ArkUI_XComponent_ImageAnalyzerState ConvertNativeXComponentAnalyzerStatus(const ImageAnalyzerState state)
 {
     switch (state) {
@@ -179,6 +101,8 @@ XComponentPattern::XComponentPattern(const std::optional<std::string>& id, XComp
         InitNativeXComponent();
     }
     RegisterSurfaceCallbackModeEvent();
+    // eventManager_ = std::make_shared<XComponentEventManager>(WeakClaim(this));
+    eventManager_ = AceType::MakeRefPtr<XComponentEventManager>(WeakClaim(this));
 }
 
 std::string XComponentPattern::XComponentTypeToString(XComponentType type)
@@ -299,6 +223,12 @@ void XComponentPattern::InitSurface()
     surfaceId_ = renderSurface_->GetUniqueId();
 
     UpdateTransformHint();
+
+    auto eventHub = host->GetEventHub<XComponentEventHub>();
+    CHECK_NULL_VOID(eventHub);
+    if (id_.has_value()) {
+        eventHub->SetOnSurfaceInitEvent(CreateExternalEvent());
+    }
 }
 
 void XComponentPattern::UpdateTransformHint()
@@ -1042,380 +972,8 @@ void XComponentPattern::InitNativeNodeCallbacks()
 
 void XComponentPattern::InitEvent()
 {
-    auto host = GetHost();
-    CHECK_NULL_VOID(host);
-    auto eventHub = host->GetEventHub<XComponentEventHub>();
-    CHECK_NULL_VOID(eventHub);
-    if (id_.has_value()) {
-        eventHub->SetOnSurfaceInitEvent(CreateExternalEvent());
-    }
-    auto gestureHub = eventHub->GetOrCreateGestureEventHub();
-    CHECK_NULL_VOID(gestureHub);
-    InitTouchEvent(gestureHub);
-    InitOnTouchIntercept(gestureHub);
-    auto inputHub = eventHub->GetOrCreateInputEventHub();
-    InitMouseEvent(inputHub);
-    InitAxisEvent(inputHub);
-    InitMouseHoverEvent(inputHub);
-    auto focusHub = host->GetOrCreateFocusHub();
-    CHECK_NULL_VOID(focusHub);
-    InitFocusEvent(focusHub);
-}
-
-void XComponentPattern::InitFocusEvent(const RefPtr<FocusHub>& focusHub)
-{
-#ifdef RENDER_EXTRACT_SUPPORTED
-    focusHub->SetFocusable(true);
-#endif
-
-    auto onFocusEvent = [weak = WeakClaim(this)]() {
-        auto pattern = weak.Upgrade();
-        CHECK_NULL_VOID(pattern);
-        return pattern->HandleFocusEvent();
-    };
-    focusHub->SetOnFocusInternal(std::move(onFocusEvent));
-
-    auto onKeyEvent = [weak = WeakClaim(this)](const KeyEvent& event) -> bool {
-        TAG_LOGD(AceLogTag::ACE_XCOMPONENT, "HandleKeyEvent[%{public}d,%{public}d,%{public}d,%{public}" PRId64 "]",
-            event.action, event.code, event.sourceType, event.deviceId);
-        auto pattern = weak.Upgrade();
-        CHECK_NULL_RETURN(pattern, false);
-        return pattern->HandleKeyEvent(event);
-    };
-    focusHub->SetOnKeyEventInternal(std::move(onKeyEvent));
-
-    auto onBlurEvent = [weak = WeakClaim(this)]() {
-        auto pattern = weak.Upgrade();
-        CHECK_NULL_VOID(pattern);
-        return pattern->HandleBlurEvent();
-    };
-    focusHub->SetOnBlurInternal(std::move(onBlurEvent));
-}
-void XComponentPattern::HandleFocusEvent()
-{
-    CHECK_NULL_VOID(nativeXComponent_);
-    CHECK_NULL_VOID(nativeXComponentImpl_);
-    auto* surface = const_cast<void*>(nativeXComponentImpl_->GetSurface());
-    const auto focusEventCallback = nativeXComponentImpl_->GetFocusEventCallback();
-    CHECK_NULL_VOID(focusEventCallback);
-    focusEventCallback(nativeXComponent_.get(), surface);
-}
-
-bool XComponentPattern::HandleKeyEvent(const KeyEvent& event)
-{
-    CHECK_NULL_RETURN(nativeXComponent_, false);
-    CHECK_NULL_RETURN(nativeXComponentImpl_, false);
-
-    OH_NativeXComponent_KeyEvent keyEvent = ConvertNativeXComponentKeyEvent(event);
-    nativeXComponentImpl_->SetKeyEvent(keyEvent);
-
-    auto* surface = const_cast<void*>(nativeXComponentImpl_->GetSurface());
-    const auto keyEventCallbackWithResult = nativeXComponentImpl_->GetKeyEventCallbackWithResult();
-    if (keyEventCallbackWithResult) {
-        return keyEventCallbackWithResult(nativeXComponent_.get(), surface);
-    }
-    const auto keyEventCallback = nativeXComponentImpl_->GetKeyEventCallback();
-    CHECK_NULL_RETURN(keyEventCallback, false);
-    keyEventCallback(nativeXComponent_.get(), surface);
-    return false;
-}
-
-void XComponentPattern::HandleBlurEvent()
-{
-    CHECK_NULL_VOID(nativeXComponent_);
-    CHECK_NULL_VOID(nativeXComponentImpl_);
-    auto* surface = const_cast<void*>(nativeXComponentImpl_->GetSurface());
-    const auto blurEventCallback = nativeXComponentImpl_->GetBlurEventCallback();
-    CHECK_NULL_VOID(blurEventCallback);
-    blurEventCallback(nativeXComponent_.get(), surface);
-}
-
-void XComponentPattern::InitTouchEvent(const RefPtr<GestureEventHub>& gestureHub)
-{
-    CHECK_NULL_VOID(!touchEvent_);
-
-    auto touchTask = [weak = WeakClaim(this)](const TouchEventInfo& info) {
-        if (EventInfoConvertor::IsTouchEventNeedAbandoned(info)) {
-            return;
-        }
-        auto pattern = weak.Upgrade();
-        CHECK_NULL_VOID(pattern);
-        pattern->HandleTouchEvent(info);
-    };
-
-    touchEvent_ = MakeRefPtr<TouchEventImpl>(std::move(touchTask));
-    gestureHub->AddTouchEvent(touchEvent_);
-}
-
-void XComponentPattern::InitAxisEvent(const RefPtr<InputEventHub>& inputHub)
-{
-    CHECK_NULL_VOID(!axisEvent_);
-
-    auto axisTask = [weak = WeakClaim(this)](const AxisInfo& info) {
-        auto pattern = weak.Upgrade();
-        CHECK_NULL_VOID(pattern);
-        pattern->HandleAxisEvent(info);
-    };
-
-    axisEvent_ = MakeRefPtr<InputEvent>(std::move(axisTask));
-    inputHub->AddOnAxisEvent(axisEvent_);
-}
-
-void XComponentPattern::InitOnTouchIntercept(const RefPtr<GestureEventHub>& gestureHub)
-{
-    gestureHub->SetOnTouchIntercept(
-        [weak = WeakClaim(this)](
-            const TouchEventInfo& touchEvent) -> HitTestMode {
-            auto pattern = weak.Upgrade();
-            CHECK_NULL_RETURN(pattern, NG::HitTestMode::HTMDEFAULT);
-            auto hostNode = pattern->GetHost();
-            CHECK_NULL_RETURN(hostNode, NG::HitTestMode::HTMDEFAULT);
-            CHECK_NULL_RETURN(pattern->nativeXComponentImpl_, hostNode->GetHitTestMode());
-            const auto onTouchInterceptCallback = pattern->nativeXComponentImpl_->GetOnTouchInterceptCallback();
-            CHECK_NULL_RETURN(onTouchInterceptCallback, hostNode->GetHitTestMode());
-            auto event = touchEvent.ConvertToTouchEvent();
-            ArkUI_UIInputEvent uiEvent { ARKUI_UIINPUTEVENT_TYPE_TOUCH, TOUCH_EVENT_ID, &event };
-            return static_cast<NG::HitTestMode>(onTouchInterceptCallback(pattern->nativeXComponent_.get(), &uiEvent));
-        });
-}
-
-void XComponentPattern::InitMouseEvent(const RefPtr<InputEventHub>& inputHub)
-{
-    CHECK_NULL_VOID(!mouseEvent_);
-
-    auto mouseTask = [weak = WeakClaim(this)](const MouseInfo& info) {
-        auto pattern = weak.Upgrade();
-        CHECK_NULL_VOID(pattern);
-        TouchEventInfo touchEventInfo("touchEvent");
-        if (EventInfoConvertor::ConvertMouseToTouchIfNeeded(info, touchEventInfo)) {
-            pattern->HandleTouchEvent(touchEventInfo);
-            return;
-        }
-        TAG_LOGD(AceLogTag::ACE_XCOMPONENT, "HandleMouseEvent[%{public}f,%{public}f,%{public}d,%{public}d]",
-            info.GetLocalLocation().GetX(), info.GetLocalLocation().GetY(), info.GetAction(), info.GetButton());
-        pattern->HandleMouseEvent(info);
-    };
-
-    mouseEvent_ = MakeRefPtr<InputEvent>(std::move(mouseTask));
-    inputHub->AddOnMouseEvent(mouseEvent_);
-}
-
-void XComponentPattern::InitMouseHoverEvent(const RefPtr<InputEventHub>& inputHub)
-{
-    CHECK_NULL_VOID(!mouseHoverEvent_);
-    auto mouseHoverTask = [weak = WeakClaim(this)](bool isHover) {
-        auto pattern = weak.Upgrade();
-        CHECK_NULL_VOID(pattern);
-        pattern->HandleMouseHoverEvent(isHover);
-    };
-    mouseHoverEvent_ = MakeRefPtr<InputEvent>(std::move(mouseHoverTask));
-    inputHub->AddOnHoverEvent(mouseHoverEvent_);
-}
-
-void XComponentPattern::HandleTouchEvent(const TouchEventInfo& info)
-{
-    auto touchInfoList = info.GetChangedTouches();
-    if (touchInfoList.empty()) {
-        return;
-    }
-    const auto& touchInfo = touchInfoList.front();
-    const auto& screenOffset = touchInfo.GetGlobalLocation();
-    const auto& localOffset = touchInfo.GetLocalLocation();
-    touchEventPoint_.id = touchInfo.GetFingerId();
-    touchEventPoint_.screenX = static_cast<float>(screenOffset.GetX());
-    touchEventPoint_.screenY = static_cast<float>(screenOffset.GetY());
-    touchEventPoint_.x = static_cast<float>(localOffset.GetX());
-    touchEventPoint_.y = static_cast<float>(localOffset.GetY());
-    touchEventPoint_.size = touchInfo.GetSize();
-    touchEventPoint_.force = touchInfo.GetForce();
-    touchEventPoint_.deviceId = touchInfo.GetTouchDeviceId();
-    const auto timeStamp = info.GetTimeStamp().time_since_epoch().count();
-    touchEventPoint_.timeStamp = timeStamp;
-    auto touchType = touchInfoList.front().GetTouchType();
-    touchEventPoint_.type = ConvertNativeXComponentTouchEvent(touchType);
-    TAG_LOGD(AceLogTag::ACE_XCOMPONENT, "HandleTouchEvent[%{public}f,%{public}f,%{public}d,%{public}zu,%{public}u]",
-        localOffset.GetX(), localOffset.GetY(), touchInfo.GetFingerId(), touchInfoList.front().GetTouchType(),
-        static_cast<uint32_t>(touchInfo.GetSize()));
-    SetTouchPoint(info.GetTouches(), timeStamp, touchType);
-
-    if (nativeXComponent_ && nativeXComponentImpl_) {
-        nativeXComponentImpl_->SetHistoricalPoint(SetHistoryPoint(info.GetHistory()));
-        nativeXComponentImpl_->SetCurrentSourceType(
-            { touchInfo.GetFingerId(), ConvertNativeXComponentEventSourceType(info.GetSourceDevice()) });
-    }
-    NativeXComponentDispatchTouchEvent(touchEventPoint_, nativeXComponentTouchPoints_);
-
-#ifdef RENDER_EXTRACT_SUPPORTED
-    if (touchType == TouchType::DOWN) {
-        RequestFocus();
-    }
-#endif
-}
-
-void XComponentPattern::HandleMouseEvent(const MouseInfo& info)
-{
-    OH_NativeXComponent_MouseEvent mouseEventPoint;
-    mouseEventPoint.x = static_cast<float>(info.GetLocalLocation().GetX());
-    mouseEventPoint.y = static_cast<float>(info.GetLocalLocation().GetY());
-    mouseEventPoint.screenX = static_cast<float>(info.GetScreenLocation().GetX());
-    mouseEventPoint.screenY = static_cast<float>(info.GetScreenLocation().GetY());
-    switch (info.GetAction()) {
-        case MouseAction::PRESS:
-            mouseEventPoint.action = OH_NativeXComponent_MouseEventAction::OH_NATIVEXCOMPONENT_MOUSE_PRESS;
-            break;
-        case MouseAction::RELEASE:
-            mouseEventPoint.action = OH_NativeXComponent_MouseEventAction::OH_NATIVEXCOMPONENT_MOUSE_RELEASE;
-            break;
-        case MouseAction::MOVE:
-            mouseEventPoint.action = OH_NativeXComponent_MouseEventAction::OH_NATIVEXCOMPONENT_MOUSE_MOVE;
-            break;
-        case MouseAction::CANCEL:
-            mouseEventPoint.action = OH_NativeXComponent_MouseEventAction::OH_NATIVEXCOMPONENT_MOUSE_CANCEL;
-            break;
-        default:
-            mouseEventPoint.action = OH_NativeXComponent_MouseEventAction::OH_NATIVEXCOMPONENT_MOUSE_NONE;
-            break;
-    }
-    switch (info.GetButton()) {
-        case MouseButton::LEFT_BUTTON:
-            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_LEFT_BUTTON;
-            break;
-        case MouseButton::RIGHT_BUTTON:
-            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_RIGHT_BUTTON;
-            break;
-        case MouseButton::MIDDLE_BUTTON:
-            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_MIDDLE_BUTTON;
-            break;
-        case MouseButton::BACK_BUTTON:
-            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_BACK_BUTTON;
-            break;
-        case MouseButton::FORWARD_BUTTON:
-            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_FORWARD_BUTTON;
-            break;
-        default:
-            mouseEventPoint.button = OH_NativeXComponent_MouseEventButton::OH_NATIVEXCOMPONENT_NONE_BUTTON;
-            break;
-    }
-    mouseEventPoint.timestamp = info.GetTimeStamp().time_since_epoch().count();
-    NativeXComponentDispatchMouseEvent(mouseEventPoint);
-}
-
-void XComponentPattern::HandleAxisEvent(const AxisInfo& info)
-{
-    auto axisEvent = info.ConvertToAxisEvent();
-    NativeXComponentDispatchAxisEvent(&axisEvent);
-}
-
-void XComponentPattern::HandleMouseHoverEvent(bool isHover)
-{
-    CHECK_RUN_ON(UI);
-    CHECK_NULL_VOID(nativeXComponent_);
-    CHECK_NULL_VOID(nativeXComponentImpl_);
-    const auto* callback = nativeXComponentImpl_->GetMouseEventCallback();
-    CHECK_NULL_VOID(callback);
-    CHECK_NULL_VOID(callback->DispatchHoverEvent);
-    callback->DispatchHoverEvent(nativeXComponent_.get(), isHover);
-}
-
-void XComponentPattern::NativeXComponentDispatchMouseEvent(const OH_NativeXComponent_MouseEvent& mouseEvent)
-{
-    CHECK_RUN_ON(UI);
-    CHECK_NULL_VOID(nativeXComponent_);
-    CHECK_NULL_VOID(nativeXComponentImpl_);
-    nativeXComponentImpl_->SetMouseEvent(mouseEvent);
-    auto* surface = const_cast<void*>(nativeXComponentImpl_->GetSurface());
-    const auto* callback = nativeXComponentImpl_->GetMouseEventCallback();
-    CHECK_NULL_VOID(callback);
-    CHECK_NULL_VOID(callback->DispatchMouseEvent);
-    callback->DispatchMouseEvent(nativeXComponent_.get(), surface);
-}
-
-void XComponentPattern::NativeXComponentDispatchAxisEvent(AxisEvent* axisEvent)
-{
-    CHECK_RUN_ON(UI);
-    CHECK_NULL_VOID(nativeXComponent_);
-    CHECK_NULL_VOID(nativeXComponentImpl_);
-    const auto callback = nativeXComponentImpl_->GetUIAxisEventCallback();
-    CHECK_NULL_VOID(callback);
-    ArkUI_UIInputEvent uiEvent { ARKUI_UIINPUTEVENT_TYPE_AXIS, AXIS_EVENT_ID, axisEvent };
-    callback(nativeXComponent_.get(), &uiEvent, ArkUI_UIInputEvent_Type::ARKUI_UIINPUTEVENT_TYPE_AXIS);
-}
-
-void XComponentPattern::SetTouchPoint(
-    const std::list<TouchLocationInfo>& touchInfoList, const int64_t timeStamp, const TouchType& touchType)
-{
-    touchEventPoint_.numPoints =
-        touchInfoList.size() <= OH_MAX_TOUCH_POINTS_NUMBER ? touchInfoList.size() : OH_MAX_TOUCH_POINTS_NUMBER;
-    nativeXComponentTouchPoints_.clear();
-    uint32_t index = 0;
-    for (auto iterator = touchInfoList.begin(); iterator != touchInfoList.end() && index < OH_MAX_TOUCH_POINTS_NUMBER;
-         iterator++) {
-        OH_NativeXComponent_TouchPoint ohTouchPoint;
-        const auto& pointTouchInfo = *iterator;
-        const auto& pointWindowOffset = pointTouchInfo.GetGlobalLocation();
-        const auto& pointLocalOffset = pointTouchInfo.GetLocalLocation();
-        const auto& pointDisplayOffset = pointTouchInfo.GetScreenLocation();
-        ohTouchPoint.id = pointTouchInfo.GetFingerId();
-        // screenX and screenY implementation wrong but should not modify for maintaining compatibility
-        ohTouchPoint.screenX = static_cast<float>(pointWindowOffset.GetX());
-        ohTouchPoint.screenY = static_cast<float>(pointWindowOffset.GetY());
-        ohTouchPoint.x = static_cast<float>(pointLocalOffset.GetX());
-        ohTouchPoint.y = static_cast<float>(pointLocalOffset.GetY());
-        ohTouchPoint.type = ConvertNativeXComponentTouchEvent(touchType);
-        ohTouchPoint.size = pointTouchInfo.GetSize();
-        ohTouchPoint.force = pointTouchInfo.GetForce();
-        ohTouchPoint.timeStamp = timeStamp;
-        ohTouchPoint.isPressed = (touchType == TouchType::DOWN);
-        touchEventPoint_.touchPoints[index++] = ohTouchPoint;
-        // set tiltX, tiltY, windowX, windowY, displayX, displayY and sourceToolType
-        XComponentTouchPoint xcomponentTouchPoint;
-        xcomponentTouchPoint.tiltX = pointTouchInfo.GetTiltX().value_or(0.0f);
-        xcomponentTouchPoint.tiltY = pointTouchInfo.GetTiltY().value_or(0.0f);
-        xcomponentTouchPoint.windowX = static_cast<float>(pointWindowOffset.GetX());
-        xcomponentTouchPoint.windowY = static_cast<float>(pointWindowOffset.GetY());
-        xcomponentTouchPoint.displayX = static_cast<float>(pointDisplayOffset.GetX());
-        xcomponentTouchPoint.displayY = static_cast<float>(pointDisplayOffset.GetY());
-        xcomponentTouchPoint.sourceToolType = ConvertNativeXComponentTouchToolType(pointTouchInfo.GetSourceTool());
-        nativeXComponentTouchPoints_.emplace_back(xcomponentTouchPoint);
-    }
-    while (index < OH_MAX_TOUCH_POINTS_NUMBER) {
-        OH_NativeXComponent_TouchPoint ohTouchPoint;
-        ohTouchPoint.id = 0;
-        ohTouchPoint.screenX = 0;
-        ohTouchPoint.screenY = 0;
-        ohTouchPoint.x = 0;
-        ohTouchPoint.y = 0;
-        ohTouchPoint.type = OH_NativeXComponent_TouchEventType::OH_NATIVEXCOMPONENT_UNKNOWN;
-        ohTouchPoint.size = 0;
-        ohTouchPoint.force = 0;
-        ohTouchPoint.timeStamp = 0;
-        ohTouchPoint.isPressed = false;
-        touchEventPoint_.touchPoints[index++] = ohTouchPoint;
-    }
-}
-
-std::vector<OH_NativeXComponent_HistoricalPoint> XComponentPattern::SetHistoryPoint(
-    const std::list<TouchLocationInfo>& touchInfoList)
-{
-    std::vector<OH_NativeXComponent_HistoricalPoint> historicalPoints;
-    for (auto&& item : touchInfoList) {
-        OH_NativeXComponent_HistoricalPoint point;
-        point.id = item.GetFingerId();
-        point.x = item.GetLocalLocation().GetX();
-        point.y = item.GetLocalLocation().GetY();
-        point.screenX = item.GetScreenLocation().GetX();
-        point.screenY = item.GetScreenLocation().GetY();
-        point.type = static_cast<OH_NativeXComponent_TouchEventType>(item.GetTouchType());
-        point.size = item.GetSize();
-        point.force = item.GetForce();
-        point.timeStamp = item.GetTimeStamp().time_since_epoch().count();
-        point.titlX = item.GetTiltX().value_or(0.0f);
-        point.titlY = item.GetTiltY().value_or(0.0f);
-        point.sourceTool = static_cast<OH_NativeXComponent_TouchEvent_SourceTool>(item.GetSourceTool());
-
-        historicalPoints.push_back(point);
-    }
-    return historicalPoints;
+    CHECK_NULL_VOID(eventManager_);
+    eventManager_->InitEvent();
 }
 
 void XComponentPattern::FireExternalEvent(RefPtr<NG::PipelineContext> context,
diff --git a/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.h b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.h
index 44dc2f76fff1bd8641ca4e8a9950831ad23c9021..e05ea4e2ef062bd82f8e9ca53eb0f5a580c6b21b 100644
--- a/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.h
+++ b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.h
@@ -36,6 +36,7 @@
 #include "core/components_ng/pattern/xcomponent/inner_xcomponent_controller.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_accessibility_provider.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_event_hub.h"
+#include "core/components_ng/pattern/xcomponent/xcomponent_event_manager.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_layout_algorithm.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_layout_property.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_paint_method.h"
@@ -50,6 +51,7 @@ class ImageAnalyzerManager;
 }
 namespace OHOS::Ace::NG {
 class XComponentExtSurfaceCallbackClient;
+// class XComponentEventManager;
 class XComponentPattern : public Pattern {
     DECLARE_ACE_TYPE(XComponentPattern, Pattern);
 
@@ -350,6 +352,9 @@ public:
     bool GetEnableAnalyzer();
     void NativeStartImageAnalyzer(std::function<void(int32_t)>& callback);
 
+    RefPtr<XComponentEventManager> GetXComponentEventManager() {
+        return eventManager_;
+    }
 protected:
     void OnAttachToMainTree() override;
     void OnDetachFromMainTree() override;
@@ -414,23 +419,8 @@ private:
     void InitSurface();
     void InitNativeNodeCallbacks();
     void InitEvent();
-    void InitTouchEvent(const RefPtr<GestureEventHub>& gestureHub);
-    void InitOnTouchIntercept(const RefPtr<GestureEventHub>& gestureHub);
-    void InitAxisEvent(const RefPtr<InputEventHub>& inputHub);
-    void HandleTouchEvent(const TouchEventInfo& info);
-    void InitMouseEvent(const RefPtr<InputEventHub>& inputHub);
-    void HandleMouseEvent(const MouseInfo& info);
-    void HandleAxisEvent(const AxisInfo& info);
-    void InitMouseHoverEvent(const RefPtr<InputEventHub>& inputHub);
-    void HandleMouseHoverEvent(bool isHover);
-    void InitFocusEvent(const RefPtr<FocusHub>& focusHub);
-    void HandleFocusEvent();
-    bool HandleKeyEvent(const KeyEvent& event);
-    void HandleBlurEvent();
     ExternalEvent CreateExternalEvent();
 
-    void SetTouchPoint(
-        const std::list<TouchLocationInfo>& touchInfoList, int64_t timeStamp, const TouchType& touchType);
     void HandleSetExpectedRateRangeEvent();
     void HandleOnFrameEvent();
     void HandleUnregisterOnFrameEvent();
@@ -453,7 +443,6 @@ private:
     void RequestFocus();
 #endif
 
-    std::vector<OH_NativeXComponent_HistoricalPoint> SetHistoryPoint(const std::list<TouchLocationInfo>& touchInfoList);
     std::optional<std::string> libraryname_;
     std::shared_ptr<InnerXComponentController> xcomponentController_;
     std::optional<std::string> soPath_;
@@ -467,12 +456,6 @@ private:
 
     bool hasXComponentInit_ = false;
 
-    RefPtr<TouchEventImpl> touchEvent_;
-    OH_NativeXComponent_TouchEvent touchEventPoint_ = {};
-    RefPtr<InputEvent> mouseEvent_;
-    RefPtr<InputEvent> axisEvent_;
-    RefPtr<InputEvent> mouseHoverEvent_;
-    std::vector<XComponentTouchPoint> nativeXComponentTouchPoints_;
     RefPtr<XComponentExtSurfaceCallbackClient> extSurfaceClient_;
     SizeF initSize_;
     OffsetF globalPosition_;
@@ -508,6 +491,7 @@ private:
     bool needRecoverDisplaySync_ = false;
     bool isNativeImageAnalyzing_ = false;
     WeakPtr<PipelineContext> initialContext_ = nullptr;
+    RefPtr<XComponentEventManager> eventManager_;
 };
 } // namespace OHOS::Ace::NG
 
diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn
index 3996eee78b6b79c88a29849c8da33ebd1d16d02c..63c60a131837cb6a16e3b6c1c571ee5e7f1d47a2 100644
--- a/test/unittest/BUILD.gn
+++ b/test/unittest/BUILD.gn
@@ -1453,6 +1453,7 @@ ohos_source_set("ace_components_pattern") {
     "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_accessibility_provider.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_accessibility_session_adapter.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_controller_ng.cpp",
+    "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_event_manager.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_ext_surface_callback_client.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_layout_algorithm.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_model_ng.cpp",
diff --git a/test/unittest/core/pattern/web/BUILD.gn b/test/unittest/core/pattern/web/BUILD.gn
index 5e2a6708a5324b1dcdfbaed776e2712e2611ff0a..55dde320f39519b4f5467a549ee1c7d807db8c08 100755
--- a/test/unittest/core/pattern/web/BUILD.gn
+++ b/test/unittest/core/pattern/web/BUILD.gn
@@ -632,6 +632,7 @@ ohos_unittest("web_pattern_unit_test_ohos") {
     "$ace_root/frameworks/core/components_ng/pattern/waterflow/water_flow_pattern.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/waterflow/water_flow_sections.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_controller_ng.cpp",
+    "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_event_manager.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_ext_surface_callback_client.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_layout_algorithm.cpp",
     "$ace_root/frameworks/core/components_ng/pattern/xcomponent/xcomponent_model_ng.cpp",
diff --git a/test/unittest/core/pattern/xcomponent/xcomponent_property_test_ng.cpp b/test/unittest/core/pattern/xcomponent/xcomponent_property_test_ng.cpp
index 7c17487966f64b198b8f063672b06de3323d24d4..225e289b12b6b1d41cb95b5c1024af7c07fb562b 100644
--- a/test/unittest/core/pattern/xcomponent/xcomponent_property_test_ng.cpp
+++ b/test/unittest/core/pattern/xcomponent/xcomponent_property_test_ng.cpp
@@ -204,6 +204,48 @@ HWTEST_F(XComponentPropertyTestNg, XComponentPropertyTest001, TestSize.Level1)
         XCOMPONENT_COMPONENT_TYPE_VALUE);
 }
 
+/**
+ * @tc.name: XComponentPropertyTest002
+ * @tc.desc: Test Property
+ * @tc.type: FUNC
+ */
+ HWTEST_F(XComponentPropertyTestNg, XComponentPropertyTest002, TestSize.Level1)
+ {
+     /**
+      * @tc.steps: step1. set type = XCOMPONENT_SURFACE_TYPE and call CreateXComponentNode
+      * @tc.expected: xcomponent PaintProperty create successfully
+      */
+     testProperty.xcType = XCOMPONENT_SURFACE_TYPE_VALUE;
+     auto frameNode = CreateXComponentNode(testProperty);
+     ASSERT_TRUE(frameNode);
+     auto pattern = frameNode->GetPattern<XComponentPattern>();
+     ASSERT_TRUE(pattern);
+ 
+     RefPtr<Property> propertyTest = frameNode->GetPaintProperty<Property>();
+     ASSERT_TRUE(propertyTest);
+ }
+
+/**
+* @tc.name: XComponentPropertyTest003
+* @tc.desc: Test Property
+* @tc.type: FUNC
+*/
+HWTEST_F(XComponentPropertyTestNg, XComponentPropertyTest003, TestSize.Level1)
+{
+    /**
+    * @tc.steps: step1. set type = XCOMPONENT_SURFACE_TYPE and call CreateXComponentNode
+    * @tc.expected: xcomponent layoutProperty create successfully
+    */
+    testProperty.xcType = XCOMPONENT_SURFACE_TYPE_VALUE;
+    auto frameNode = CreateXComponentNode(testProperty);
+    ASSERT_TRUE(frameNode);
+    auto pattern = frameNode->GetPattern<XComponentPattern>();
+    ASSERT_TRUE(pattern);
+
+    RefPtr<LayoutProperty> layoutPropertyTest = frameNode->GetLayoutProperty<LayoutProperty>();
+    ASSERT_TRUE(layoutPropertyTest);
+}
+
 /**
  * @tc.name: XComponentNDKTest003
  * @tc.desc: Test XComponent NDK interfaces.
diff --git a/test/unittest/core/pattern/xcomponent/xcomponent_test_ng.cpp b/test/unittest/core/pattern/xcomponent/xcomponent_test_ng.cpp
index 46711f17d9f24f277664ab27fd076353823e1274..378c2bd53fb1e0c7cd1e485a22d056f5e4ebd779 100644
--- a/test/unittest/core/pattern/xcomponent/xcomponent_test_ng.cpp
+++ b/test/unittest/core/pattern/xcomponent/xcomponent_test_ng.cpp
@@ -34,6 +34,7 @@
 #include "core/components_ng/pattern/xcomponent/xcomponent_controller_ng.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_layout_algorithm.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_model_ng.h"
+#include "core/components_ng/pattern/xcomponent/xcomponent_event_manager.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_pattern.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_pattern_v2.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_surface_holder.h"
@@ -363,6 +364,8 @@ HWTEST_F(XComponentTestNg, XComponentMouseEventTest007, TestSize.Level1)
     auto pattern = frameNode->GetPattern<XComponentPattern>();
     ASSERT_TRUE(pattern);
     pattern->hasXComponentInit_ = true;
+    auto xcomponentEventManager = pattern->GetXComponentEventManager();
+    ASSERT_TRUE(xcomponentEventManager);
 
     /**
      * @tc.steps: step2. prepare mouse info
@@ -385,13 +388,13 @@ HWTEST_F(XComponentTestNg, XComponentMouseEventTest007, TestSize.Level1)
      */
     for (MouseAction& action : mouseActions) {
         mouseInfo.SetAction(action);
-        pattern->HandleMouseEvent(mouseInfo);
-        pattern->HandleMouseHoverEvent(true);
-        pattern->HandleMouseHoverEvent(false);
+        xcomponentEventManager->HandleMouseEvent(mouseInfo);
+        xcomponentEventManager->HandleMouseHoverEvent(true);
+        xcomponentEventManager->HandleMouseHoverEvent(false);
     }
     for (MouseButton& button : mouseButtons) {
         mouseInfo.SetButton(button);
-        pattern->HandleMouseEvent(mouseInfo);
+        xcomponentEventManager->HandleMouseEvent(mouseInfo);
     }
 }
 
@@ -411,7 +414,8 @@ HWTEST_F(XComponentTestNg, XComponentTouchEventTest008, TestSize.Level1)
     ASSERT_TRUE(frameNode);
     auto pattern = frameNode->GetPattern<XComponentPattern>();
     ASSERT_TRUE(pattern);
-
+    auto xcomponentEventManager = pattern->GetXComponentEventManager();
+    ASSERT_TRUE(xcomponentEventManager);
     /**
      * @tc.steps: step2. prepare touchEvent info
      */
@@ -432,12 +436,12 @@ HWTEST_F(XComponentTestNg, XComponentTouchEventTest008, TestSize.Level1)
     /**
      * @tc.steps: step3. call HandleTouchEvent
      *            case: touchEventInfo.GetChangedTouches is empty
-     * @tc.expected: pattern->touchEventPoint_.numPoints not change
+     * @tc.expected: xcomponentEventManager->touchEventPoint_.numPoints not change
      */
     TouchEventInfo touchEventInfoEmpty("onTouch");
-    uint32_t numPoints = pattern->touchEventPoint_.numPoints;
-    pattern->HandleTouchEvent(touchEventInfoEmpty);
-    EXPECT_EQ(pattern->touchEventPoint_.numPoints, numPoints);
+    uint32_t numPoints = xcomponentEventManager->touchEventPoint_.numPoints;
+    xcomponentEventManager->HandleTouchEvent(touchEventInfoEmpty);
+    EXPECT_EQ(xcomponentEventManager->touchEventPoint_.numPoints, numPoints);
 
     /**
      * @tc.steps: step4. call HandleTouchEvent
@@ -449,9 +453,9 @@ HWTEST_F(XComponentTestNg, XComponentTouchEventTest008, TestSize.Level1)
         TouchLocationInfo locationInfo(1);
         locationInfo.SetTouchType(touchType);
         touchEventInfo.AddChangedTouchLocationInfo(std::move(locationInfo));
-        pattern->HandleTouchEvent(touchEventInfo);
+        xcomponentEventManager->HandleTouchEvent(touchEventInfo);
         EXPECT_EQ(
-            static_cast<int>(ConvertXComponentTouchType(pattern->touchEventPoint_.type)), static_cast<int>(touchType));
+            static_cast<int>(ConvertXComponentTouchType(xcomponentEventManager->touchEventPoint_.type)), static_cast<int>(touchType));
     }
 
     /**
@@ -468,37 +472,14 @@ HWTEST_F(XComponentTestNg, XComponentTouchEventTest008, TestSize.Level1)
         pointInfo.SetSourceTool(sourceTools[i % sourceTools.size()]);
         touchEventInfo.AddTouchLocationInfo(std::move(pointInfo));
     }
-    pattern->HandleTouchEvent(touchEventInfo);
-    EXPECT_EQ(pattern->nativeXComponentTouchPoints_.size(), OH_MAX_TOUCH_POINTS_NUMBER);
+    xcomponentEventManager->HandleTouchEvent(touchEventInfo);
+    EXPECT_EQ(xcomponentEventManager->nativeXComponentTouchPoints_.size(), OH_MAX_TOUCH_POINTS_NUMBER);
     for (int i = 0; i < static_cast<int>(OH_MAX_TOUCH_POINTS_NUMBER); i++) {
-        EXPECT_EQ(static_cast<int>(pattern->nativeXComponentTouchPoints_[i].sourceToolType),
+        EXPECT_EQ(static_cast<int>(xcomponentEventManager->nativeXComponentTouchPoints_[i].sourceToolType),
             static_cast<int>(sourceTools[i % sourceTools.size()]));
     }
 }
 
-/**
- * @tc.name: XComponentTouchEventTest009
- * @tc.desc: Test TouchEvent
- * @tc.type: FUNC
- */
-HWTEST_F(XComponentTestNg, XComponentTouchEventTest009, TestSize.Level1)
-{
-    /**
-     * @tc.steps: step1. set type = XCOMPONENT_SURFACE_TYPE and call CreateXComponentNode
-     * @tc.expected: xcomponent frameNode create successfully
-     */
-    testProperty.xcType = XCOMPONENT_SURFACE_TYPE_VALUE;
-    auto frameNode = CreateXComponentNode(testProperty);
-    ASSERT_TRUE(frameNode);
-    auto pattern = frameNode->GetPattern<XComponentPattern>();
-    ASSERT_TRUE(pattern);
-
-    RefPtr<LayoutProperty> layoutPropertyTest = frameNode->GetLayoutProperty<LayoutProperty>();
-    ASSERT_TRUE(layoutPropertyTest);
-    RefPtr<Property> propertyTest = frameNode->GetPaintProperty<Property>();
-    ASSERT_TRUE(propertyTest);
-}
-
 /**
  * @tc.name: XComponentKeyEventTest010
  * @tc.desc: Test KeyEvent/FocusEvent/BlurEvent
@@ -515,7 +496,8 @@ HWTEST_F(XComponentTestNg, XComponentKeyEventTest010, TestSize.Level1)
     ASSERT_TRUE(frameNode);
     auto pattern = frameNode->GetPattern<XComponentPattern>();
     ASSERT_TRUE(pattern);
-
+    auto xcomponentEventManager = pattern->GetXComponentEventManager();
+    ASSERT_TRUE(xcomponentEventManager);
     /**
      * @tc.steps: step2. create focusHub & nativeXComponent instance
      * @tc.expected: focusHub & nativeXComponent instance create successfully
@@ -662,6 +644,8 @@ HWTEST_F(XComponentTestNg, XComponentSetHistoryPointTest20, TestSize.Level1)
     auto pattern = frameNode->GetPattern<XComponentPattern>();
     ASSERT_TRUE(pattern);
     pattern->hasXComponentInit_ = true;
+    auto xcomponentEventManager = pattern->GetXComponentEventManager();
+    ASSERT_TRUE(xcomponentEventManager);
 
     /**
      * @tc.steps: step2. prepare point info
@@ -689,7 +673,7 @@ HWTEST_F(XComponentTestNg, XComponentSetHistoryPointTest20, TestSize.Level1)
         touchInfoList.push_back(item);
     }
 
-    auto pVector = pattern->SetHistoryPoint(touchInfoList);
+    auto pVector = xcomponentEventManager->ConvertHistoryPoint(touchInfoList);
 
     /**
      * @tc.steps: step3. check
@@ -1208,6 +1192,8 @@ HWTEST_F(XComponentTestNg, XComponentAxisEventTest012, TestSize.Level1)
     ASSERT_TRUE(frameNode);
     auto pattern = frameNode->GetPattern<XComponentPattern>();
     ASSERT_TRUE(pattern);
+    auto xcomponentEventManager = pattern->GetXComponentEventManager();
+    ASSERT_TRUE(xcomponentEventManager);
 
     /**
      * @tc.steps: step2. create nativeXComponent instance
@@ -1231,7 +1217,7 @@ HWTEST_F(XComponentTestNg, XComponentAxisEventTest012, TestSize.Level1)
      * @tc.steps: step4. call HandleAxisEvent
      */
     AxisInfo event;
-    pattern->HandleAxisEvent(event);
+    xcomponentEventManager->HandleAxisEvent(event);
     EXPECT_TRUE(isAxis);
 }
 
@@ -1251,7 +1237,8 @@ HWTEST_F(XComponentTestNg, XComponentSourceTypeTest, TestSize.Level1)
     ASSERT_TRUE(frameNode);
     auto pattern = frameNode->GetPattern<XComponentPattern>();
     ASSERT_TRUE(pattern);
-
+    auto xcomponentEventManager = pattern->GetXComponentEventManager();
+    ASSERT_TRUE(xcomponentEventManager);
     /**
      * @tc.steps: step2. call HandleTouchEvent
      *            case: set source type
@@ -1265,7 +1252,7 @@ HWTEST_F(XComponentTestNg, XComponentSourceTypeTest, TestSize.Level1)
         SourceType::KEYBOARD };
     for (SourceType& sourceType : sourceTypes) {
         touchEventInfoSourceType.SetSourceDevice(sourceType);
-        pattern->HandleTouchEvent(touchEventInfoSourceType);
+        xcomponentEventManager->HandleTouchEvent(touchEventInfoSourceType);
         EXPECT_EQ(pattern->nativeXComponentImpl_->curSourceType_.first, 0);
         EXPECT_EQ(static_cast<int>(pattern->nativeXComponentImpl_->curSourceType_.second),
             static_cast<int>(ConvertNativeXComponentEventSourceType(sourceType)));