diff --git a/adapter/ohos/entrance/mmi_event_convertor.cpp b/adapter/ohos/entrance/mmi_event_convertor.cpp
index 620bfeb3a8db591bbf7f9bd91b1708521c5546a0..6e6f44bc549eaaec246877c93cb5b7c094af0207 100644
--- a/adapter/ohos/entrance/mmi_event_convertor.cpp
+++ b/adapter/ohos/entrance/mmi_event_convertor.cpp
@@ -23,6 +23,7 @@
 #include "adapter/ohos/entrance/ace_extra_input_data.h"
 #include "base/utils/time_util.h"
 #include "base/utils/utils.h"
+#include "core/event/ace_events.h"
 #include "core/pipeline/pipeline_base.h"
 
 namespace OHOS::Ace::Platform {
@@ -124,54 +125,73 @@ TouchEvent ConvertTouchEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEv
     auto touchPoint = ConvertTouchPoint(item);
     std::chrono::microseconds microseconds(pointerEvent->GetActionTime());
     TimeStamp time(microseconds);
-    TouchEvent event { touchPoint.id, touchPoint.x, touchPoint.y, touchPoint.screenX, touchPoint.screenY,
-        TouchType::UNKNOWN, TouchType::UNKNOWN, time, touchPoint.size, touchPoint.force, touchPoint.tiltX,
-        touchPoint.tiltY, pointerEvent->GetDeviceId(), pointerEvent->GetTargetDisplayId(), SourceType::NONE,
-        touchPoint.sourceTool, pointerEvent->GetId() };
+    TouchEvent event;
+    event.SetId(touchPoint.id)
+        .SetX(touchPoint.x)
+        .SetY(touchPoint.y)
+        .SetScreenX(touchPoint.screenX)
+        .SetScreenY(touchPoint.screenY)
+        .SetType(TouchType::UNKNOWN)
+        .SetPullType(TouchType::UNKNOWN)
+        .SetTime(time)
+        .SetSize(touchPoint.size)
+        .SetForce(touchPoint.force)
+        .SetTiltX(touchPoint.tiltX)
+        .SetTiltY(touchPoint.tiltY)
+        .SetDeviceId(pointerEvent->GetDeviceId())
+        .SetTargetDisplayId(pointerEvent->GetTargetDisplayId())
+        .SetSourceType(SourceType::NONE)
+        .SetSourceTool(touchPoint.sourceTool)
+        .SetTouchEventId(pointerEvent->GetId());
     AceExtraInputData::ReadToTouchEvent(pointerEvent, event);
     event.pointerEvent = pointerEvent;
     int32_t orgDevice = pointerEvent->GetSourceType();
     GetEventDevice(orgDevice, event);
     int32_t orgAction = pointerEvent->GetPointerAction();
+    SetTouchEventType(orgAction, event);
+    UpdateTouchEvent(pointerEvent, event);
+    return event;
+}
+
+void SetTouchEventType(int32_t orgAction, TouchEvent& event)
+{
     switch (orgAction) {
         case OHOS::MMI::PointerEvent::POINTER_ACTION_CANCEL:
             event.type = TouchType::CANCEL;
-            break;
+            return;
         case OHOS::MMI::PointerEvent::POINTER_ACTION_DOWN:
             event.type = TouchType::DOWN;
-            break;
+            return;
         case OHOS::MMI::PointerEvent::POINTER_ACTION_MOVE:
             event.type = TouchType::MOVE;
-            break;
+            return;
         case OHOS::MMI::PointerEvent::POINTER_ACTION_UP:
             event.type = TouchType::UP;
-            break;
+            return;
         case OHOS::MMI::PointerEvent::POINTER_ACTION_PULL_DOWN:
             event.type = TouchType::PULL_DOWN;
             event.pullType = TouchType::PULL_DOWN;
-            break;
+            return;
         case OHOS::MMI::PointerEvent::POINTER_ACTION_PULL_MOVE:
             event.type = TouchType::PULL_MOVE;
             event.pullType = TouchType::PULL_MOVE;
-            break;
+            return;
         case OHOS::MMI::PointerEvent::POINTER_ACTION_PULL_UP:
             event.type = TouchType::PULL_UP;
             event.pullType = TouchType::PULL_UP;
-            break;
+            return;
         case OHOS::MMI::PointerEvent::POINTER_ACTION_PULL_IN_WINDOW:
             event.type = TouchType::PULL_IN_WINDOW;
             event.pullType = TouchType::PULL_IN_WINDOW;
-            break;
+            return;
         case OHOS::MMI::PointerEvent::POINTER_ACTION_PULL_OUT_WINDOW:
             event.type = TouchType::PULL_OUT_WINDOW;
             event.pullType = TouchType::PULL_OUT_WINDOW;
-            break;
+            return;
         default:
             LOGW("unknown type");
-            break;
+            return;
     }
-    UpdateTouchEvent(pointerEvent, event);
-    return event;
 }
 
 void GetMouseEventAction(int32_t action, MouseEvent& events, bool isScenceBoardWindow)
diff --git a/adapter/ohos/entrance/mmi_event_convertor.h b/adapter/ohos/entrance/mmi_event_convertor.h
index cb0a693b2ae39490d5d1e8f595c597c781a80cb5..93122f9b0dd4d6558c77babc2f9fd14533d4352e 100644
--- a/adapter/ohos/entrance/mmi_event_convertor.h
+++ b/adapter/ohos/entrance/mmi_event_convertor.h
@@ -72,6 +72,8 @@ void GetEventDevice(int32_t sourceType, E& event)
 
 TouchEvent ConvertTouchEvent(const std::shared_ptr<MMI::PointerEvent>& pointerEvent);
 
+void SetTouchEventType(int32_t orgAction, TouchEvent& event);
+
 void CalculatePointerEvent(const NG::OffsetF& offsetF, const std::shared_ptr<MMI::PointerEvent>& point,
     const NG::VectorF& scale, int32_t udegree = 0);
 
diff --git a/frameworks/bridge/declarative_frontend/BUILD.gn b/frameworks/bridge/declarative_frontend/BUILD.gn
index a2b4e4a6c9565ce125b22b3c3f7de85aaba96987..c0fe17ac0355cec92948fb12ecb3af0a8b1b8fae 100644
--- a/frameworks/bridge/declarative_frontend/BUILD.gn
+++ b/frameworks/bridge/declarative_frontend/BUILD.gn
@@ -170,6 +170,7 @@ template("declarative_js_engine") {
       "engine/functions/js_swiper_function.cpp",
       "engine/functions/js_tabs_function.cpp",
       "engine/functions/js_touch_function.cpp",
+      "engine/functions/js_touch_intercept_function.cpp",
       "engine/functions/js_webview_function.cpp",
       "engine/js_types.cpp",
       "interfaces/profiler/js_profiler.cpp",
@@ -673,6 +674,7 @@ template("declarative_js_engine_ng") {
       "engine/functions/js_swiper_function.cpp",
       "engine/functions/js_tabs_function.cpp",
       "engine/functions/js_touch_function.cpp",
+      "engine/functions/js_touch_intercept_function.cpp",
       "engine/functions/js_webview_function.cpp",
       "engine/js_types.cpp",
       "jsview/js_dump_log.cpp",
diff --git a/frameworks/bridge/declarative_frontend/engine/functions/js_touch_function.h b/frameworks/bridge/declarative_frontend/engine/functions/js_touch_function.h
index 42381f03f4b9236cf27b52308ae932ce60276f52..0118014ab3d54c4ab3bfa0dfb8c8db413c807856 100644
--- a/frameworks/bridge/declarative_frontend/engine/functions/js_touch_function.h
+++ b/frameworks/bridge/declarative_frontend/engine/functions/js_touch_function.h
@@ -35,10 +35,8 @@ public:
         JsFunction::Execute();
     }
     void Execute(TouchEventInfo& info);
-
-private:
-    JSRef<JSObject> CreateTouchInfo(const TouchLocationInfo& touchInfo, TouchEventInfo& info);
-    JSRef<JSObject> CreateJSEventInfo(TouchEventInfo& info);
+    static JSRef<JSObject> CreateTouchInfo(const TouchLocationInfo& touchInfo, TouchEventInfo& info);
+    static JSRef<JSObject> CreateJSEventInfo(TouchEventInfo& info);
 };
 
 } // namespace OHOS::Ace::Framework
diff --git a/frameworks/bridge/declarative_frontend/engine/functions/js_touch_intercept_function.cpp b/frameworks/bridge/declarative_frontend/engine/functions/js_touch_intercept_function.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..af0aecdabbff1525f1c8c05f0f63c1b9cd3a0a65
--- /dev/null
+++ b/frameworks/bridge/declarative_frontend/engine/functions/js_touch_intercept_function.cpp
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 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 "frameworks/bridge/declarative_frontend/engine/functions/js_touch_intercept_function.h"
+
+#include "bridge/declarative_frontend/engine/functions/js_function.h"
+#include "bridge/declarative_frontend/engine/functions/js_touch_function.h"
+
+namespace OHOS::Ace::Framework {
+
+NG::HitTestMode JsTouchInterceptFunction::Execute(TouchEventInfo& info)
+{
+    JSRef<JSVal> param = JSRef<JSObject>::Cast(JsTouchFunction::CreateJSEventInfo(info));
+    auto jsValue = JsFunction::ExecuteJS(1, &param);
+    auto returnValue = NG::HitTestMode::HTMDEFAULT;
+    if (jsValue->IsNumber()) {
+        returnValue = static_cast<NG::HitTestMode>(jsValue->ToNumber<int32_t>());
+    }
+    return returnValue;
+}
+
+} // namespace OHOS::Ace::Framework
diff --git a/frameworks/bridge/declarative_frontend/engine/functions/js_touch_intercept_function.h b/frameworks/bridge/declarative_frontend/engine/functions/js_touch_intercept_function.h
new file mode 100644
index 0000000000000000000000000000000000000000..dade10fcf9bc3a91af37a76b45fe8bf7ef0c2931
--- /dev/null
+++ b/frameworks/bridge/declarative_frontend/engine/functions/js_touch_intercept_function.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 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 FRAMEWORKS_BRIDGE_DECLARATIVE_FRONTEND_ENGINE_FUNCTION_JS_TOUCH_INTERCEPT_FUNCTION_H
+#define FRAMEWORKS_BRIDGE_DECLARATIVE_FRONTEND_ENGINE_FUNCTION_JS_TOUCH_INTERCEPT_FUNCTION_H
+
+#include "frameworks/bridge/declarative_frontend/engine/functions/js_function.h"
+
+namespace OHOS::Ace::Framework {
+class JsTouchInterceptFunction : public JsFunction {
+    DECLARE_ACE_TYPE(JsTouchInterceptFunction, JsFunction)
+
+public:
+    explicit JsTouchInterceptFunction(const JSRef<JSFunc>& jsFunction) : JsFunction(JSRef<JSObject>(), jsFunction) {}
+
+    ~JsTouchInterceptFunction() override = default;
+
+    void Execute() override
+    {
+        ExecuteJS();
+    }
+
+    NG::HitTestMode Execute(TouchEventInfo& info);
+};
+} // namespace OHOS::Ace::Framework
+
+#endif // FRAMEWORKS_BRIDGE_DECLARATIVE_FRONTEND_ENGINE_FUNCTION_JS_TOUCH_INTERCEPT_FUNCTION_H
diff --git a/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.cpp b/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.cpp
index f456111a8272b273c8538fa26cf46f250cc4dea7..b8a93f45a3c51045269083dfb747447d0dd6d343 100755
--- a/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.cpp
+++ b/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.cpp
@@ -25,6 +25,7 @@
 #include <utility>
 #include <vector>
 #include <unordered_map>
+#include "interfaces/native/native_event.h"
 
 #include "base/geometry/calc_dimension.h"
 #include "base/geometry/dimension.h"
@@ -51,6 +52,7 @@
 #include "bridge/declarative_frontend/engine/functions/js_key_function.h"
 #include "bridge/declarative_frontend/engine/functions/js_on_area_change_function.h"
 #include "bridge/declarative_frontend/engine/functions/js_on_size_change_function.h"
+#include "bridge/declarative_frontend/engine/functions/js_touch_intercept_function.h"
 #include "bridge/declarative_frontend/engine/js_converter.h"
 #include "bridge/declarative_frontend/engine/js_ref_ptr.h"
 #include "bridge/declarative_frontend/engine/js_types.h"
@@ -6842,6 +6844,7 @@ void JSViewAbstract::JSBind(BindingTarget globalObj)
     JSClass<JSViewAbstract>::StaticMethod("onHover", &JSViewAbstract::JsOnHover);
     JSClass<JSViewAbstract>::StaticMethod("onClick", &JSViewAbstract::JsOnClick);
     JSClass<JSViewAbstract>::StaticMethod("onGestureJudgeBegin", &JSViewAbstract::JsOnGestureJudgeBegin);
+    JSClass<JSViewAbstract>::StaticMethod("onTouchIntercept", &JSViewAbstract::JsOnTouchIntercept);
     JSClass<JSViewAbstract>::StaticMethod("clickEffect", &JSViewAbstract::JsClickEffect);
     JSClass<JSViewAbstract>::StaticMethod("debugLine", &JSViewAbstract::JsDebugLine);
     JSClass<JSViewAbstract>::StaticMethod("geometryTransition", &JSViewAbstract::JsGeometryTransition);
@@ -7757,6 +7760,25 @@ void JSViewAbstract::JsOnGestureJudgeBegin(const JSCallbackInfo& info)
     ViewAbstractModel::GetInstance()->SetOnGestureJudgeBegin(std::move(onGestureJudgefunc));
 }
 
+void JSViewAbstract::JsOnTouchIntercept(const JSCallbackInfo& info)
+{
+    if (info[0]->IsUndefined() || !info[0]->IsFunction()) {
+        ViewAbstractModel::GetInstance()->SetOnTouchIntercept(nullptr);
+        return;
+    }
+
+    auto jsOnTouchInterceptFunc = AceType::MakeRefPtr<JsTouchInterceptFunction>(JSRef<JSFunc>::Cast(info[0]));
+    WeakPtr<NG::FrameNode> frameNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
+    auto onTouchInterceptfunc = [execCtx = info.GetExecutionContext(), func = jsOnTouchInterceptFunc, node = frameNode](
+                                    TouchEventInfo& info) -> NG::HitTestMode {
+        JAVASCRIPT_EXECUTION_SCOPE_WITH_CHECK(execCtx, NG::HitTestMode::HTMDEFAULT);
+        ACE_SCORING_EVENT("onTouchIntercept");
+        PipelineContext::SetCallBackNode(node);
+        return func->Execute(info);
+    };
+    ViewAbstractModel::GetInstance()->SetOnTouchIntercept(std::move(onTouchInterceptfunc));
+}
+
 void JSViewAbstract::JsClickEffect(const JSCallbackInfo& info)
 {
     if (info[0]->IsUndefined() || info[0]->IsNull()) {
diff --git a/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.h b/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.h
index 111ee84b0b535a1947d78093815dfa59e71438c4..f8462da36b3829fc75c1f526a4aacad403038899 100755
--- a/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.h
+++ b/frameworks/bridge/declarative_frontend/jsview/js_view_abstract.h
@@ -184,6 +184,7 @@ public:
     static void JsOnHover(const JSCallbackInfo& info);
     static void JsOnClick(const JSCallbackInfo& info);
     static void JsOnGestureJudgeBegin(const JSCallbackInfo& args);
+    static void JsOnTouchIntercept(const JSCallbackInfo& info);
     static void JsClickEffect(const JSCallbackInfo& info);
     static void JsRestoreId(int32_t restoreId);
     static void JsOnVisibleAreaChange(const JSCallbackInfo& info);
diff --git a/frameworks/bridge/declarative_frontend/jsview/models/view_abstract_model_impl.h b/frameworks/bridge/declarative_frontend/jsview/models/view_abstract_model_impl.h
index f65ccb7b5e5020d82926db64c62323b42fb67470..86b05b9a66103ae1b664c7e5004569f0c7a22627 100755
--- a/frameworks/bridge/declarative_frontend/jsview/models/view_abstract_model_impl.h
+++ b/frameworks/bridge/declarative_frontend/jsview/models/view_abstract_model_impl.h
@@ -161,6 +161,7 @@ public:
     void SetClickEffectLevel(const ClickEffectLevel& level, float scaleValue) override {}
     void SetOnClick(GestureEventFunc&& tapEventFunc, ClickEventFunc&& clickEventFunc) override;
     void SetOnGestureJudgeBegin(NG::GestureJudgeFunc&& gestureJudgeFunc) override {}
+    void SetOnTouchIntercept(NG::TouchInterceptFunc&& touchInterceptFunc) override {}
     void SetOnTouch(TouchEventFunc&& touchEventFunc) override;
     void SetOnKeyEvent(OnKeyCallbackFunc&& onKeyCallback) override;
     void SetOnMouse(OnMouseEventFunc&& onMouseEventFunc) override;
diff --git a/frameworks/core/components/web/resource/web_delegate.cpp b/frameworks/core/components/web/resource/web_delegate.cpp
index 16bc79b5fb91f518e951fab6df03c4ebfea0866e..f7f0c575a7b1456fea763ba0a345ab842cde5998 100644
--- a/frameworks/core/components/web/resource/web_delegate.cpp
+++ b/frameworks/core/components/web/resource/web_delegate.cpp
@@ -5677,11 +5677,17 @@ void WebDelegate::SetTouchEventInfo(std::shared_ptr<OHOS::NWeb::NWebNativeEmbedT
     auto webPattern = webPattern_.Upgrade();
     CHECK_NULL_VOID(webPattern);
     if (touchEvent) {
-        TouchEvent event{touchEvent->GetId(), touchEvent->GetX(), touchEvent->GetY(), touchEvent->GetScreenX(),
-            touchEvent->GetScreenY(), static_cast<OHOS::Ace::TouchType>(touchEvent->GetType())};
+        TouchEvent event;
+        event.SetId(touchEvent->GetId())
+            .SetX(touchEvent->GetX())
+            .SetY(touchEvent->GetY())
+            .SetScreenX(touchEvent->GetScreenX())
+            .SetScreenY(touchEvent->GetScreenY())
+            .SetType(static_cast<OHOS::Ace::TouchType>(touchEvent->GetType()));
         webPattern->SetTouchEventInfo(event, touchEventInfo);
     } else {
-        TouchEvent event = {0, };
+        TouchEvent event;
+        event.SetId(0);
         webPattern->SetTouchEventInfo(event, touchEventInfo);
     }
 }
diff --git a/frameworks/core/components/xcomponent/native_interface_xcomponent_impl.cpp b/frameworks/core/components/xcomponent/native_interface_xcomponent_impl.cpp
index af63236566798015b6ac8c3cb949450f80d558c7..05d29539b69a65876aa783d13ef8d2bcbc279d9f 100644
--- a/frameworks/core/components/xcomponent/native_interface_xcomponent_impl.cpp
+++ b/frameworks/core/components/xcomponent/native_interface_xcomponent_impl.cpp
@@ -278,3 +278,13 @@ int32_t OH_NativeXComponent::SetNeedSoftKeyboard(bool needSoftKeyboard)
     xcomponentImpl_->SetNeedSoftKeyboard(needSoftKeyboard);
     return OH_NATIVEXCOMPONENT_RESULT_SUCCESS;
 }
+
+int32_t OH_NativeXComponent::RegisterOnTouchInterceptCallback(
+    HitTestMode (*callback)(OH_NativeXComponent* component, ArkUI_UIInputEvent* event))
+{
+    if (xcomponentImpl_ == nullptr) {
+        return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
+    }
+    xcomponentImpl_->SetOnTouchInterceptCallback(callback);
+    return OH_NATIVEXCOMPONENT_RESULT_SUCCESS;
+}
diff --git a/frameworks/core/components/xcomponent/native_interface_xcomponent_impl.h b/frameworks/core/components/xcomponent/native_interface_xcomponent_impl.h
index d0f5602e34fcc155191ce9ee310e54f6cff7c1d0..021f8581772d2d39a78b84c24f984a7254494639 100644
--- a/frameworks/core/components/xcomponent/native_interface_xcomponent_impl.h
+++ b/frameworks/core/components/xcomponent/native_interface_xcomponent_impl.h
@@ -21,11 +21,13 @@
 #include <unistd.h>
 #include <vector>
 
+#include "interfaces/native/native_event.h"
 #include "interfaces/native/native_interface_xcomponent.h"
 #include "interfaces/native/ui_input_event.h"
 
 #include "base/memory/ace_type.h"
 #include "base/utils/utils.h"
+#include "core/components_ng/event/gesture_event_hub.h"
 
 struct XComponentTouchPoint {
     float tiltX = 0.0f;
@@ -43,6 +45,8 @@ struct OH_NativeXComponent_KeyEvent {
     int64_t timestamp {};
 };
 
+using OnTouchIntercept_Callback = HitTestMode (*)(OH_NativeXComponent*, ArkUI_UIInputEvent*);
+
 namespace OHOS::Ace {
 class NativeXComponentImpl : public virtual AceType {
     DECLARE_ACE_TYPE(NativeXComponentImpl, AceType);
@@ -239,6 +243,16 @@ public:
         return blurEventCallback_;
     }
 
+    void SetOnTouchInterceptCallback(OnTouchIntercept_Callback callback)
+    {
+        onTouchInterceptCallback_ = callback;
+    }
+
+    OnTouchIntercept_Callback GetOnTouchInterceptCallback()
+    {
+        return onTouchInterceptCallback_;
+    }
+
     void SetFocusEventCallback(NativeXComponent_Callback callback)
     {
         focusEventCallback_ = callback;
@@ -360,6 +374,7 @@ private:
     OH_NativeXComponent_ExpectedRateRange* rateRange_ = nullptr;
     NativeNode_Callback attachNativeNodeCallback_ = nullptr;
     NativeNode_Callback detachNativeNodeCallback_ = nullptr;
+    OnTouchIntercept_Callback onTouchInterceptCallback_ = nullptr;
     void* container_;
     bool needSoftKeyboard_ = false;
 };
@@ -393,6 +408,8 @@ struct OH_NativeXComponent {
     int32_t RegisterUIAxisEventCallback(
         void (*callback)(OH_NativeXComponent* component, ArkUI_UIInputEvent* event, ArkUI_UIInputEvent_Type type));
     int32_t SetNeedSoftKeyboard(bool needSoftKeyboard);
+    int32_t RegisterOnTouchInterceptCallback(
+        HitTestMode (*callback)(OH_NativeXComponent* component, ArkUI_UIInputEvent* event));
 
 private:
     OHOS::Ace::NativeXComponentImpl* xcomponentImpl_ = nullptr;
diff --git a/frameworks/core/components_ng/base/frame_node.cpp b/frameworks/core/components_ng/base/frame_node.cpp
index 37081098cec9d77560cc71aebfc0d433a4bb417a..44f94fc1f10784f2daa0759acce443748cdf4c00 100644
--- a/frameworks/core/components_ng/base/frame_node.cpp
+++ b/frameworks/core/components_ng/base/frame_node.cpp
@@ -1807,28 +1807,32 @@ HitTestResult FrameNode::TouchTest(const PointF& globalPoint, const PointF& pare
     auto subRevertPoint = revertPoint - origRect.GetOffset();
     bool consumed = false;
 
-    std::vector<TouchTestInfo> touchInfos;
-    CollectTouchInfos(globalPoint, subRevertPoint, touchInfos);
-    TouchResult touchRes = GetOnChildTouchTestRet(touchInfos);
-    if ((touchRes.strategy != TouchTestStrategy::DEFAULT) && touchRes.id.empty()) {
-        TAG_LOGW(AceLogTag::ACE_UIEVENT, "onChildTouchTest result is: id = %{public}s, strategy = %{public}d.",
-            touchRes.id.c_str(), static_cast<int32_t>(touchRes.strategy));
-        touchRes.strategy = TouchTestStrategy::DEFAULT;
-    }
-
-    auto childNode = GetDispatchFrameNode(touchRes);
-    if (childNode != nullptr) {
-        TAG_LOGD(AceLogTag::ACE_UIEVENT, "%{public}s do TouchTest, parameter isDispatch is true.",
-            childNode->GetInspectorId()->c_str());
-        auto hitResult = childNode->TouchTest(
-            globalPoint, localPoint, subRevertPoint, touchRestrict, newComingTargets, touchId, true);
-        if (hitResult == HitTestResult::STOP_BUBBLING) {
-            preventBubbling = true;
-            consumed = true;
-        }
+    auto onTouchInterceptresult = TriggerOnTouchIntercept(touchRestrict.touchEvent);
+    TouchResult touchRes;
+    if (onTouchInterceptresult != HitTestMode::HTMBLOCK) {
+        std::vector<TouchTestInfo> touchInfos;
+        CollectTouchInfos(globalPoint, subRevertPoint, touchInfos);
+        touchRes = GetOnChildTouchTestRet(touchInfos);
+        if ((touchRes.strategy != TouchTestStrategy::DEFAULT) && touchRes.id.empty()) {
+            TAG_LOGW(AceLogTag::ACE_UIEVENT, "onChildTouchTest result is: id = %{public}s, strategy = %{public}d.",
+                touchRes.id.c_str(), static_cast<int32_t>(touchRes.strategy));
+            touchRes.strategy = TouchTestStrategy::DEFAULT;
+        }
+
+        auto childNode = GetDispatchFrameNode(touchRes);
+        if (childNode != nullptr) {
+            TAG_LOGD(AceLogTag::ACE_UIEVENT, "%{public}s do TouchTest, parameter isDispatch is true.",
+                childNode->GetInspectorId()->c_str());
+            auto hitResult = childNode->TouchTest(
+                globalPoint, localPoint, subRevertPoint, touchRestrict, newComingTargets, touchId, true);
+            if (hitResult == HitTestResult::STOP_BUBBLING) {
+                preventBubbling = true;
+                consumed = true;
+            }
 
-        if (hitResult == HitTestResult::BUBBLING) {
-            consumed = true;
+            if (hitResult == HitTestResult::BUBBLING) {
+                consumed = true;
+            }
         }
     }
 
@@ -1836,21 +1840,24 @@ HitTestResult FrameNode::TouchTest(const PointF& globalPoint, const PointF& pare
         if (GetHitTestMode() == HitTestMode::HTMBLOCK) {
             break;
         }
-        if (touchRes.strategy == TouchTestStrategy::FORWARD) {
-            break;
+        if (onTouchInterceptresult != HitTestMode::HTMBLOCK) {
+            if (touchRes.strategy == TouchTestStrategy::FORWARD) {
+                break;
+            }
         }
 
         const auto& child = iter->Upgrade();
         if (!child) {
             continue;
         }
-
-        std::string id;
-        if (child->GetInspectorId().has_value()) {
-            id = child->GetInspectorId().value();
-        }
-        if (touchRes.strategy == TouchTestStrategy::FORWARD_COMPETITION && touchRes.id == id) {
-            continue;
+        if (onTouchInterceptresult != HitTestMode::HTMBLOCK) {
+            std::string id;
+            if (child->GetInspectorId().has_value()) {
+                id = child->GetInspectorId().value();
+            }
+            if (touchRes.strategy == TouchTestStrategy::FORWARD_COMPETITION && touchRes.id == id) {
+                continue;
+            }
         }
 
         auto childHitResult =
@@ -3510,4 +3517,77 @@ void FrameNode::PaintDebugBoundary(bool flag)
         renderContext_->PaintDebugBoundary(flag);
     }
 }
+
+HitTestMode FrameNode::TriggerOnTouchIntercept(const TouchEvent& touchEvent)
+{
+    auto gestureHub = eventHub_->GetGestureEventHub();
+    CHECK_NULL_RETURN(gestureHub, HitTestMode::HTMDEFAULT);
+    auto onTouchIntercept = gestureHub->GetOnTouchIntercept();
+    CHECK_NULL_RETURN(onTouchIntercept, HitTestMode::HTMDEFAULT);
+    TouchEventInfo event("touchEvent");
+    event.SetTimeStamp(touchEvent.time);
+    event.SetPointerEvent(touchEvent.pointerEvent);
+    TouchLocationInfo changedInfo("onTouch", touchEvent.id);
+    PointF lastLocalPoint(touchEvent.x, touchEvent.y);
+    NGGestureRecognizer::Transform(lastLocalPoint, Claim(this), false, false);
+    auto localX = static_cast<float>(lastLocalPoint.GetX());
+    auto localY = static_cast<float>(lastLocalPoint.GetY());
+    changedInfo.SetLocalLocation(Offset(localX, localY));
+    changedInfo.SetGlobalLocation(Offset(touchEvent.x, touchEvent.y));
+    changedInfo.SetScreenLocation(Offset(touchEvent.screenX, touchEvent.screenY));
+    changedInfo.SetTouchType(touchEvent.type);
+    changedInfo.SetForce(touchEvent.force);
+    if (touchEvent.tiltX.has_value()) {
+        changedInfo.SetTiltX(touchEvent.tiltX.value());
+    }
+    if (touchEvent.tiltY.has_value()) {
+        changedInfo.SetTiltY(touchEvent.tiltY.value());
+    }
+    changedInfo.SetSourceTool(touchEvent.sourceTool);
+    event.AddChangedTouchLocationInfo(std::move(changedInfo));
+
+    AddTouchEventAllFingersInfo(event, touchEvent);
+    event.SetSourceDevice(touchEvent.sourceType);
+    event.SetForce(touchEvent.force);
+    if (touchEvent.tiltX.has_value()) {
+        event.SetTiltX(touchEvent.tiltX.value());
+    }
+    if (touchEvent.tiltY.has_value()) {
+        event.SetTiltY(touchEvent.tiltY.value());
+    }
+    event.SetSourceTool(touchEvent.sourceTool);
+    auto result = onTouchIntercept(event);
+    SetHitTestMode(result);
+    return result;
+}
+
+void FrameNode::AddTouchEventAllFingersInfo(TouchEventInfo& event, const TouchEvent& touchEvent)
+{
+    // all fingers collection
+    for (const auto& item : touchEvent.pointers) {
+        float globalX = item.x;
+        float globalY = item.y;
+        float screenX = item.screenX;
+        float screenY = item.screenY;
+        PointF localPoint(globalX, globalY);
+        NGGestureRecognizer::Transform(localPoint, Claim(this), false, false);
+        auto localX = static_cast<float>(localPoint.GetX());
+        auto localY = static_cast<float>(localPoint.GetY());
+        TouchLocationInfo info("onTouch", item.id);
+        info.SetGlobalLocation(Offset(globalX, globalY));
+        info.SetLocalLocation(Offset(localX, localY));
+        info.SetScreenLocation(Offset(screenX, screenY));
+        info.SetTouchType(touchEvent.type);
+        info.SetForce(item.force);
+        if (item.tiltX.has_value()) {
+            info.SetTiltX(item.tiltX.value());
+        }
+        if (item.tiltY.has_value()) {
+            info.SetTiltY(item.tiltY.value());
+        }
+        info.SetSourceTool(item.sourceTool);
+        event.AddTouchLocationInfo(std::move(info));
+    }
+}
+
 } // namespace OHOS::Ace::NG
diff --git a/frameworks/core/components_ng/base/frame_node.h b/frameworks/core/components_ng/base/frame_node.h
index fac1b9754b3ec56d7fe1bf61dc6034af4acb41bd..3cd2f429ecb51c902c9f18caa9dbda2acf8498fb 100644
--- a/frameworks/core/components_ng/base/frame_node.h
+++ b/frameworks/core/components_ng/base/frame_node.h
@@ -809,6 +809,10 @@ private:
 
     void SetCachedTransformRelativeOffset(const std::pair<uint64_t, OffsetF>& timestampOffset);
 
+    HitTestMode TriggerOnTouchIntercept(const TouchEvent& touchEvent);
+
+    void AddTouchEventAllFingersInfo(TouchEventInfo& event, const TouchEvent& touchEvent);
+
     // sort in ZIndex.
     std::multiset<WeakPtr<FrameNode>, ZIndexComparator> frameChildren_;
     RefPtr<GeometryNode> geometryNode_ = MakeRefPtr<GeometryNode>();
diff --git a/frameworks/core/components_ng/base/inspector.cpp b/frameworks/core/components_ng/base/inspector.cpp
index 981e013e3f077d707162509b236efe89cd9a8683..6b78dde61a606b456285d9db6cce4229ba8587fd 100644
--- a/frameworks/core/components_ng/base/inspector.cpp
+++ b/frameworks/core/components_ng/base/inspector.cpp
@@ -27,6 +27,7 @@
 #include "core/components_ng/pattern/stage/page_pattern.h"
 #include "core/components_ng/pattern/text/span_node.h"
 #include "core/components_v2/inspector/inspector_constants.h"
+#include "core/event/touch_event.h"
 #include "core/pipeline_ng/pipeline_context.h"
 #include "frameworks/base/memory/type_info_base.h"
 
@@ -93,11 +94,12 @@ void DumpElementTree(
 
 TouchEvent GetUpPoint(const TouchEvent& downPoint)
 {
-    return { .x = downPoint.x,
-        .y = downPoint.y,
-        .type = TouchType::UP,
-        .time = std::chrono::high_resolution_clock::now(),
-        .sourceType = SourceType::TOUCH };
+    return TouchEvent {}
+        .SetX(downPoint.x)
+        .SetY(downPoint.y)
+        .SetType(TouchType::UP)
+        .SetTime(std::chrono::high_resolution_clock::now())
+        .SetSourceType(SourceType::TOUCH);
 }
 #ifdef PREVIEW
 void GetFrameNodeChildren(const RefPtr<NG::UINode>& uiNode, std::vector<RefPtr<NG::UINode>>& children, int32_t pageId)
@@ -648,12 +650,12 @@ bool Inspector::SendEventByKey(const std::string& key, int action, const std::st
             if (!context) {
                 return;
             }
-
-            TouchEvent point { .x = (rect.Left() + rect.Width() / 2),
-                .y = (rect.Top() + rect.Height() / 2),
-                .type = TouchType::DOWN,
-                .time = std::chrono::high_resolution_clock::now(),
-                .sourceType = SourceType::TOUCH };
+            TouchEvent point;
+            point.SetX(static_cast<float>(rect.Left() + rect.Width() / 2))
+                .SetY(static_cast<float>(rect.Top() + rect.Height() / 2))
+                .SetType(TouchType::DOWN)
+                .SetTime(std::chrono::high_resolution_clock::now())
+                .SetSourceType(SourceType::TOUCH);
             context->OnTouchEvent(point.UpdatePointers());
 
             switch (action) {
diff --git a/frameworks/core/components_ng/base/view_abstract.cpp b/frameworks/core/components_ng/base/view_abstract.cpp
index 4e4455f89939aec5c38ccd087910661deb276b40..2be233ace43a5cfe3728520b2a4d1fa16238d4d4 100755
--- a/frameworks/core/components_ng/base/view_abstract.cpp
+++ b/frameworks/core/components_ng/base/view_abstract.cpp
@@ -824,6 +824,13 @@ void ViewAbstract::SetOnGestureJudgeBegin(GestureJudgeFunc &&gestureJudgeFunc)
     gestureHub->SetOnGestureJudgeBegin(std::move(gestureJudgeFunc));
 }
 
+void ViewAbstract::SetOnTouchIntercept(TouchInterceptFunc&& touchInterceptFunc)
+{
+    auto gestureHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeGestureEventHub();
+    CHECK_NULL_VOID(gestureHub);
+    gestureHub->SetOnTouchIntercept(std::move(touchInterceptFunc));
+}
+
 void ViewAbstract::SetOnTouch(TouchEventFunc &&touchEventFunc)
 {
     auto gestureHub = ViewStackProcessor::GetInstance()->GetMainFrameNodeGestureEventHub();
diff --git a/frameworks/core/components_ng/base/view_abstract.h b/frameworks/core/components_ng/base/view_abstract.h
index 83d514c5ae6dd27a2faa790d16793f17f263ceeb..77ad25850f7a795ee572f482f9deb19a2867360a 100644
--- a/frameworks/core/components_ng/base/view_abstract.h
+++ b/frameworks/core/components_ng/base/view_abstract.h
@@ -224,6 +224,7 @@ public:
     // event
     static void SetOnClick(GestureEventFunc &&clickEventFunc);
     static void SetOnGestureJudgeBegin(GestureJudgeFunc &&gestureJudgeFunc);
+    static void SetOnTouchIntercept(TouchInterceptFunc &&touchInterceptFunc);
     static void SetOnTouch(TouchEventFunc &&touchEventFunc);
     static void SetOnMouse(OnMouseEventFunc &&onMouseEventFunc);
     static void SetOnHover(OnHoverFunc &&onHoverEventFunc);
diff --git a/frameworks/core/components_ng/base/view_abstract_model.h b/frameworks/core/components_ng/base/view_abstract_model.h
index 67d06e177f96a2f5d94e395149a2341d9eb8ab9f..ce8799df48203114246f76d3398f245ea9a7a84b 100755
--- a/frameworks/core/components_ng/base/view_abstract_model.h
+++ b/frameworks/core/components_ng/base/view_abstract_model.h
@@ -215,6 +215,7 @@ public:
     // event
     virtual void SetOnClick(GestureEventFunc&& tapEventFunc, ClickEventFunc&& clickEventFunc) = 0;
     virtual void SetOnGestureJudgeBegin(NG::GestureJudgeFunc&& gestureJudgeFunc) = 0;
+    virtual void SetOnTouchIntercept(NG::TouchInterceptFunc&& touchInterceptFunc) = 0;
     virtual void SetOnTouch(TouchEventFunc&& touchEventFunc) = 0;
     virtual void SetOnKeyEvent(OnKeyCallbackFunc&& onKeyCallback) = 0;
     virtual void SetOnMouse(OnMouseEventFunc&& onMouseEventFunc) = 0;
diff --git a/frameworks/core/components_ng/base/view_abstract_model_ng.h b/frameworks/core/components_ng/base/view_abstract_model_ng.h
index 46651997d4c2c39b2e7fe72d6cc3ada7795ce58c..16eb885eacce9ad7412d3d131d2f7e490fd56d0b 100755
--- a/frameworks/core/components_ng/base/view_abstract_model_ng.h
+++ b/frameworks/core/components_ng/base/view_abstract_model_ng.h
@@ -765,6 +765,11 @@ public:
         ViewAbstract::SetOnGestureJudgeBegin(std::move(gestureJudgeFunc));
     }
 
+    void SetOnTouchIntercept(NG::TouchInterceptFunc&& touchInterceptFunc) override
+    {
+        ViewAbstract::SetOnTouchIntercept(std::move(touchInterceptFunc));
+    }
+
     void SetOnTouch(TouchEventFunc&& touchEventFunc) override
     {
         ViewAbstract::SetOnTouch(std::move(touchEventFunc));
diff --git a/frameworks/core/components_ng/event/gesture_event_hub.cpp b/frameworks/core/components_ng/event/gesture_event_hub.cpp
index 9afb96fc9ef803882bd639345f1de4698a774df7..1afd2077f14404e529d259ac2c4ce846ea94d29e 100644
--- a/frameworks/core/components_ng/event/gesture_event_hub.cpp
+++ b/frameworks/core/components_ng/event/gesture_event_hub.cpp
@@ -1019,6 +1019,16 @@ void GestureEventHub::SetOnGestureJudgeBegin(GestureJudgeFunc&& gestureJudgeFunc
     gestureJudgeFunc_ = std::move(gestureJudgeFunc);
 }
 
+void GestureEventHub::SetOnTouchIntercept(TouchInterceptFunc&& touchInterceptFunc)
+{
+    touchInterceptFunc_ = std::move(touchInterceptFunc);
+}
+
+TouchInterceptFunc GestureEventHub::GetOnTouchIntercept() const
+{
+    return touchInterceptFunc_;
+}
+
 void GestureEventHub::SetOnGestureJudgeNativeBegin(GestureJudgeFunc&& gestureJudgeFunc)
 {
     gestureJudgeNativeFunc_ = std::move(gestureJudgeFunc);
@@ -1372,4 +1382,31 @@ RefPtr<UnifiedData> GestureEventHub::GetUnifiedData(const std::string& frameTag,
     }
     return unifiedData;
 }
+
+void GestureEventHub::SetResponseRegion(const std::vector<DimensionRect>& responseRegion)
+{
+    responseRegion_ = responseRegion;
+    if (!responseRegion_.empty()) {
+        isResponseRegion_ = true;
+    }
+    if (responseRegionFunc_) {
+        responseRegionFunc_(responseRegion_);
+    }
+}
+
+void GestureEventHub::RemoveLastResponseRect()
+    {
+        if (responseRegion_.empty()) {
+            isResponseRegion_ = false;
+            return;
+        }
+        responseRegion_.pop_back();
+        if (responseRegion_.empty()) {
+            isResponseRegion_ = false;
+        }
+
+        if (responseRegionFunc_) {
+            responseRegionFunc_(responseRegion_);
+        }
+    }
 } // namespace OHOS::Ace::NG
diff --git a/frameworks/core/components_ng/event/gesture_event_hub.h b/frameworks/core/components_ng/event/gesture_event_hub.h
index d7d9c17896d053125c508c49dee0f63be23b5622..201af2271640d249d3730bb78dc6cadd837bd695 100644
--- a/frameworks/core/components_ng/event/gesture_event_hub.h
+++ b/frameworks/core/components_ng/event/gesture_event_hub.h
@@ -81,6 +81,8 @@ enum class HitTestMode {
     HTMTRANSPARENT_SELF,
 };
 
+using TouchInterceptFunc = std::function<NG::HitTestMode(TouchEventInfo&)>;
+
 enum class TouchTestStrategy {
     DEFAULT = 0,
     FORWARD_COMPETITION,
@@ -247,6 +249,10 @@ public:
 
     void SetOnGestureJudgeBegin(GestureJudgeFunc&& gestureJudgeFunc);
 
+    void SetOnTouchIntercept(TouchInterceptFunc&& touchInterceptFunc);
+
+    TouchInterceptFunc GetOnTouchIntercept() const;
+
     void SetOnGestureJudgeNativeBegin(GestureJudgeFunc&& gestureJudgeFunc);
 
     GestureJudgeFunc GetOnGestureJudgeBeginCallback() const
@@ -401,16 +407,7 @@ public:
         responseRegionFunc_ = func;
     }
 
-    void SetResponseRegion(const std::vector<DimensionRect>& responseRegion)
-    {
-        responseRegion_ = responseRegion;
-        if (!responseRegion_.empty()) {
-            isResponseRegion_ = true;
-        }
-        if (responseRegionFunc_) {
-            responseRegionFunc_(responseRegion_);
-        }
-    }
+    void SetResponseRegion(const std::vector<DimensionRect>& responseRegion);
 
     void SetOnTouchTestFunc(OnChildTouchTestFunc&& callback)
     {
@@ -440,21 +437,7 @@ public:
         }
     }
 
-    void RemoveLastResponseRect()
-    {
-        if (responseRegion_.empty()) {
-            isResponseRegion_ = false;
-            return;
-        }
-        responseRegion_.pop_back();
-        if (responseRegion_.empty()) {
-            isResponseRegion_ = false;
-        }
-
-        if (responseRegionFunc_) {
-            responseRegionFunc_(responseRegion_);
-        }
-    }
+    void RemoveLastResponseRect();
 
     bool GetTouchable() const
     {
@@ -652,6 +635,8 @@ private:
     GestureJudgeFunc gestureJudgeFunc_;
     GestureJudgeFunc gestureJudgeNativeFunc_;
 
+    TouchInterceptFunc touchInterceptFunc_;
+
     MenuPreviewMode previewMode_ = MenuPreviewMode::NONE;
     bool textDraggable_ = false;
     bool isTextDraggable_ = false;
diff --git a/frameworks/core/components_ng/pattern/model/model_touch_handler.cpp b/frameworks/core/components_ng/pattern/model/model_touch_handler.cpp
index 9465f640de9d29bb7a6c6ae193e1f8979d20da08..32e880fedd33d1602f358ae933653eee13c94c31 100644
--- a/frameworks/core/components_ng/pattern/model/model_touch_handler.cpp
+++ b/frameworks/core/components_ng/pattern/model/model_touch_handler.cpp
@@ -14,6 +14,7 @@
  */
 
 #include "core/components_ng/pattern/model/model_touch_handler.h"
+#include "core/event/touch_event.h"
 
 namespace OHOS::Ace::NG {
 
@@ -64,14 +65,13 @@ bool ModelTouchHandler::HandleTouchEvent(const TouchEventInfo& info, uint32_t vi
 TouchEvent ModelTouchHandler::CreateTouchEvent(const TouchEventInfo& info) const
 {
     auto point = info.GetChangedTouches().front();
-    return {
-        .id = point.GetFingerId(),
-        .x = point.GetLocalLocation().GetX(),
-        .y = point.GetLocalLocation().GetY(),
-        .screenX = point.GetGlobalLocation().GetX(),
-        .screenY = point.GetGlobalLocation().GetY(),
-        .type = point.GetTouchType()
-    };
+    return TouchEvent {}
+        .SetId(point.GetFingerId())
+        .SetX(point.GetLocalLocation().GetX())
+        .SetY(point.GetLocalLocation().GetY())
+        .SetScreenX(point.GetGlobalLocation().GetX())
+        .SetScreenY(point.GetGlobalLocation().GetY())
+        .SetType(point.GetTouchType());
 }
 
 Render3D::PointerEvent ModelTouchHandler::CreateSceneTouchEvent(const TouchEvent& point,
diff --git a/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.cpp b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.cpp
index 6ed1b32788fb19cea4da0f8433e336a18093bdba..595c5688b0d6743babd09b076e631db4c7b92017 100644
--- a/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.cpp
+++ b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.cpp
@@ -15,14 +15,17 @@
 
 #include "core/components_ng/pattern/xcomponent/xcomponent_pattern.h"
 
+#include "interfaces/native/native_event.h"
 #include "interfaces/native/ui_input_event.h"
 
 #include "base/geometry/ng/size_t.h"
 #include "base/log/log_wrapper.h"
+#include "base/memory/ace_type.h"
 #include "base/ressched/ressched_report.h"
 #include "base/utils/system_properties.h"
 #include "base/utils/utils.h"
 #include "core/components/common/layout/constants.h"
+#include "core/components_ng/event/gesture_event_hub.h"
 #include "core/components_ng/pattern/xcomponent/xcomponent_controller_ng.h"
 #include "core/event/axis_event.h"
 #ifdef NG_BUILD
@@ -541,6 +544,7 @@ void XComponentPattern::InitEvent()
     auto gestureHub = eventHub->GetOrCreateGestureEventHub();
     CHECK_NULL_VOID(gestureHub);
     InitTouchEvent(gestureHub);
+    InitOnTouchIntercept(gestureHub);
     auto inputHub = eventHub->GetOrCreateInputEventHub();
     InitMouseEvent(inputHub);
     InitAxisEvent(inputHub);
@@ -640,6 +644,20 @@ void XComponentPattern::InitAxisEvent(const RefPtr<InputEventHub>& inputHub)
     inputHub->AddOnAxisEvent(axisEvent_);
 }
 
+void XComponentPattern::InitOnTouchIntercept(const RefPtr<GestureEventHub>& gestureHub)
+{
+    gestureHub->SetOnTouchIntercept(
+        [pattern = Claim(this)](
+            const TouchEventInfo& touchEvent) -> HitTestMode {
+            auto event = touchEvent.ConvertToTouchEvent();
+            auto* uiEvent = static_cast<ArkUI_UIInputEvent*>(&event);
+            CHECK_NULL_RETURN(uiEvent, NG::HitTestMode::HTMDEFAULT);
+            const auto onTouchInterceptCallback = pattern->nativeXComponentImpl_->GetOnTouchInterceptCallback();
+            CHECK_NULL_RETURN(onTouchInterceptCallback, NG::HitTestMode::HTMDEFAULT);
+            return static_cast<NG::HitTestMode>(onTouchInterceptCallback(pattern->nativeXComponent_.get(), uiEvent));
+        });
+}
+
 void XComponentPattern::InitMouseEvent(const RefPtr<InputEventHub>& inputHub)
 {
     CHECK_NULL_VOID(!mouseEvent_);
diff --git a/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.h b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.h
index 742ba13e11f40158ae716e2e7345bd0b09e033d5..c62d3f6f4cae7f32496f0cc6679c480e82a4d5cb 100644
--- a/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.h
+++ b/frameworks/core/components_ng/pattern/xcomponent/xcomponent_pattern.h
@@ -280,6 +280,7 @@ private:
     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);
diff --git a/frameworks/core/components_v2/inspector/inspector.cpp b/frameworks/core/components_v2/inspector/inspector.cpp
index 74d7c38218ad4eff6b70796243629b5a7c404094..1c1891a042fdab8b96bb5134778f3c11ccbaf279 100644
--- a/frameworks/core/components_v2/inspector/inspector.cpp
+++ b/frameworks/core/components_v2/inspector/inspector.cpp
@@ -217,19 +217,20 @@ bool Inspector::SendEventByKey(
             if (!context) {
                 return;
             }
-
-            TouchEvent point { .x = static_cast<float>(rect.Left() + rect.Width() / 2),
-                .y = static_cast<float>(rect.Top() + rect.Height() / 2),
-                .type = TouchType::DOWN,
-                .time = std::chrono::high_resolution_clock::now() };
+            TouchEvent point;
+            point.SetX(static_cast<float>(rect.Left() + rect.Width() / 2))
+                .SetY(static_cast<float>(rect.Top() + rect.Height() / 2))
+                .SetType(TouchType::DOWN)
+                .SetTime(std::chrono::high_resolution_clock::now());
             context->OnTouchEvent(point);
 
             switch (action) {
                 case static_cast<int>(AceAction::ACTION_CLICK): {
-                    TouchEvent upPoint { .x = point.x,
-                        .y = point.y,
-                        .type = TouchType::UP,
-                        .time = std::chrono::high_resolution_clock::now() };
+                    TouchEvent upPoint;
+                    upPoint.SetX(point.x)
+                        .SetY(point.y)
+                        .SetType(TouchType::UP)
+                        .SetTime(std::chrono::high_resolution_clock::now());
                     context->OnTouchEvent(upPoint);
                     break;
                 }
@@ -238,10 +239,11 @@ bool Inspector::SendEventByKey(
                     auto&& callback = [weak, point]() {
                         auto refPtr = weak.Upgrade();
                         if (refPtr) {
-                            TouchEvent upPoint { .x = point.x,
-                                .y = point.y,
-                                .type = TouchType::UP,
-                                .time = std::chrono::high_resolution_clock::now() };
+                            TouchEvent upPoint;
+                            upPoint.SetX(point.x)
+                                .SetY(point.y)
+                                .SetType(TouchType::UP)
+                                .SetTime(std::chrono::high_resolution_clock::now());
                             refPtr->OnTouchEvent(upPoint);
                         }
                     };
diff --git a/frameworks/core/event/event_convertor.cpp b/frameworks/core/event/event_convertor.cpp
index 1d587f9d208980c8cf707f36e2dd9532f752289f..129095fe87b8b33c133934fd1fc0cabc33f2f176 100644
--- a/frameworks/core/event/event_convertor.cpp
+++ b/frameworks/core/event/event_convertor.cpp
@@ -30,42 +30,54 @@ void ConvertTouchEvent(const std::vector<uint8_t>& data, std::vector<TouchEvent>
     while (current < end) {
         std::chrono::microseconds micros(current->timeStamp);
         TimeStamp time(micros);
-        TouchEvent point { static_cast<int32_t>(current->actionId), static_cast<float>(current->physicalX),
-            static_cast<float>(current->physicalY), static_cast<float>(current->physicalX),
-            static_cast<float>(current->physicalY), TouchType::UNKNOWN, TouchType::UNKNOWN, time, current->size,
-            static_cast<float>(current->pressure), static_cast<int64_t>(current->sourceDeviceId) };
-        point.sourceType = static_cast<SourceType>(current->sourceDevice);
-        switch (current->actionType) {
-            case AceActionData::ActionType::CANCEL:
-                point.type = TouchType::CANCEL;
-                events.push_back(point);
-                break;
-            case AceActionData::ActionType::ADD:
-            case AceActionData::ActionType::REMOVE:
-            case AceActionData::ActionType::HOVER:
-                break;
-            case AceActionData::ActionType::DOWN:
-                point.type = TouchType::DOWN;
-                events.push_back(point);
-                break;
-            case AceActionData::ActionType::MOVE:
-                point.type = TouchType::MOVE;
-                events.push_back(point);
-                break;
-            case AceActionData::ActionType::UP:
-                point.type = TouchType::UP;
-                events.push_back(point);
-                break;
-            case AceActionData::ActionType::UNKNOWN:
-                break;
-            default:
-                break;
-        }
+        TouchEvent point;
+        point.SetId(static_cast<int32_t>(current->actionId))
+            .SetX(static_cast<float>(current->physicalX))
+            .SetY(static_cast<float>(current->physicalY))
+            .SetScreenX(static_cast<float>(current->physicalX))
+            .SetScreenY(static_cast<float>(current->physicalY))
+            .SetType(TouchType::UNKNOWN)
+            .SetPullType(TouchType::UNKNOWN)
+            .SetTime(time)
+            .SetSize(current->size)
+            .SetForce(static_cast<float>(current->pressure))
+            .SetDeviceId(static_cast<int64_t>(current->sourceDeviceId))
+            .SetSourceType(static_cast<SourceType>(current->sourceDevice));
+        SetTouchEventType(current->actionType, point, events);
         current++;
     }
     UpdateTouchEvent(events);
 }
 
+void SetTouchEventType(AceActionData::ActionType actionType, TouchEvent& point, std::vector<TouchEvent>& events)
+{
+    switch (actionType) {
+        case AceActionData::ActionType::CANCEL:
+            point.type = TouchType::CANCEL;
+            events.push_back(point);
+            return;
+        case AceActionData::ActionType::ADD:
+        case AceActionData::ActionType::REMOVE:
+        case AceActionData::ActionType::HOVER:
+            return;
+        case AceActionData::ActionType::DOWN:
+            point.type = TouchType::DOWN;
+            events.push_back(point);
+            return;
+        case AceActionData::ActionType::MOVE:
+            point.type = TouchType::MOVE;
+            events.push_back(point);
+            return;
+        case AceActionData::ActionType::UP:
+            point.type = TouchType::UP;
+            events.push_back(point);
+            return;
+        case AceActionData::ActionType::UNKNOWN:
+        default:
+            return;
+    }
+}
+
 void UpdateTouchEvent(std::vector<TouchEvent>& events)
 {
     if (events.empty()) {
diff --git a/frameworks/core/event/event_convertor.h b/frameworks/core/event/event_convertor.h
index abb95ed04cca0a02f2bcb8ed74bd3add1b71da42..2e25e7698fc1078e3ef78cc49b49a6c3e68140d5 100644
--- a/frameworks/core/event/event_convertor.h
+++ b/frameworks/core/event/event_convertor.h
@@ -89,6 +89,8 @@ struct alignas(8) AceMouseData {
 
 void ConvertTouchEvent(const std::vector<uint8_t>& data, std::vector<TouchEvent>& events);
 
+void SetTouchEventType(AceActionData::ActionType actionType, TouchEvent& point, std::vector<TouchEvent>& events);
+
 void UpdateTouchEvent(std::vector<TouchEvent>& events);
 
 void ConvertMouseEvent(const std::vector<uint8_t>& data, MouseEvent& events);
diff --git a/frameworks/core/event/mouse_event.h b/frameworks/core/event/mouse_event.h
index eebae7d8cac73c80bb2489e4f4eee5a5ca3c4283..fc49479a6a6a132dab9f0b6f02d519c51795a0e3 100644
--- a/frameworks/core/event/mouse_event.h
+++ b/frameworks/core/event/mouse_event.h
@@ -192,19 +192,19 @@ struct MouseEvent final {
             .downTime = time,
             .size = 0.0,
             .isPressed = (type == TouchType::DOWN) };
-        TouchEvent event { .id = pointId,
-            .x = x,
-            .y = y,
-            .screenX = screenX,
-            .screenY = screenY,
-            .type = type,
-            .time = time,
-            .size = 0.0,
-            .deviceId = deviceId,
-            .targetDisplayId = targetDisplayId,
-            .sourceType = sourceType,
-            .pointerEvent = pointerEvent,
-        };
+        TouchEvent event;
+        event.SetId(id)
+            .SetX(x)
+            .SetY(y)
+            .SetScreenX(screenX)
+            .SetScreenY(screenY)
+            .SetType(type)
+            .SetTime(time)
+            .SetSize(0.0)
+            .SetDeviceId(deviceId)
+            .SetTargetDisplayId(targetDisplayId)
+            .SetSourceType(sourceType)
+            .SetPointerEvent(pointerEvent);
         event.pointers.emplace_back(std::move(point));
         return event;
     }
diff --git a/frameworks/core/event/touch_event.h b/frameworks/core/event/touch_event.h
index c9d904af565d193f2b64049ed1f7b9333c7e7d97..94e79a0564a8f7e080f03a8690b0b4703b6b6091 100755
--- a/frameworks/core/event/touch_event.h
+++ b/frameworks/core/event/touch_event.h
@@ -17,6 +17,9 @@
 #define FOUNDATION_ACE_FRAMEWORKS_CORE_EVENT_TOUCH_EVENT_H
 
 #include <list>
+#include <utility>
+
+#include "interfaces/native/ui_input_event.h"
 
 #include "base/geometry/offset.h"
 #include "base/memory/ace_type.h"
@@ -68,7 +71,8 @@ struct TouchPoint final {
 /**
  * @brief TouchEvent contains the active change point and a list of all touch points.
  */
-struct TouchEvent final {
+struct TouchEvent final : public UIInputEvent {
+    ~TouchEvent() = default;
     // the active changed point info
     // The ID is used to identify the point of contact between the finger and the screen. Different fingers have
     // different ids.
@@ -79,8 +83,6 @@ struct TouchEvent final {
     float screenY = 0.0f;
     TouchType type = TouchType::UNKNOWN;
     TouchType pullType = TouchType::UNKNOWN;
-    // nanosecond time stamp.
-    TimeStamp time;
     double size = 0.0;
     float force = 0.0f;
     std::optional<float> tiltX;
@@ -98,6 +100,165 @@ struct TouchEvent final {
     // historical points
     std::vector<TouchEvent> history;
 
+    // Coordinates relative to the upper-left corner of the current component
+    float localX = 0.0f;
+    float localY = 0.0f;
+
+    TouchEvent()
+    {
+        eventType = ArkUI_UIInputEvent_Type::ARKUI_UIINPUTEVENT_TYPE_TOUCH;
+    }
+
+    TouchEvent& SetId(int32_t id)
+    {
+        this->id = id;
+        return *this;
+    }
+
+    TouchEvent& SetX(float x)
+    {
+        this->x = x;
+        return *this;
+    }
+
+    TouchEvent& SetY(float y)
+    {
+        this->y = y;
+        return *this;
+    }
+
+    TouchEvent& SetScreenX(float screenX)
+    {
+        this->screenX = screenX;
+        return *this;
+    }
+
+    TouchEvent& SetScreenY(float screenY)
+    {
+        this->screenY = screenY;
+        return *this;
+    }
+
+    TouchEvent& SetTime(TimeStamp time)
+    {
+        this->time = time;
+        return *this;
+    }
+
+    TouchEvent& SetType(TouchType type)
+    {
+        this->type = type;
+        return *this;
+    }
+
+    TouchEvent& SetPullType(TouchType pullType)
+    {
+        this->pullType = pullType;
+        return *this;
+    }
+
+    TouchEvent& SetSize(double size)
+    {
+        this->size = size;
+        return *this;
+    }
+
+    TouchEvent& SetForce(float force)
+    {
+        this->force = force;
+        return *this;
+    }
+
+    TouchEvent& SetTiltX(std::optional<float> tiltX)
+    {
+        this->tiltX = tiltX;
+        return *this;
+    }
+
+    TouchEvent& SetTiltY(std::optional<float> tiltY)
+    {
+        this->tiltY = tiltY;
+        return *this;
+    }
+
+    TouchEvent& SetDeviceId(int64_t deviceId)
+    {
+        this->deviceId = deviceId;
+        return *this;
+    }
+
+    TouchEvent& SetTargetDisplayId(int32_t targetDisplayId)
+    {
+        this->targetDisplayId = targetDisplayId;
+        return *this;
+    }
+
+    TouchEvent& SetSourceType(SourceType sourceType)
+    {
+        this->sourceType = sourceType;
+        return *this;
+    }
+
+    TouchEvent& SetSourceTool(SourceTool sourceTool)
+    {
+        this->sourceTool = sourceTool;
+        return *this;
+    }
+
+    TouchEvent& SetTouchEventId(int32_t touchEventId)
+    {
+        this->touchEventId = touchEventId;
+        return *this;
+    }
+
+    TouchEvent& SetIsInterpolated(bool isInterpolated)
+    {
+        this->isInterpolated = isInterpolated;
+        return *this;
+    }
+
+    TouchEvent& SetPointers(std::vector<TouchPoint> pointers)
+    {
+        this->pointers = std::move(pointers);
+        return *this;
+    }
+
+    TouchEvent& SetPointerEvent(std::shared_ptr<MMI::PointerEvent> pointerEvent)
+    {
+        this->pointerEvent = std::move(pointerEvent);
+        return *this;
+    }
+
+    TouchEvent CloneWith(float scale) const
+    {
+        return CloneWith(scale, 0.0f, 0.0f, std::nullopt);
+    }
+
+    TouchEvent CloneWith(float scale, float offsetX, float offsetY, std::optional<int32_t> pointId) const
+    {
+        return TouchEvent {}
+            .SetId(pointId.has_value() ? pointId.value() : id)
+            .SetX((x - offsetX) / scale)
+            .SetY((y - offsetY) / scale)
+            .SetScreenX((screenX - offsetX) / scale)
+            .SetScreenY((screenY - offsetY) / scale)
+            .SetType(type)
+            .SetPullType(pullType)
+            .SetTime(time)
+            .SetSize(size)
+            .SetForce(force)
+            .SetTiltX(tiltX)
+            .SetTiltY(tiltY)
+            .SetDeviceId(deviceId)
+            .SetTargetDisplayId(targetDisplayId)
+            .SetSourceType(sourceType)
+            .SetSourceTool(sourceTool)
+            .SetTouchEventId(touchEventId)
+            .SetIsInterpolated(isInterpolated)
+            .SetPointers(pointers)
+            .SetPointerEvent(pointerEvent);
+    }
+
     void ToJsonValue(std::unique_ptr<JsonValue>& json) const
     {
         json->Put("id", id);
@@ -170,8 +331,7 @@ struct TouchEvent final {
     TouchEvent CreateScalePoint(float scale) const
     {
         if (NearZero(scale)) {
-            return { id, x, y, screenX, screenY, type, pullType, time, size, force, tiltX, tiltY, deviceId,
-                targetDisplayId, sourceType, sourceTool, 0, isInterpolated, pointers, pointerEvent };
+            return CloneWith(1);
         }
         auto temp = pointers;
         std::for_each(temp.begin(), temp.end(), [scale](auto&& point) {
@@ -180,8 +340,7 @@ struct TouchEvent final {
             point.screenX = point.screenX / scale;
             point.screenY = point.screenY / scale;
         });
-        return { id, x / scale, y / scale, screenX / scale, screenY / scale, type, pullType, time, size, force, tiltX,
-            tiltY, deviceId, targetDisplayId, sourceType, sourceTool, 0, isInterpolated, temp, pointerEvent };
+        return CloneWith(scale);
     }
 
     TouchEvent UpdateScalePoint(float scale, float offsetX, float offsetY, int32_t pointId) const
@@ -194,9 +353,7 @@ struct TouchEvent final {
                 point.screenX = point.screenX - offsetX;
                 point.screenY = point.screenY - offsetY;
             });
-            return { pointId, x - offsetX, y - offsetY, screenX - offsetX, screenY - offsetY, type, pullType, time,
-                size, force, tiltX, tiltY, deviceId, targetDisplayId, sourceType, sourceTool, 0, isInterpolated, temp,
-                pointerEvent };
+            return CloneWith(1, offsetX, offsetY, pointId);
         }
 
         std::for_each(temp.begin(), temp.end(), [scale, offsetX, offsetY](auto&& point) {
@@ -205,9 +362,7 @@ struct TouchEvent final {
             point.screenX = (point.screenX - offsetX) / scale;
             point.screenY = (point.screenY - offsetY) / scale;
         });
-        return { pointId, (x - offsetX) / scale, (y - offsetY) / scale, (screenX - offsetX) / scale,
-            (screenY - offsetY) / scale, type, pullType, time, size, force, tiltX, tiltY, deviceId, targetDisplayId,
-            sourceType, sourceTool, 0, isInterpolated, temp, pointerEvent };
+        return CloneWith(scale, offsetX, offsetY, pointId);
     }
 
     TouchEvent UpdatePointers() const
@@ -221,21 +376,21 @@ struct TouchEvent final {
             .size = size,
             .force = force,
             .isPressed = (type == TouchType::DOWN) };
-        TouchEvent event { .id = id,
-            .x = x,
-            .y = y,
-            .screenX = screenX,
-            .screenY = screenY,
-            .type = type,
-            .time = time,
-            .size = size,
-            .force = force,
-            .deviceId = deviceId,
-            .targetDisplayId = targetDisplayId,
-            .sourceType = sourceType,
-            .isInterpolated = isInterpolated,
-            .pointerEvent = pointerEvent
-        };
+        TouchEvent event;
+        event.SetId(id)
+            .SetX(x)
+            .SetY(y)
+            .SetScreenX(screenX)
+            .SetScreenY(screenY)
+            .SetType(type)
+            .SetTime(time)
+            .SetSize(size)
+            .SetForce(force)
+            .SetDeviceId(deviceId)
+            .SetTargetDisplayId(targetDisplayId)
+            .SetSourceType(sourceType)
+            .SetIsInterpolated(isInterpolated)
+            .SetPointerEvent(pointerEvent);
         event.pointers.emplace_back(std::move(point));
         return event;
     }
@@ -740,6 +895,26 @@ public:
     {
         return isTouchEventsEnd_;
     }
+
+    TouchEvent ConvertToTouchEvent() const
+    {
+        TouchEvent touchEvent;
+        if (!changedTouches_.empty()) {
+            touchEvent.x = static_cast<float>(changedTouches_.front().GetGlobalLocation().GetX());
+            touchEvent.y = static_cast<float>(changedTouches_.front().GetGlobalLocation().GetY());
+            touchEvent.screenX = static_cast<float>(changedTouches_.front().GetScreenLocation().GetX());
+            touchEvent.screenY = static_cast<float>(changedTouches_.front().GetScreenLocation().GetY());
+            touchEvent.localX = static_cast<float>(changedTouches_.front().GetLocalLocation().GetX());
+            touchEvent.localY = static_cast<float>(changedTouches_.front().GetLocalLocation().GetY());
+            touchEvent.id = changedTouches_.front().GetFingerId();
+            touchEvent.force = changedTouches_.front().GetForce();
+            touchEvent.type = changedTouches_.front().GetTouchType();
+            touchEvent.tiltX = changedTouches_.front().GetTiltX();
+            touchEvent.tiltY = changedTouches_.front().GetTiltY();
+        }
+        touchEvent.time = timeStamp_;
+        return touchEvent;
+    }
 private:
     std::shared_ptr<MMI::PointerEvent> pointerEvent_;
     std::list<TouchLocationInfo> touches_;
diff --git a/interfaces/native/event/ui_input_event.cpp b/interfaces/native/event/ui_input_event.cpp
index a30b4ee74ef6fc00d2ea8c756cca1c64b2c50c1d..baa2541e1b17165b2e8992488732b032e11e1ea7 100644
--- a/interfaces/native/event/ui_input_event.cpp
+++ b/interfaces/native/event/ui_input_event.cpp
@@ -15,8 +15,9 @@
 
 #include "interfaces/native/ui_input_event.h"
 
-#include "frameworks/core/event/axis_event.h"
+#include "core/event/touch_event.h"
 #include "frameworks/base/utils/type_definition.h"
+#include "frameworks/core/event/axis_event.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -24,7 +25,7 @@ extern "C" {
 
 int32_t OH_ArkUI_UIInputEvent_GetType(const ArkUI_UIInputEvent* event)
 {
-    const auto *uiEvent = static_cast<const OHOS::Ace::UIInputEvent*>(event);
+    const auto* uiEvent = static_cast<const OHOS::Ace::UIInputEvent*>(event);
     if (!uiEvent) {
         LOGE("The parameter of OH_ArkUI_UIInputEvent_GetType is invalid");
         return 0;
@@ -32,9 +33,9 @@ int32_t OH_ArkUI_UIInputEvent_GetType(const ArkUI_UIInputEvent* event)
     return uiEvent->eventType;
 }
 
-int64_t OH_ArkUI_UIInputEvent_GetEventTime(const ArkUI_UIInputEvent *event)
+int64_t OH_ArkUI_UIInputEvent_GetEventTime(const ArkUI_UIInputEvent* event)
 {
-    const auto *uiEvent = static_cast<const OHOS::Ace::UIInputEvent*>(event);
+    const auto* uiEvent = static_cast<const OHOS::Ace::UIInputEvent*>(event);
     if (!uiEvent) {
         LOGE("The parameter of OH_ArkUI_UIInputEvent_GetEventTime is invalid");
         return 0;
@@ -42,21 +43,65 @@ int64_t OH_ArkUI_UIInputEvent_GetEventTime(const ArkUI_UIInputEvent *event)
     return uiEvent->time.time_since_epoch().count();
 }
 
-float OH_ArkUI_PointerEvent_GetX(const ArkUI_UIInputEvent *event)
+float OH_ArkUI_PointerEvent_GetX(const ArkUI_UIInputEvent* event)
 {
-    const auto *axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
-    if (axisEvent) {
-        return axisEvent->localX;
+    const auto* uiEvent = static_cast<const OHOS::Ace::UIInputEvent*>(event);
+    if (!uiEvent) {
+        LOGE("The parameter of OH_ArkUI_PointerEvent_GetX is invalid");
+        return 0.0f;
+    }
+    auto type = uiEvent->eventType;
+    switch (type) {
+        case ARKUI_UIINPUTEVENT_TYPE_UNKNOWN:
+            break;
+        case ARKUI_UIINPUTEVENT_TYPE_TOUCH: {
+            const auto* touchEvent = static_cast<const OHOS::Ace::TouchEvent*>(event);
+            if (touchEvent) {
+                return touchEvent->localX;
+            }
+            break;
+        }
+        case ARKUI_UIINPUTEVENT_TYPE_AXIS: {
+            const auto* axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
+            if (axisEvent) {
+                return axisEvent->localX;
+            }
+            break;
+        }
+        default:
+            break;
     }
     LOGE("The parameter of OH_ArkUI_PointerEvent_GetX is invalid");
     return 0.0f;
 }
 
-float OH_ArkUI_PointerEvent_GetY(const ArkUI_UIInputEvent *event)
+float OH_ArkUI_PointerEvent_GetY(const ArkUI_UIInputEvent* event)
 {
-    const auto *axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
-    if (axisEvent) {
-        return axisEvent->localY;
+    const auto* uiEvent = static_cast<const OHOS::Ace::UIInputEvent*>(event);
+    if (!uiEvent) {
+        LOGE("The parameter of OH_ArkUI_PointerEvent_GetY is invalid");
+        return 0.0f;
+    }
+    auto type = uiEvent->eventType;
+    switch (type) {
+        case ARKUI_UIINPUTEVENT_TYPE_UNKNOWN:
+            break;
+        case ARKUI_UIINPUTEVENT_TYPE_TOUCH: {
+            const auto* touchEvent = static_cast<const OHOS::Ace::TouchEvent*>(event);
+            if (touchEvent) {
+                return touchEvent->localY;
+            }
+            break;
+        }
+        case ARKUI_UIINPUTEVENT_TYPE_AXIS: {
+            const auto* axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
+            if (axisEvent) {
+                return axisEvent->localY;
+            }
+            break;
+        }
+        default:
+            break;
     }
     LOGE("The parameter of OH_ArkUI_PointerEvent_GetY is invalid");
     return 0.0f;
@@ -64,9 +109,31 @@ float OH_ArkUI_PointerEvent_GetY(const ArkUI_UIInputEvent *event)
 
 float OH_ArkUI_PointerEvent_GetWindowX(const ArkUI_UIInputEvent* event)
 {
-    const auto *axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
-    if (axisEvent) {
-        return axisEvent->x;
+    const auto* uiEvent = static_cast<const OHOS::Ace::UIInputEvent*>(event);
+    if (!uiEvent) {
+        LOGE("The parameter of OH_ArkUI_PointerEvent_GetWindowX is invalid");
+        return 0.0f;
+    }
+    auto type = uiEvent->eventType;
+    switch (type) {
+        case ARKUI_UIINPUTEVENT_TYPE_UNKNOWN:
+            break;
+        case ARKUI_UIINPUTEVENT_TYPE_TOUCH: {
+            const auto* touchEvent = static_cast<const OHOS::Ace::TouchEvent*>(event);
+            if (touchEvent) {
+                return touchEvent->x;
+            }
+            break;
+        }
+        case ARKUI_UIINPUTEVENT_TYPE_AXIS: {
+            const auto* axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
+            if (axisEvent) {
+                return axisEvent->x;
+            }
+            break;
+        }
+        default:
+            break;
     }
     LOGE("The parameter of OH_ArkUI_PointerEvent_GetWindowX is invalid");
     return 0.0f;
@@ -74,9 +141,31 @@ float OH_ArkUI_PointerEvent_GetWindowX(const ArkUI_UIInputEvent* event)
 
 float OH_ArkUI_PointerEvent_GetWindowY(const ArkUI_UIInputEvent* event)
 {
-    const auto *axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
-    if (axisEvent) {
-        return axisEvent->y;
+    const auto* uiEvent = static_cast<const OHOS::Ace::UIInputEvent*>(event);
+    if (!uiEvent) {
+        LOGE("The parameter of OH_ArkUI_PointerEvent_GetWindowY is invalid");
+        return 0.0f;
+    }
+    auto type = uiEvent->eventType;
+    switch (type) {
+        case ARKUI_UIINPUTEVENT_TYPE_UNKNOWN:
+            break;
+        case ARKUI_UIINPUTEVENT_TYPE_TOUCH: {
+            const auto* touchEvent = static_cast<const OHOS::Ace::TouchEvent*>(event);
+            if (touchEvent) {
+                return touchEvent->y;
+            }
+            break;
+        }
+        case ARKUI_UIINPUTEVENT_TYPE_AXIS: {
+            const auto* axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
+            if (axisEvent) {
+                return axisEvent->y;
+            }
+            break;
+        }
+        default:
+            break;
     }
     LOGE("The parameter of OH_ArkUI_PointerEvent_GetWindowY is invalid");
     return 0.0f;
@@ -84,9 +173,31 @@ float OH_ArkUI_PointerEvent_GetWindowY(const ArkUI_UIInputEvent* event)
 
 float OH_ArkUI_PointerEvent_GetDisplayX(const ArkUI_UIInputEvent* event)
 {
-    const auto *axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
-    if (axisEvent) {
-        return axisEvent->screenX;
+    const auto* uiEvent = static_cast<const OHOS::Ace::UIInputEvent*>(event);
+    if (!uiEvent) {
+        LOGE("The parameter of OH_ArkUI_PointerEvent_GetDisplayX is invalid");
+        return 0.0f;
+    }
+    auto type = uiEvent->eventType;
+    switch (type) {
+        case ARKUI_UIINPUTEVENT_TYPE_UNKNOWN:
+            break;
+        case ARKUI_UIINPUTEVENT_TYPE_TOUCH: {
+            const auto* touchEvent = static_cast<const OHOS::Ace::TouchEvent*>(event);
+            if (touchEvent) {
+                return touchEvent->screenX;
+            }
+            break;
+        }
+        case ARKUI_UIINPUTEVENT_TYPE_AXIS: {
+            const auto* axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
+            if (axisEvent) {
+                return axisEvent->screenX;
+            }
+            break;
+        }
+        default:
+            break;
     }
     LOGE("The parameter of OH_ArkUI_PointerEvent_GetDisplayX is invalid");
     return 0.0f;
@@ -94,9 +205,31 @@ float OH_ArkUI_PointerEvent_GetDisplayX(const ArkUI_UIInputEvent* event)
 
 float OH_ArkUI_PointerEvent_GetDisplayY(const ArkUI_UIInputEvent* event)
 {
-    const auto *axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
-    if (axisEvent) {
-        return axisEvent->screenY;
+    const auto* uiEvent = static_cast<const OHOS::Ace::UIInputEvent*>(event);
+    if (!uiEvent) {
+        LOGE("The parameter of OH_ArkUI_PointerEvent_GetDisplayY is invalid");
+        return 0.0f;
+    }
+    auto type = uiEvent->eventType;
+    switch (type) {
+        case ARKUI_UIINPUTEVENT_TYPE_UNKNOWN:
+            break;
+        case ARKUI_UIINPUTEVENT_TYPE_TOUCH: {
+            const auto* touchEvent = static_cast<const OHOS::Ace::TouchEvent*>(event);
+            if (touchEvent) {
+                return touchEvent->screenY;
+            }
+            break;
+        }
+        case ARKUI_UIINPUTEVENT_TYPE_AXIS: {
+            const auto* axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
+            if (axisEvent) {
+                return axisEvent->screenY;
+            }
+            break;
+        }
+        default:
+            break;
     }
     LOGE("The parameter of OH_ArkUI_PointerEvent_GetDisplayY is invalid");
     return 0.0f;
@@ -104,7 +237,7 @@ float OH_ArkUI_PointerEvent_GetDisplayY(const ArkUI_UIInputEvent* event)
 
 double OH_ArkUI_AxisEvent_GetVerticalAxisValue(const ArkUI_UIInputEvent* event)
 {
-    const auto *axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
+    const auto* axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
     if (!axisEvent) {
         LOGE("The parameter of OH_ArkUI_AxisEvent_GetVerticalAxisValue is invalid");
         return 0.0;
@@ -114,7 +247,7 @@ double OH_ArkUI_AxisEvent_GetVerticalAxisValue(const ArkUI_UIInputEvent* event)
 
 double OH_ArkUI_AxisEvent_GetHorizontalAxisValue(const ArkUI_UIInputEvent* event)
 {
-    const auto *axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
+    const auto* axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
     if (!axisEvent) {
         LOGE("The parameter of OH_ArkUI_AxisEvent_GetHorizontalAxisValue is invalid");
         return 0.0;
@@ -122,9 +255,9 @@ double OH_ArkUI_AxisEvent_GetHorizontalAxisValue(const ArkUI_UIInputEvent* event
     return axisEvent->horizontalAxis;
 }
 
-double OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(const ArkUI_UIInputEvent *event)
+double OH_ArkUI_AxisEvent_GetPinchAxisScaleValue(const ArkUI_UIInputEvent* event)
 {
-    const auto *axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
+    const auto* axisEvent = static_cast<const OHOS::Ace::AxisEvent*>(event);
     if (!axisEvent) {
         LOGE("The parameter of OH_ArkUI_AxisEvent_GetPinchAxisScaleValue is invalid");
         return 0.0;
diff --git a/interfaces/native/libace.ndk.json b/interfaces/native/libace.ndk.json
index b8dd472d0bbb0703febcfb79e17e1d587702f6ff..361a2ff68ac7df13553669529ebe75b3344971b4 100644
--- a/interfaces/native/libace.ndk.json
+++ b/interfaces/native/libace.ndk.json
@@ -158,5 +158,9 @@
     {
         "first_introduced": "12",
         "name": "OH_NativeXComponent_SetNeedSoftKeyboard"
+    },
+    {
+        "first_introduced": "12",
+        "name": "OH_NativeXComponent_RegisterOnTouchInterceptCallback"
     }
 ]
diff --git a/interfaces/native/native_event.h b/interfaces/native/native_event.h
index 923e78f50d78649a663434609090fd7009d09e09..e83bff3de550bbd196198ef2959061353a8bb7cc 100644
--- a/interfaces/native/native_event.h
+++ b/interfaces/native/native_event.h
@@ -225,6 +225,37 @@ typedef struct {
     bool preventDefault;
 } ArkUI_NodeTouchEvent;
 
+/**
+ * @brief Enumerates HitTestMode types.
+ *
+ * @since 12
+ */
+typedef enum {
+    /**
+     *  Both self and children respond to the hit test for touch events,
+     *  but block hit test of the other nodes which is masked by this node.
+     */
+    HTM_DEFAULT = 0,
+
+    /**
+     * Self respond to the hit test for touch events,
+     * but block hit test of children and other nodes which is masked by this node.
+     */
+    HTM_BLOCK,
+
+    /**
+     * Self and child respond to the hit test for touch events,
+     * and allow hit test of other nodes which is masked by this node.
+     */
+    HTM_TRANSPARENT,
+
+    /**
+     * Self not respond to the hit test for touch events,
+     * but children respond to the hit test for touch events.
+     */
+    HTM_NONE,
+} HitTestMode;
+
 #ifdef __cplusplus
 };
 #endif
diff --git a/interfaces/native/native_interface_xcomponent.cpp b/interfaces/native/native_interface_xcomponent.cpp
index 0a794a4bbd9447ce3cd3d83406f94ee327ac995e..04807ba0c2f72165a3d747d5f0935d43258d8aff 100644
--- a/interfaces/native/native_interface_xcomponent.cpp
+++ b/interfaces/native/native_interface_xcomponent.cpp
@@ -268,6 +268,15 @@ int32_t OH_NativeXComponent_SetNeedSoftKeyboard(OH_NativeXComponent* component,
     return component ? component->SetNeedSoftKeyboard(needSoftKeyboard) : OH_NATIVEXCOMPONENT_RESULT_BAD_PARAMETER;
 }
 
+int32_t OH_NativeXComponent_RegisterOnTouchInterceptCallback(
+    OH_NativeXComponent* component, HitTestMode (*callback)(OH_NativeXComponent* component, ArkUI_UIInputEvent* event))
+{
+    if ((component == nullptr) || (callback == nullptr)) {
+        return OHOS::Ace::ERROR_CODE_PARAM_INVALID;
+    }
+    return component->RegisterOnTouchInterceptCallback(callback);
+}
+
 #ifdef __cplusplus
 };
 #endif
diff --git a/interfaces/native/native_interface_xcomponent.h b/interfaces/native/native_interface_xcomponent.h
index 9df95903c6823327061ed94fe25433fe935d3e63..c5b64cab18acfbcb0dfb1c6eb8d3f005e820b318 100644
--- a/interfaces/native/native_interface_xcomponent.h
+++ b/interfaces/native/native_interface_xcomponent.h
@@ -39,6 +39,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 
+#include "native_event.h"
 #include "native_type.h"
 #include "native_xcomponent_key_event.h"
 #include "ui_input_event.h"
@@ -673,6 +674,18 @@ int32_t OH_NativeXComponent_RegisterUIInputEventCallback(OH_NativeXComponent* co
  */
 int32_t OH_NativeXComponent_SetNeedSoftKeyboard(OH_NativeXComponent* component, bool needSoftKeyboard);
 
+/**
+ * @brief Registers a callback for this <b>OH_NativeXComponent</b> instance.
+ *
+ * @param component Indicates the pointer to this <b>OH_NativeXComponent</b> instance.
+ * @param callback Indicates the pointer to a key event callback.
+ * @return Returns the status code of the execution.
+ * @since 10
+ * @version 1.0
+ */
+int32_t OH_NativeXComponent_RegisterOnTouchInterceptCallback(
+    OH_NativeXComponent* component, HitTestMode (*callback)(OH_NativeXComponent* component, ArkUI_UIInputEvent* event));
+
 #ifdef __cplusplus
 };
 #endif
diff --git a/test/unittest/core/event/event_manager_test_ng.cpp b/test/unittest/core/event/event_manager_test_ng.cpp
index ee6d23a3d0e3486e848ec80a5fb21b6c91062234..3860b90e3112fe5b528c12ba87e2d78df7fa2520 100644
--- a/test/unittest/core/event/event_manager_test_ng.cpp
+++ b/test/unittest/core/event/event_manager_test_ng.cpp
@@ -1267,7 +1267,8 @@ HWTEST_F(EventManagerTestNg, EventManagerTest025, TestSize.Level1)
     touchTestResults.push_back(AceType::MakeRefPtr<MockTouchEventTarget>());
     eventManager->touchTestResults_.emplace(resultId, touchTestResults);
 
-    TouchEvent event { .id = resultId };
+    TouchEvent event {};
+    event.id = resultId;
     std::list<TouchEvent> touchEvents { event };
     eventManager->FlushTouchEventsBegin(touchEvents);
     EXPECT_NE(eventManager->touchTestResults_.find(event.id), eventManager->touchTestResults_.end());
@@ -1292,7 +1293,8 @@ HWTEST_F(EventManagerTestNg, EventManagerTest026, TestSize.Level1)
     touchTestResults.push_back(AceType::MakeRefPtr<MockTouchEventTarget>());
     eventManager->touchTestResults_.emplace(resultId, touchTestResults);
 
-    TouchEvent event { .id = resultId };
+    TouchEvent event {};
+    event.id = resultId;
     std::list<TouchEvent> touchEvents { event };
     eventManager->FlushTouchEventsEnd(touchEvents);
     EXPECT_NE(eventManager->touchTestResults_.find(event.id), eventManager->touchTestResults_.end());
diff --git a/test/unittest/core/event/touch_event_test_ng.cpp b/test/unittest/core/event/touch_event_test_ng.cpp
index ea9d56e45569bd10b1e5902df2ddddb2027e7510..125706e41ec1d508dd9adfb3b6b1cec706f9d1f5 100644
--- a/test/unittest/core/event/touch_event_test_ng.cpp
+++ b/test/unittest/core/event/touch_event_test_ng.cpp
@@ -191,7 +191,8 @@ HWTEST_F(TouchEventTestNg, TouchEventActuatorHandleAndDispatchTest004, TestSize.
      * @tc.steps: step2. Invoke DispatchEvent.
      * @tc.expected: TouchTestResult size has been increased one.
      */
-    const TouchEvent touchEvent { .tiltX = TILT_X_VALUE, .tiltY = TILT_Y_VALUE, .pointers = POINTERS };
+    TouchEvent touchEvent;
+    touchEvent.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS);
     EXPECT_TRUE(touchEventActuator->DispatchEvent(touchEvent));
 
     /**
@@ -241,7 +242,8 @@ HWTEST_F(TouchEventTestNg, TouchEventActuatorHandleAndDispatchTest004, TestSize.
      * @tc.expected: HandleEvent return true;
      */
     touchEventActuator->userCallback_ = nullptr;
-    const TouchEvent touchEvent3 { .pointers = POINTERS_2 };
+    TouchEvent touchEvent3;
+    touchEvent3.SetPointers(POINTERS_2);
     EXPECT_TRUE(touchEventActuator->HandleEvent(touchEvent3));
 
     /**
@@ -274,7 +276,8 @@ HWTEST_F(TouchEventTestNg, TouchEventDisable001, TestSize.Level1)
      * @tc.steps: step2. Invoke DispatchEvent.
      * @tc.expected: TouchTestResult size has been increased one.
      */
-    const TouchEvent touchEvent { .tiltX = TILT_X_VALUE, .tiltY = TILT_Y_VALUE, .pointers = POINTERS };
+    TouchEvent touchEvent;
+    touchEvent.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS);
     EXPECT_TRUE(touchEventActuator->DispatchEvent(touchEvent));
 
     /**
@@ -379,7 +382,8 @@ HWTEST_F(TouchEventTestNg, TriggerTouchCallBack001, TestSize.Level1)
      * @tc.steps: step2. create TouchEvent object and call TriggerTouchCallBack.
      * @tc.expected: Execute function return value is true.
      */
-    TouchEvent touchEvent { .tiltX = TILT_X_VALUE, .tiltY = TILT_Y_VALUE, .pointers = POINTERS };
+    TouchEvent touchEvent;
+    touchEvent.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS);
     EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent));
 
     /**
@@ -416,7 +420,8 @@ HWTEST_F(TouchEventTestNg, TriggerTouchCallBack001, TestSize.Level1)
      * @tc.steps: step7. create TouchEvent object and call TriggerTouchCallBack.
      * @tc.expected: Execute function return value is true.
      */
-    TouchEvent touchEvent_2 { .tiltX = TILT_X_VALUE, .tiltY = TILT_Y_VALUE, .pointers = POINTERS_2 };
+    TouchEvent touchEvent_2;
+    touchEvent_2.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS_2);
     TouchEvent touchEvent_3;
     touchEvent_2.history.push_back(touchEvent_3);
     EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent_3));
@@ -425,7 +430,8 @@ HWTEST_F(TouchEventTestNg, TriggerTouchCallBack001, TestSize.Level1)
      * @tc.steps: step8. create TouchEvent object and call isFlushTouchEventsEnd_ assignment.
      * @tc.expected: Execute function return value is true.
      */
-    TouchEvent touchEvent_4 { .tiltX = TILT_X_VALUE, .tiltY = TILT_Y_VALUE, .pointers = POINTERS_2 };
+    TouchEvent touchEvent_4;
+    touchEvent_4.SetTiltX(TILT_X_VALUE).SetTiltY(TILT_Y_VALUE).SetPointers(POINTERS_2);
     touchEvent_2.history.push_back(touchEvent_4);
     touchEventActuator->isFlushTouchEventsEnd_ = true;
     EXPECT_TRUE(touchEventActuator->TriggerTouchCallBack(touchEvent_2));
diff --git a/test/unittest/core/pipeline/pipeline_context_test_ng.cpp b/test/unittest/core/pipeline/pipeline_context_test_ng.cpp
index 919cca6a2c89cb4327117b86b59bd02f0a84e293..b031c054a3b2b66dbfcd82d64a78bc2113ca9e81 100644
--- a/test/unittest/core/pipeline/pipeline_context_test_ng.cpp
+++ b/test/unittest/core/pipeline/pipeline_context_test_ng.cpp
@@ -3005,11 +3005,11 @@ HWTEST_F(PipelineContextTestNg, PipelineContextTestNg066, TestSize.Level1)
     auto timeStampThree = TimeStamp(std::chrono::nanoseconds(3000));
     auto timeStampFour = TimeStamp(std::chrono::nanoseconds(4000));
     std::vector<TouchEvent> history;
-    history.push_back(TouchEvent { .x = 100.0f, .y = 200.0f, .time = timeStampAce });
-    history.push_back(TouchEvent { .x = 150.0f, .y = 250.0f, .time = timeStampTwo });
+    history.push_back(TouchEvent {}.SetX(100.0f).SetY(200.0f).SetTime(timeStampAce));
+    history.push_back(TouchEvent {}.SetX(150.0f).SetY(250.0f).SetTime(timeStampTwo));
     std::vector<TouchEvent> current;
-    current.push_back(TouchEvent { .x = 200.0f, .y = 300.0f, .time = timeStampThree });
-    current.push_back(TouchEvent { .x = 250.0f, .y = 350.0f, .time = timeStampFour });
+    current.push_back(TouchEvent {}.SetX(200.0f).SetY(300.0f).SetTime(timeStampThree));
+    current.push_back(TouchEvent {}.SetX(250.0f).SetY(350.0f).SetTime(timeStampFour));
 
     auto resampledCoord = context_->GetResampleCoord(history, current, 2500, true);
 
@@ -3043,8 +3043,8 @@ HWTEST_F(PipelineContextTestNg, PipelineContextTestNg068, TestSize.Level1)
     auto timeStampAce = TimeStamp(std::chrono::nanoseconds(1000));
     auto timeStampTwo = TimeStamp(std::chrono::nanoseconds(2000));
     std::vector<TouchEvent> current;
-    current.push_back(TouchEvent { .x = 100.0f, .y = 200.0f, .time = timeStampAce });
-    current.push_back(TouchEvent { .x = 150.0f, .y = 250.0f, .time = timeStampTwo });
+    current.push_back(TouchEvent {}.SetX(100.0f).SetY(200.0f).SetTime(timeStampAce));
+    current.push_back(TouchEvent {}.SetX(150.0f).SetY(250.0f).SetTime(timeStampTwo));
     uint64_t nanoTimeStamp = 1500;
 
     TouchEvent latestPoint = context_->GetLatestPoint(current, nanoTimeStamp);
@@ -3065,11 +3065,11 @@ HWTEST_F(PipelineContextTestNg, PipelineContextTestNg069, TestSize.Level1)
     auto timeStampThree = TimeStamp(std::chrono::nanoseconds(3000));
     auto timeStampFour = TimeStamp(std::chrono::nanoseconds(4000));
     std::vector<TouchEvent> history;
-    history.push_back(TouchEvent { .x = 100.0f, .y = 200.0f, .time = timeStampAce });
-    history.push_back(TouchEvent { .x = 150.0f, .y = 250.0f, .time = timeStampTwo });
+    history.push_back(TouchEvent {}.SetX(100.0f).SetY(200.0f).SetTime(timeStampAce));
+    history.push_back(TouchEvent {}.SetX(150.0f).SetY(250.0f).SetTime(timeStampTwo));
     std::vector<TouchEvent> current;
-    current.push_back(TouchEvent { .x = 200.0f, .y = 300.0f, .time = timeStampThree });
-    current.push_back(TouchEvent { .x = 250.0f, .y = 350.0f, .time = timeStampFour });
+    current.push_back(TouchEvent {}.SetX(200.0f).SetY(300.0f).SetTime(timeStampThree));
+    current.push_back(TouchEvent {}.SetX(250.0f).SetY(350.0f).SetTime(timeStampFour));
     uint64_t nanoTimeStamp = 2500;
 
     TouchEvent resampledTouchEvent = context_->GetResampleTouchEvent(history, current, nanoTimeStamp);