diff --git a/frameworks/core/accessibility/accessibility_manager_ng.cpp b/frameworks/core/accessibility/accessibility_manager_ng.cpp
index c5166e6586c2d20eb0bc1b5a35f2e1a1ceca6efb..38eb2edfe1e4b75259c7249e53efdf1758f224f1 100644
--- a/frameworks/core/accessibility/accessibility_manager_ng.cpp
+++ b/frameworks/core/accessibility/accessibility_manager_ng.cpp
@@ -146,14 +146,28 @@ bool CheckPointIsInNode(const RefPtr<FrameNode>& root, const RefPtr<FrameNode>&
 {
     CHECK_NULL_RETURN(root, false);
     CHECK_NULL_RETURN(targetNode, false);
-    PointF pointNode(point);
-    auto covertResult = AccessibilityManagerNG::ConvertPointFromAncestorToNode(root, targetNode, point, pointNode);
-    CHECK_NE_RETURN(covertResult, true, false);
-    auto renderContext = targetNode->GetRenderContext();
-    CHECK_NULL_RETURN(renderContext, false);
-    auto rect = AccessibilityProperty::UpdateHoverTestRect(targetNode);
-    renderContext->GetPointWithRevert(pointNode);
-    return rect.IsInnerRegion(pointNode);
+    std::vector<RefPtr<NG::FrameNode>> path;
+    RefPtr<NG::FrameNode> curr = targetNode;
+    while (curr != nullptr && curr->GetId() != root->GetId()) {
+        path.push_back(curr);
+        curr = curr->GetAncestorNodeOfFrame(true);
+    }
+    // curr == null means can not find root
+    CHECK_NULL_RETURN(curr, false);
+    path.push_back(root);
+    PointF selfPoint = point;
+    bool hitSelf = false;
+    for (auto nodePtr = path.rbegin(); nodePtr != path.rend(); ++nodePtr) {
+        CHECK_NULL_CONTINUE(*nodePtr);
+        auto renderContext = (*nodePtr)->GetRenderContext();
+        CHECK_NULL_CONTINUE(renderContext);
+        renderContext->GetPointWithRevert(selfPoint);
+        auto rect = AccessibilityProperty::UpdateHoverTestRect(*nodePtr);
+        hitSelf = rect.IsInnerRegion(selfPoint);
+        auto orginRect = renderContext->GetPaintRectWithoutTransform();
+        selfPoint = selfPoint - orginRect.GetOffset();
+    }
+    return hitSelf;
 }
 
 bool IsInSentTransparentNode(const RefPtr<FrameNode>& node, AccessibilityHoverState& hoverState)
@@ -319,6 +333,7 @@ bool AccessibilityManagerNG::HandleAccessibilityHoverTransparentCallback(bool tr
 {
     CHECK_NE_RETURN(param.lastHoveringId, INVALID_NODE_ID, false);
     bool needSendExit = false;
+    bool result = false;
     for (auto& transparentWeak : hoverState.nodeTransparent) {
         auto transparentNode = transparentWeak.Upgrade();
         CHECK_NULL_CONTINUE(transparentNode);
@@ -328,7 +343,7 @@ bool AccessibilityManagerNG::HandleAccessibilityHoverTransparentCallback(bool tr
         CHECK_NULL_CONTINUE(callback);
         
         if (((param.currentHoveringId != INVALID_NODE_ID)
-            && (param.currentHoveringId != transparentNode->GetAccessibilityId()))
+            && (param.currentHoveringId != transparentNode->GetId()))
             || transformed) {
             needSendExit = true;
         } else {
@@ -345,12 +360,12 @@ bool AccessibilityManagerNG::HandleAccessibilityHoverTransparentCallback(bool tr
 
     if ((!transformed) && (param.currentHoveringId == INVALID_NODE_ID)
         && !IsHoverTransparentCallbackListEmpty(root)) {
-        return ExecuteChildNodeHoverTransparentCallback(root, param.point, event, hoverState);
+        result = ExecuteChildNodeHoverTransparentCallback(root, param.point, event, hoverState);
     }
     if (needSendExit) {
         hoverState.nodeTransparent.clear();
     }
-    return false;
+    return result;
 }
 
 HandleHoverRet AccessibilityManagerNG::HandleAccessibilityHoverEventInner(
@@ -368,12 +383,12 @@ HandleHoverRet AccessibilityManagerNG::HandleAccessibilityHoverEventInner(
         static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(time - hoverState.time).count());
 
     if (eventType == AccessibilityHoverEventType::CANCEL) {
-        hoverStateManager_.ResetHoverState(hoverState);
         HandleTransparentCallbackParam callbackParam = {
             .currentHoveringId = INVALID_NODE_ID,
             .lastHoveringId = INVALID_NODE_ID,
             .point = param.point};
         HandleAccessibilityHoverTransparentCallback(false, root, callbackParam, event, hoverState);
+        hoverStateManager_.ResetHoverState(hoverState);
         return HandleHoverRet::HOVER_HIT;
     }
 
diff --git a/test/unittest/core/accessibility/accessibility_manager_ng_test_ng.cpp b/test/unittest/core/accessibility/accessibility_manager_ng_test_ng.cpp
index cee6511208985c170c07bdbbebea0e7e093466fb..9742b910cafed5f0b9134fcbb2c442bb57126645 100644
--- a/test/unittest/core/accessibility/accessibility_manager_ng_test_ng.cpp
+++ b/test/unittest/core/accessibility/accessibility_manager_ng_test_ng.cpp
@@ -767,7 +767,7 @@ HWTEST_F(AccessibilityManagerNgTestNg, HandleAccessibilityHoverTransparentCallba
     // 2.has nodeTransparent, transformed false,currentHoveringId != INVALID_NODE_ID, lastHoveringId == INVALID_NODE_ID
     // 2.1  currentHoveringId != transparentNode->GetAccessibilityId()
     processFlag = false;
-    param = {frameNode1->GetAccessibilityId(), INVALID_NODE_ID, point};
+    param = {frameNode1->GetId(), INVALID_NODE_ID, point};
     ret = accessibilityManagerNg.HandleAccessibilityHoverTransparentCallback(
             transformed, frameNode1, param, touchEvent, hoverState);
     EXPECT_EQ(processFlag, true);
@@ -776,7 +776,7 @@ HWTEST_F(AccessibilityManagerNgTestNg, HandleAccessibilityHoverTransparentCallba
     hoverState.nodeTransparent.clear();
     hoverState.nodeTransparent.emplace_back(frameNode2);
     processFlag = false;
-    param = {frameNode2->GetAccessibilityId(), INVALID_NODE_ID, point};
+    param = {frameNode2->GetId(), INVALID_NODE_ID, point};
     ret = accessibilityManagerNg.HandleAccessibilityHoverTransparentCallback(
             transformed, frameNode1, param, touchEvent, hoverState);
     EXPECT_EQ(processFlag, false);
@@ -817,7 +817,7 @@ HWTEST_F(AccessibilityManagerNgTestNg, HandleAccessibilityHoverTransparentCallba
     // 3.transformed true , currentHoveringId != INVALID_NODE_ID, lastHoveringId == INVALID_NODE_ID
     // 3.1  currentHoveringId != transparentNode->GetAccessibilityId(), point in node
     processFlag = false;
-    param = {frameNode1->GetAccessibilityId(), INVALID_NODE_ID, point};
+    param = {frameNode1->GetId(), INVALID_NODE_ID, point};
     auto ret = accessibilityManagerNg.HandleAccessibilityHoverTransparentCallback(
         transformed, frameNode1, param, touchEvent, hoverState);
     EXPECT_EQ(processFlag, true);
@@ -826,7 +826,7 @@ HWTEST_F(AccessibilityManagerNgTestNg, HandleAccessibilityHoverTransparentCallba
     hoverState.nodeTransparent.clear();
     hoverState.nodeTransparent.emplace_back(frameNode2);
     processFlag = false;
-    param = {frameNode2->GetAccessibilityId(), INVALID_NODE_ID, point};
+    param = {frameNode2->GetId(), INVALID_NODE_ID, point};
     ret = accessibilityManagerNg.HandleAccessibilityHoverTransparentCallback(
         transformed, frameNode1, param, touchEvent, hoverState);
     EXPECT_EQ(processFlag, true);
@@ -834,12 +834,58 @@ HWTEST_F(AccessibilityManagerNgTestNg, HandleAccessibilityHoverTransparentCallba
     hoverState.nodeTransparent.clear();
     hoverState.nodeTransparent.emplace_back(frameNode2);
     processFlag = false;
-    param = {frameNode2->GetAccessibilityId(), INVALID_NODE_ID, point};
+    param = {frameNode2->GetId(), INVALID_NODE_ID, point};
     ret = accessibilityManagerNg.HandleAccessibilityHoverTransparentCallback(
         transformed, frameNode1, param, touchEvent, hoverState);
     EXPECT_EQ(processFlag, true);
 }
 
+/**
+ * @tc.name: HandleAccessibilityHoverTransparentCallback004
+ * @tc.desc:
+ * @tc.type: FUNC
+ */
+HWTEST_F(AccessibilityManagerNgTestNg, HandleAccessibilityHoverTransparentCallback005, TestSize.Level1)
+{
+    AccessibilityManagerNG accessibilityManagerNg{};
+    TouchEvent touchEvent;
+    AccessibilityHoverState hoverState;
+    PointF point{1, 1};
+    bool processFlag = false;
+    TouchType resultType = TouchType::UNKNOWN;
+    AccessibilityManagerNG::HandleTransparentCallbackParam param;
+    RefPtr<FrameNode> frameNode1;
+    RefPtr<FrameNode> frameNode2;
+    auto initRet = InitTwoFrameNode(frameNode1, frameNode2);
+    ASSERT_EQ(initRet, true);
+    RefPtr<FrameNode> frameNode3;
+    RefPtr<FrameNode> frameNode4;
+    initRet = InitTwoFrameNode(frameNode3, frameNode4);
+    ASSERT_EQ(initRet, true);
+
+    auto accessibilityProperty2 = frameNode2->GetAccessibilityProperty<NG::AccessibilityProperty>();
+    ASSERT_NE(accessibilityProperty2, nullptr);
+    accessibilityProperty2->SetAccessibilityTransparentCallback([&] (TouchEventInfo& eventInfo) {
+        processFlag = true;
+        auto touches = eventInfo.GetChangedTouches();
+        if (touches.size() > 0) {
+            auto changeTouch = touches.front();
+            resultType = changeTouch.GetTouchType();
+        }
+    });
+    hoverState.nodeTransparent.emplace_back(frameNode2);
+    touchEvent.type = TouchType::HOVER_MOVE;
+    bool transformed = false;
+    // 4. has nodeTransparent, transformed false,
+    // currentHoveringId == INVALID_NODE_ID, lastHoveringId == INVALID_NODE_ID
+    // point not in node， can not find root
+    PointF point2(-1, -1);
+    param = {INVALID_NODE_ID, INVALID_NODE_ID, point2};
+    accessibilityManagerNg.HandleAccessibilityHoverTransparentCallback(
+        transformed, frameNode3, param, touchEvent, hoverState);
+    EXPECT_EQ(processFlag, true);
+    EXPECT_EQ(resultType, TouchType::HOVER_EXIT);
+}
 /**
 * @tc.name: AccessibilityRectTest001
 * @tc.desc: AccessibilityRect