xref: /foundation/arkui/ace_engine/frameworks/core/components_ng/pattern/overlay/sheet_presentation_pattern.cpp

/*
 * Copyright (c) 2023 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 "core/components_ng/pattern/overlay/sheet_presentation_pattern.h"
#include "overlay_manager.h"

#include "base/geometry/dimension.h"
#include "base/log/dump_log.h"
#include "base/memory/referenced.h"
#include "base/utils/utils.h"
#include "base/window/foldable_window.h"
#include "core/animation/animation_pub.h"
#include "core/animation/curve.h"
#include "core/common/ace_engine.h"
#include "core/common/container.h"
#include "core/common/resource/resource_parse_utils.h"
#include "core/components/drag_bar/drag_bar_theme.h"
#include "core/components_ng/base/frame_node.h"
#include "core/components_ng/event/event_hub.h"
#include "core/components_ng/event/gesture_event_hub.h"
#include "core/components_ng/event/touch_event.h"
#include "core/components_ng/pattern/container_modal/enhance/container_modal_view_enhance.h"
#include "core/components_ng/pattern/image/image_pattern.h"
#include "core/components_ng/pattern/navrouter/navdestination_pattern.h"
#include "core/components_ng/pattern/overlay/overlay_manager.h"
#include "core/components_ng/pattern/overlay/sheet_drag_bar_pattern.h"
#include "core/components_ng/pattern/overlay/sheet_manager.h"
#include "core/components_ng/pattern/overlay/sheet_style.h"
#include "core/components_ng/pattern/overlay/sheet_view.h"
#include "core/components_ng/pattern/overlay/sheet_wrapper_pattern.h"
#include "core/components_ng/pattern/scroll/scroll_layout_algorithm.h"
#include "core/components_ng/pattern/scroll/scroll_layout_property.h"
#include "core/components_ng/pattern/scroll/scroll_pattern.h"
#include "core/components_ng/pattern/stage/page_pattern.h"
#include "core/components_ng/pattern/text/text_layout_property.h"
#include "core/components_ng/pattern/text_field/text_field_manager.h"
#include "core/components_ng/property/accessibility_property_helper.h"
#ifdef WINDOW_SCENE_SUPPORTED
#include "core/components_ng/pattern/window_scene/scene/system_window_scene.h"
#endif
#include "core/components_ng/property/property.h"
#ifdef ENABLE_ROSEN_BACKEND
#include "core/components_ng/render/adapter/rosen_render_context.h"
#endif
#include "core/components/theme/shadow_theme.h"
#include "core/components_v2/inspector/inspector_constants.h"
#include "core/event/touch_event.h"
#include "core/pipeline_ng/pipeline_context.h"

namespace OHOS::Ace::NG {
namespace {
constexpr int32_t SHEET_DETENTS_ZERO = 0;
constexpr int32_t SHEET_DETENTS_ONE = 1;
constexpr int32_t SHEET_DETENTS_TWO = 2;
constexpr int32_t SHEET_DETENTS_THREE = 3;
constexpr float SHEET_VISIABLE_ALPHA = 1.0f;
constexpr float SHEET_INVISIABLE_ALPHA = 0.0f;
constexpr int32_t SHEET_ENTRY_ANIMATION_DURATION = 250;
constexpr int32_t SHEET_EXIT_ANIMATION_DURATION = 100;
constexpr float SHEET_INVISIABLE_OFFSET = 8.0f;
constexpr float BOTTOM_STYLE_RATIO = 1.25f;
constexpr int32_t SHEET_HALF_HEIGHT = 2;
constexpr Dimension ARROW_VERTICAL_P1_OFFSET_X = 8.0_vp;
constexpr Dimension ARROW_VERTICAL_P2_OFFSET_X = 1.5_vp;
constexpr Dimension ARROW_VERTICAL_P2_OFFSET_Y = 7.32_vp;
constexpr Dimension ARROW_VERTICAL_P4_OFFSET_X = 1.5_vp;
constexpr Dimension ARROW_VERTICAL_P4_OFFSET_Y = 7.32_vp;
constexpr Dimension ARROW_VERTICAL_P5_OFFSET_X = 8.0_vp;
constexpr Dimension ARROW_CORNER_P2_OFFSET_X = 12.8_vp;
constexpr Dimension ARROW_CORNER_P2_OFFSET_Y = 7.6_vp;
constexpr Dimension ARROW_CORNER_P4_OFFSET_Y = 6.0_vp;
constexpr Dimension ARROW_RADIUS = 2.0_vp;
constexpr Dimension SUBWINDOW_SHEET_TRANSLATION = 80.0_vp;
} // namespace

// MarkModifyDone must be called after UpdateSheetObject. InitSheetMode depends on SheetObject.
void SheetPresentationPattern::OnModifyDone()
{
    Pattern::CheckLocalized();
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto renderContext = host->GetRenderContext();
    if (renderContext) {
        auto pipeline = host->GetContext();
        CHECK_NULL_VOID(pipeline);
        auto sheetTheme = pipeline->GetTheme<SheetTheme>();
        CHECK_NULL_VOID(sheetTheme);
        auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
        CHECK_NULL_VOID(layoutProperty);
        auto sheetStyle = layoutProperty->GetSheetStyleValue();
        BlurStyle blurStyle = static_cast<BlurStyle>(sheetTheme->GetSheetBackgroundBlurStyle());
        if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)
            && blurStyle != BlurStyle::NO_MATERIAL) {
            BlurStyleOption options;
            options.blurStyle = blurStyle;
            renderContext->UpdateBackgroundColor(Color::TRANSPARENT);
            renderContext->UpdateBackBlurStyle(sheetStyle.backgroundBlurStyle.value_or(options));
        } else {
            renderContext->UpdateBackgroundColor(
                sheetStyle.backgroundColor.value_or(sheetTheme->GetSheetBackgoundColor()));
        }
    }
    InitPanEvent();
    InitPageHeight();
    InitSheetMode();
    sheetObject_->InitScrollProps();
    InitFoldCreaseRegion();
}

// check device is phone, fold status, and device in landscape
bool SheetPresentationPattern::IsPhoneInLandScape()
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, false);
    auto pipelineContext = host->GetContext();
    CHECK_NULL_RETURN(pipelineContext, false);
    auto containerId = Container::CurrentId();
    auto foldWindow = FoldableWindow::CreateFoldableWindow(containerId);
    CHECK_NULL_RETURN(foldWindow, false);
    auto sheetTheme = pipelineContext->GetTheme<SheetTheme>();
    CHECK_NULL_RETURN(sheetTheme, false);
    auto sheetThemeType = sheetTheme->GetSheetType();
    if (sheetThemeType == "auto" && !foldWindow->IsFoldExpand() &&
        SystemProperties::GetDeviceOrientation() == DeviceOrientation::LANDSCAPE) {
        return true;
    }
    return false;
}

float SheetPresentationPattern::GetSheetTopSafeArea()
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, 0.0f);
    auto pipelineContext = host->GetContext();
    CHECK_NULL_RETURN(pipelineContext, 0.0f);
    auto safeAreaInsets = pipelineContext->GetSafeAreaWithoutProcess();
    auto sheetTopSafeArea = safeAreaInsets.top_.Length();
    auto windowManager = pipelineContext->GetWindowManager();
    auto sheetType = sheetType_;
    auto windowGlobalRect = pipelineContext->GetDisplayWindowRectInfo();
    double deviceHeight = static_cast<double>(SystemProperties::GetDeviceHeight());

    // full screen subwindow sheet is also WINDOW_MODE_FLOATING, can not enter
    if (windowManager && windowManager->GetWindowMode() == WindowMode::WINDOW_MODE_FLOATING &&
        !NearEqual(windowGlobalRect.Height(), deviceHeight)) {
        sheetTopSafeArea = SHEET_BLANK_FLOATING_STATUS_BAR.ConvertToPx();
    } else if ((sheetType == SheetType::SHEET_BOTTOMLANDSPACE || sheetType == SheetType::SHEET_BOTTOM ||
                sheetType == SheetType::SHEET_BOTTOM_OFFSET) &&
               Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_EIGHTEEN)) {
        sheetTopSafeArea = GetBottomSafeArea();
    } else if (sheetType == SheetType::SHEET_BOTTOMLANDSPACE &&
               AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) {
        sheetTopSafeArea = 0.0f;
    }
    // before API14，ignore safeArea height when in landscape
    if (!Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_EIGHTEEN)) {
        auto layoutProperty = DynamicCast<SheetPresentationProperty>(host->GetLayoutProperty());
        CHECK_NULL_RETURN(layoutProperty, 0.0f);
        auto sheetStyle = layoutProperty->GetSheetStyleValue();
        if (sheetStyle.sheetType.has_value() && sheetStyle.sheetType.value() == SheetType::SHEET_BOTTOM &&
            IsPhoneInLandScape()) {
            sheetTopSafeArea = 0.0f;
        }
    }
    // if window titleBar hidden, avoid button area.
    NG::RectF floatButtons;
    if (GetWindowButtonRect(floatButtons)) {
        sheetTopSafeArea = floatButtons.Height();
    }
    return sheetTopSafeArea;
}

void SheetPresentationPattern::InitPageHeight()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipelineContext = host->GetContext();
    CHECK_NULL_VOID(pipelineContext);
    auto safeAreaInsets = pipelineContext->GetSafeAreaWithoutProcess();
    auto currentTopSafeArea = sheetTopSafeArea_;
    TAG_LOGD(AceLogTag::ACE_SHEET, "statusBarHeight of sheet by GetSafeAreaWithoutProcess : %{public}u",
        safeAreaInsets.top_.Length());
    sheetTopSafeArea_ =
        sheetType_ != SheetType::SHEET_BOTTOMLANDSPACE ? safeAreaInsets.top_.Length() : .0f;
    auto showInPage =
        GetLayoutProperty<SheetPresentationProperty>()->GetSheetStyleValue(SheetStyle()).showInPage.value_or(false);
    auto overlay = GetOverlayManager();
    if (overlay && overlay->IsRootExpansive() && showInPage) {
        sheetTopSafeArea_ = .0f;
    }
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    if (sheetStyle.sheetType.has_value() && sheetStyle.sheetType.value() == SheetType::SHEET_BOTTOM &&
        IsPhoneInLandScape()) {
        sheetTopSafeArea_ = 0.0f;
    }
    sheetTopSafeArea_ = GetSheetTopSafeArea();
    TAG_LOGD(AceLogTag::ACE_SHEET, "sheetTopSafeArea of sheet is : %{public}f", sheetTopSafeArea_);
    if (!NearEqual(currentTopSafeArea, sheetTopSafeArea_)) {
        topSafeAreaChanged_ = true;
    }
}

bool SheetPresentationPattern::OnDirtyLayoutWrapperSwap(
    const RefPtr<LayoutWrapper>& dirty, const DirtySwapConfig& config)
{
    if (config.skipMeasure && config.skipLayout) {
        return false;
    }
    auto layoutAlgorithmWrapper = DynamicCast<LayoutAlgorithmWrapper>(dirty->GetLayoutAlgorithm());
    CHECK_NULL_RETURN(layoutAlgorithmWrapper, false);
    InitPageHeight();
    sheetObject_->DirtyLayoutProcess(layoutAlgorithmWrapper);
    UpdateFontScaleStatus();
    UpdateCloseIconStatus();
    UpdateTitlePadding();
    UpdateSheetTitle();
    ClipSheetNode();

    sheetObject_->AvoidKeyboardInDirtyLayoutProcess();

    if (sheetType_ == SheetType::SHEET_POPUP) {
        MarkSheetPageNeedRender();
    }
    return true;
}

void SheetPresentationPattern::SetBottomStyleHotAreaInSubwindow()
{
    if (IsShowInSubWindow() && IsSheetBottom()) {
        auto host = GetHost();
        auto paintRect = host->GetPaintRectWithTransform();
        std::vector<Rect> rects;
        auto rect =
            Rect(paintRect.GetOffset().GetX(), paintRect.GetOffset().GetY(), paintRect.Width(), paintRect.Height());
        rects.emplace_back(rect);
        SubwindowManager::GetInstance()->SetHotAreas(rects, SubwindowType::TYPE_SHEET, host->GetId(), GetSubWindowId());
    }
}

void SheetPresentationPattern::CheckBuilderChange()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto builderNode = GetFirstFrameNodeOfBuilder();
    CHECK_NULL_VOID(builderNode);
    auto eventHub = builderNode->GetOrCreateEventHub<EventHub>();
    CHECK_NULL_VOID(eventHub);
    OnAreaChangedFunc onBuilderAreaChangedFunc = [sheetNodeWk = WeakPtr<FrameNode>(host)](const RectF& /* oldRect */,
                                                     const OffsetF& /* oldOrigin */, const RectF& /* rect */,
                                                     const OffsetF& /* origin */) {
        auto sheetNode = sheetNodeWk.Upgrade();
        CHECK_NULL_VOID(sheetNode);
        auto sheetPattern = sheetNode->GetPattern<SheetPresentationPattern>();
        CHECK_NULL_VOID(sheetPattern);
        auto layoutProperty = sheetNode->GetLayoutProperty<SheetPresentationProperty>();
        CHECK_NULL_VOID(layoutProperty);
        auto sheetStyle = layoutProperty->GetSheetStyleValue();
        if (sheetStyle.sheetHeight.sheetMode == SheetMode::AUTO) {
            auto sheetWrapper = sheetNode->GetParent();
            CHECK_NULL_VOID(sheetWrapper);
            sheetWrapper->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
        }
    };
    eventHub->AddInnerOnAreaChangedCallback(builderNode->GetId(), std::move(onBuilderAreaChangedFunc));
}

void SheetPresentationPattern::AvoidAiBar()
{
    CHECK_NULL_VOID(Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_ELEVEN));
    if (!IsTypeNeedAvoidAiBar()) {
        TAG_LOGD(AceLogTag::ACE_SHEET, "Sheet need not avoid AiBar.");
        return;
    }
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto scrollNode = GetSheetScrollNode();
    CHECK_NULL_VOID(scrollNode);
    auto scrollPattern = scrollNode->GetPattern<ScrollPattern>();
    CHECK_NULL_VOID(scrollPattern);
    if (NonPositive(scrollPattern->GetScrollableDistance()) || isScrolling_) {
        return;
    }
    auto pipeline = PipelineContext::GetCurrentContext();
    CHECK_NULL_VOID(pipeline);
    auto inset = pipeline->GetSafeArea();
    auto layoutProperty = scrollNode->GetLayoutProperty<ScrollLayoutProperty>();
    layoutProperty->UpdateScrollContentEndOffset(inset.bottom_.Length());
    TAG_LOGD(AceLogTag::ACE_SHEET, "AvoidAiBar function execution completed");
    host->MarkDirtyNode(PROPERTY_UPDATE_LAYOUT);
}

bool SheetPresentationPattern::IsScrollable() const
{
    auto scrollNode = GetSheetScrollNode();
    CHECK_NULL_RETURN(scrollNode, false);
    auto scrollPattern = scrollNode->GetPattern<ScrollPattern>();
    CHECK_NULL_RETURN(scrollPattern, false);
    return Positive(scrollPattern->GetScrollableDistance());
}

void SheetPresentationPattern::OnAttachToFrameNode()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    InitFoldState();
    host->GetLayoutProperty()->UpdateMeasureType(MeasureType::MATCH_PARENT);
    host->GetLayoutProperty()->UpdateAlignment(Alignment::TOP_LEFT);
    auto targetNode = FrameNode::GetFrameNode(targetTag_, targetId_);
    CHECK_NULL_VOID(targetNode);
    auto targetNodeContext = targetNode->GetContext();
    CHECK_NULL_VOID(targetNodeContext);
    auto sheetTheme = targetNodeContext->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);
    sheetThemeType_ = sheetTheme->GetSheetType();
    scale_ = targetNodeContext->GetFontScale();
    if (IsShowInSubWindow()) {
        targetNodeContext->AddWindowSizeChangeCallback(host->GetId());
        targetNodeContext->AddOnAreaChangeNode(targetNode->GetId());
    } else {
        auto currentPipeline = host->GetContext();
        CHECK_NULL_VOID(currentPipeline);
        currentPipeline->AddWindowSizeChangeCallback(host->GetId());
        currentPipeline->AddOnAreaChangeNode(targetNode->GetId());
    }
    OnAreaChangedFunc onAreaChangedFunc = [sheetNodeWk = WeakPtr<FrameNode>(host)](const RectF& /* oldRect */,
                                              const OffsetF& /* oldOrigin */, const RectF& /* rect */,
                                              const OffsetF& /* origin */) {
        auto sheetNode = sheetNodeWk.Upgrade();
        CHECK_NULL_VOID(sheetNode);
        auto sheetPattern = sheetNode->GetPattern<SheetPresentationPattern>();
        CHECK_NULL_VOID(sheetPattern);
        if (sheetPattern->GetSheetTypeNoProcess() == SheetType::SHEET_POPUP) {
            auto sheetWrapper = sheetNode->GetParent();
            CHECK_NULL_VOID(sheetWrapper);
            sheetWrapper->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
        }
    };
    auto eventHub = targetNode->GetOrCreateEventHub<EventHub>();
    CHECK_NULL_VOID(eventHub);
    eventHub->AddInnerOnAreaChangedCallback(host->GetId(), std::move(onAreaChangedFunc));

    auto gesture = host->GetOrCreateGestureEventHub();
    CHECK_NULL_VOID(gesture);
    auto touchTask = [](TouchEventInfo& info) {
        info.SetStopPropagation(true);
        TAG_LOGD(AceLogTag::ACE_SHEET, "The sheet hits the touch event.");
    };
    gesture->AddTouchEvent(MakeRefPtr<TouchEventImpl>(std::move(touchTask)));
    RegisterHoverModeChangeCallback();
    RegisterAvoidInfoChangeListener(host);
}

void SheetPresentationPattern::OnDetachFromFrameNode(FrameNode* sheetNode)
{
    CHECK_NULL_VOID(sheetNode);
    auto pipeline = sheetNode->GetContext();
    CHECK_NULL_VOID(pipeline);
    pipeline->RemoveWindowSizeChangeCallback(sheetNode->GetId());
    if (HasHoverModeChangedCallbackId()) {
        pipeline->UnRegisterHalfFoldHoverChangedCallback(hoverModeChangedCallbackId_.value_or(-1));
    }
    UnRegisterAvoidInfoChangeListener(sheetNode);
    SendMessagesAfterTransitionOut(sheetNode);

    auto targetNode = FrameNode::GetFrameNode(targetTag_, targetId_);
    CHECK_NULL_VOID(targetNode);
    auto eventHub = targetNode->GetOrCreateEventHub<EventHub>();
    CHECK_NULL_VOID(eventHub);
    eventHub->RemoveInnerOnAreaChangedCallback(sheetNode->GetId());
}

void SheetPresentationPattern::RegisterHoverModeChangeCallback()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto context = host->GetContext();
    CHECK_NULL_VOID(context);
    auto hoverModeChangeCallback = [weak = WeakClaim(this)](bool isHalfFoldHover) {
        auto pattern = weak.Upgrade();
        CHECK_NULL_VOID(pattern);
        auto sheetType = pattern->GetSheetTypeNoProcess();
        if (sheetType != SheetType::SHEET_CENTER) {
            return;
        }
        auto host = pattern->GetHost();
        CHECK_NULL_VOID(host);
        auto context = host->GetContext();
        CHECK_NULL_VOID(context);
        AnimationOption optionPosition;
        auto motion = AceType::MakeRefPtr<ResponsiveSpringMotion>(0.35f, 1.0f, 0.0f);
        optionPosition.SetCurve(motion);
        context->FlushUITasks();
        context->Animate(
            optionPosition, motion,
            [host, context]() {
                host->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
                context->FlushUITasks();
            },
            [weak]() {
                auto pattern = weak.Upgrade();
                CHECK_NULL_VOID(pattern);
                pattern->FireHoverModeChangeCallback();
            });
    };
    auto hoverModeCallId = context->RegisterHalfFoldHoverChangedCallback(std::move(hoverModeChangeCallback));
    UpdateHoverModeChangedCallbackId(hoverModeCallId);
}

void SheetPresentationPattern::SetSheetBorderWidth(bool isPartialUpdate)
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);
    auto layoutProperty = host->GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    auto renderContext = host->GetRenderContext();
    CHECK_NULL_VOID(renderContext);
    renderContext->SetClipToBounds(true);
    if (sheetStyle.borderWidth.has_value()) {
        auto borderWidth = sheetStyle.borderWidth.value();
        borderWidth = GetSheetObject()->PostProcessBorderWidth(borderWidth);
        layoutProperty->UpdateBorderWidth(borderWidth);
        renderContext->UpdateBorderWidth(borderWidth);
    } else if (renderContext->GetBorderWidth().has_value() && !isPartialUpdate) {
        BorderWidthProperty borderWidth;
        borderWidth.SetBorderWidth(0.0_vp);
        layoutProperty->UpdateBorderWidth(borderWidth);
        renderContext->UpdateBorderWidth(borderWidth);
    }

    SetSheetOuterBorderWidth(sheetTheme, sheetStyle);
}

// initial drag gesture event
void SheetPresentationPattern::InitPanEvent()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto focusHub = host->GetFocusHub();
    CHECK_NULL_VOID(focusHub);
    InitOnkeyEvent(focusHub);
    if (IsShowInSubWindowTwoInOne()) {
        return;
    }

    auto hub = host->GetOrCreateEventHub<EventHub>();
    CHECK_NULL_VOID(hub);
    auto gestureHub = hub->GetOrCreateGestureEventHub();
    CHECK_NULL_VOID(gestureHub);
    if (panEvent_) {
        return;
    }

    auto actionStartTask = [weak = WeakClaim(this)](const GestureEvent& event) {
        auto pattern = weak.Upgrade();
        if (pattern) {
            pattern->HandleDragStart();
        }
    };

    auto actionUpdateTask = [weak = WeakClaim(this)](const GestureEvent& info) {
        auto pattern = weak.Upgrade();
        if (pattern) {
            pattern->HandleDragUpdate(info);
        }
    };

    auto actionEndTask = [weak = WeakClaim(this)](const GestureEvent& info) {
        auto pattern = weak.Upgrade();
        if (pattern) {
            pattern->HandleDragEnd(info.GetMainVelocity());
        }
    };
    auto actionCancelTask = [weak = WeakClaim(this)]() {
        auto pattern = weak.Upgrade();
        if (pattern) {
            pattern->HandleDragEnd({});
        }
    };
    PanDirection panDirection;
    panDirection.type = sheetObject_->GetPanDirection();
    panEvent_ = MakeRefPtr<PanEvent>(
        std::move(actionStartTask), std::move(actionUpdateTask), std::move(actionEndTask), std::move(actionCancelTask));
    PanDistanceMap distanceMap = { { SourceTool::UNKNOWN, DEFAULT_PAN_DISTANCE.ConvertToPx() },
        { SourceTool::PEN, DEFAULT_PEN_PAN_DISTANCE.ConvertToPx() } };
    gestureHub->AddPanEvent(panEvent_, panDirection, 1, distanceMap);
}

void SheetPresentationPattern::RemovePanEvent()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto hub = host->GetEventHub<EventHub>();
    CHECK_NULL_VOID(hub);
    auto gestureHub = hub->GetOrCreateGestureEventHub();
    CHECK_NULL_VOID(gestureHub);
    gestureHub->RemovePanEvent(panEvent_);
    panEvent_.Reset();
}

void SheetPresentationPattern::InitOnkeyEvent(const RefPtr<FocusHub>& focusHub)
{
    CHECK_NULL_VOID(focusHub);
    focusHub->SetOnFocusInternal([weak = WeakClaim(this)](FocusReason reason) {
        auto pattern = weak.Upgrade();
        if (pattern) {
            pattern->HandleFocusEvent();
        }
    });

    focusHub->SetOnBlurInternal([weak = WeakClaim(this)]() {
        auto pattern = weak.Upgrade();
        if (pattern) {
            pattern->HandleBlurEvent();
        }
    });
}

void SheetPresentationPattern::SetShadowStyle(bool isFocused)
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto layoutProperty = host->GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    if (sheetStyle.shadow.has_value()) {
        return;
    }
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    auto renderContext = host->GetRenderContext();
    CHECK_NULL_VOID(renderContext);
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);
    auto style = static_cast<ShadowStyle>(sheetTheme->GetSheetShadowConfig());
    if (!isFocused) {
        style = static_cast<ShadowStyle>(sheetTheme->GetSheetShadowConfigS());
    }
    auto shadow = GetShadowFromTheme(style);
    renderContext->UpdateBackShadow(shadow);
}

void SheetPresentationPattern::HandleFocusEvent()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto sheetId = host->GetId();
    TAG_LOGI(AceLogTag::ACE_SHEET, "Sheet get focus, and id is : %{public}d", sheetId);
    SheetManager::GetInstance().SetFocusSheetId(sheetId);
    SetShadowStyle(true);
}

void SheetPresentationPattern::HandleBlurEvent()
{
    TAG_LOGI(AceLogTag::ACE_SHEET, "Sheet lost focus");
    SheetManager::GetInstance().SetFocusSheetId(std::nullopt);
    SetShadowStyle(false);
}

void SheetPresentationPattern::HandleDragStart()
{
    sheetObject_->HandleDragStart();
}

void SheetPresentationPattern::HandleDragUpdate(const GestureEvent& info)
{
    sheetObject_->HandleDragUpdate(info);
}

void SheetPresentationPattern::HandleDragEnd(float dragVelocity)
{
    sheetObject_->HandleDragEnd(dragVelocity);
}

void SheetPresentationPattern::SendTextUpdateEvent()
{
    auto sheetNode = GetHost();
    CHECK_NULL_VOID(sheetNode);
    // Use TEXT_CHANGE to send events.
    TAG_LOGI(AceLogTag::ACE_SHEET, "bindsheet sent TEXT_CHANGE event, when follow up.");
    sheetNode->OnAccessibilityEvent(AccessibilityEventType::TEXT_CHANGE, "", "");
}

void SheetPresentationPattern::SendSelectedEvent()
{
    auto sheetNode = GetHost();
    CHECK_NULL_VOID(sheetNode);
    // Use SELECTED to send events.
    TAG_LOGI(AceLogTag::ACE_SHEET, "bindsheet sent SELECTED event, when get out of your hands.");
    sheetNode->OnAccessibilityEvent(AccessibilityEventType::SELECTED, "", "");
}

void SheetPresentationPattern::RegisterElementInfoCallBack()
{
    auto sheetNode = GetHost();
    CHECK_NULL_VOID(sheetNode);
    auto accessibilityProperty = sheetNode->GetAccessibilityProperty<NG::AccessibilityProperty>();
    CHECK_NULL_VOID(accessibilityProperty);
    auto callBack = [sheetDetents = std::to_string(static_cast<int32_t>(sheetDetents_))]
        (Accessibility::ExtraElementInfo& extraElementInfo) {
        extraElementInfo.SetExtraElementInfo("BindSheet", sheetDetents);
    };
    accessibilityProperty->SetRelatedElementInfoCallback(callBack);
}

bool SheetPresentationPattern::UpdateAccessibilityDetents(float height)
{
    auto sheetDetentsSize = sheetDetentHeight_.size();
    bool invalid = sheetDetentsSize < 2 || !IsSheetBottomStyle();
    if (invalid) {
        return false;
    }
    for (uint32_t i = 0; i < sheetDetentsSize; i++) {
        if (NearEqual(height, sheetDetentHeight_[i])) {
            // size is 2, corresponds to high and low.
            // size is 3, corresponds to high、medium and low.
            // The lower of the two detents, corresponds to "LOW".
            bool lowOfTwoDetents = sheetDetentsSize == 2 && i == 0;
            sheetDetents_ = lowOfTwoDetents
                ? static_cast<SheetAccessibilityDetents>(sheetDetentsSize - i)
                : static_cast<SheetAccessibilityDetents>(sheetDetentsSize -1 - i);
            TAG_LOGI(AceLogTag::ACE_SHEET, "bindsheet detents enum value: %{public}d", sheetDetents_);
            RegisterElementInfoCallBack();
            return true;
        }
    }
    return false;
}

uint32_t SheetPresentationPattern::GetCurrentBroadcastDetentsIndex()
{
    bool invalid = sheetDetentHeight_.size() < 2 || !IsSheetBottomStyle();
    if (invalid) {
        return broadcastPreDetentsIndex_;
    }
    // get currrent detents index.
    auto it = std::find(sheetDetentHeight_.begin(), sheetDetentHeight_.end(), height_);
    if (it != sheetDetentHeight_.end()) {
        broadcastPreDetentsIndex_ = static_cast<uint32_t>(std::distance(sheetDetentHeight_.begin(), it));
    }
    return broadcastPreDetentsIndex_;
}

void SheetPresentationPattern::HandleFollowAccessibilityEvent(float currHeight)
{
    auto sheetDetentsSize = sheetDetentHeight_.size();
    bool invalid = sheetDetentsSize < 2 || !IsSheetBottomStyle();
    if (invalid) {
        return;
    }
    if (currHeight < sheetDetentHeight_[0] || currHeight > sheetDetentHeight_[sheetDetentsSize - 1]) {
        return;
    }
    float upHeight = 0.0f;
    float downHeight = 0.0f;
    float finalHeight = 0.0f;

    // record current position info.
    uint32_t detentsLowerPos = 0;
    uint32_t detentsUpperPos = 0;
    uint32_t broadcastCurrDetentsIndex = 0;
    ComputeDetentsPos(currHeight, upHeight, downHeight, detentsLowerPos, detentsUpperPos);

    if (GreatNotEqual(std::abs(currHeight - upHeight), std::abs(currHeight - downHeight))) {
        finalHeight = downHeight;
        broadcastCurrDetentsIndex = detentsLowerPos;
    } else if (LessNotEqual(std::abs(currHeight - upHeight), std::abs(currHeight - downHeight))) {
        finalHeight = upHeight;
        broadcastCurrDetentsIndex = detentsUpperPos;
    }

    // Broadcast once when enter other effect area.
    if (broadcastCurrDetentsIndex != broadcastPreDetentsIndex_) {
        UpdateAccessibilityDetents(finalHeight);
        SendTextUpdateEvent();
        broadcastPreDetentsIndex_ = broadcastCurrDetentsIndex;
    }
}

void SheetPresentationPattern::HandleDragEndAccessibilityEvent()
{
    if (UpdateAccessibilityDetents(GetSheetHeightBeforeDragUpdate())) {
        SendSelectedEvent();
    }
}

void SheetPresentationPattern::ComputeDetentsPos(
    float currentSheetHeight, float& upHeight, float& downHeight, uint32_t& detentsLowerPos, uint32_t& detentsUpperPos)
{
    // when drag the sheet page, find the lower and upper index range
    auto lowerIter = std::lower_bound(sheetDetentHeight_.begin(), sheetDetentHeight_.end(), currentSheetHeight);
    auto upperIter = std::upper_bound(sheetDetentHeight_.begin(), sheetDetentHeight_.end(), currentSheetHeight);
    auto sheetDetentsSize = sheetDetentHeight_.size();
    if (lowerIter == sheetDetentHeight_.end() || upperIter == sheetDetentHeight_.end()) {
        // when drag over the highest sheet page
        upHeight = sheetDetentHeight_[sheetDetentsSize - 1];
        downHeight = sheetDetentHeight_[sheetDetentsSize - 1];
        detentsLowerPos = sheetDetentsSize - 1;
        detentsUpperPos = sheetDetentsSize - 1;
    } else {
        auto lowerPosition = static_cast<uint32_t>(std::distance(sheetDetentHeight_.begin(), lowerIter));
        auto upperPosition = static_cast<uint32_t>(std::distance(sheetDetentHeight_.begin(), upperIter));
        if (lowerPosition == 0) {
            upHeight = sheetDetentHeight_[lowerPosition];
            downHeight = 0;
        } else {
            // the first largest height greater than the currentsheet height
            upHeight = sheetDetentHeight_[upperPosition];

            // the largest height lower than the currentsheet height
            downHeight = sheetDetentHeight_[lowerPosition - 1];
            detentsLowerPos = lowerPosition - 1;
            detentsUpperPos = upperPosition;
        }
    }
}

void SheetPresentationPattern::ChangeSheetPage(float height)
{
    if (IsAvoidingKeyboard() && keyboardAvoidMode_ == SheetKeyboardAvoidMode::TRANSLATE_AND_SCROLL) {
        return;
    }
    ChangeScrollHeight(height);
}

void SheetPresentationPattern::OnCoordScrollStart()
{
    if (animation_ && isAnimationProcess_) {
        AnimationUtils::StopAnimation(animation_);
        isAnimationBreak_ = true;
    }
    currentOffset_ = 0.0f;
    GetCurrentBroadcastDetentsIndex();
}

bool SheetPresentationPattern::OnCoordScrollUpdate(float scrollOffset)
{
    if (!GetShowState() || !IsScrollable()) {
        return false;
    }

    auto sheetType = GetSheetType();
    auto sheetDetentsSize = sheetDetentHeight_.size();
    if ((sheetType == SheetType::SHEET_POPUP) || (sheetDetentsSize == 0)) {
        return false;
    }
    auto height = GetSheetHeightBeforeDragUpdate();
    if ((NearZero(currentOffset_)) && (LessNotEqual(scrollOffset, 0.0f)) &&
        (GreatOrEqual(height, GetMaxSheetHeightBeforeDragUpdate()))) {
        return false;
    }
    auto host = GetHost();
    CHECK_NULL_RETURN(host, false);
    currentOffset_ = currentOffset_ + scrollOffset;
    auto pageHeight = GetPageHeightWithoutOffset();
    auto offset = pageHeight - height + currentOffset_;
    if (LessOrEqual(offset, pageHeight - sheetMaxHeight_)) {
        offset = pageHeight - sheetMaxHeight_;
        currentOffset_ = height - sheetMaxHeight_;
    }
    HandleFollowAccessibilityEvent(height - currentOffset_);
    auto renderContext = host->GetRenderContext();
    renderContext->UpdateTransformTranslate({ 0.0f, offset, 0.0f });
    return true;
}

void SheetPresentationPattern::OnCoordScrollEnd(float dragVelocity)
{
    HandleDragEnd(dragVelocity);
}

void SheetPresentationPattern::InitialLayoutProps()
{
    CheckSheetHeightChange();
    InitSheetDetents();
}

bool SheetPresentationPattern::GetWindowButtonRect(NG::RectF& floatButtons)
{
    if (!AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_EIGHTEEN)) {
        return false;
    }
    auto host = GetHost();
    CHECK_NULL_RETURN(host, false);
    auto pipelineContext = host->GetContext();
    CHECK_NULL_RETURN(pipelineContext, false);
    auto avoidInfoMgr = pipelineContext->GetAvoidInfoManager();
    CHECK_NULL_RETURN(avoidInfoMgr, false);
    NG::RectF floatContainerModal;
    if (avoidInfoMgr->NeedAvoidContainerModal() &&
        avoidInfoMgr->GetContainerModalButtonsRect(floatContainerModal, floatButtons)) {
        TAG_LOGD(AceLogTag::ACE_SHEET, "When hidden, floatButtons rect is %{public}s", floatButtons.ToString().c_str());
        return true;
    };
    TAG_LOGD(AceLogTag::ACE_SHEET, "Window title builder shown");
    return false;
}

bool SheetPresentationPattern::GetWindowButtonRectForAllAPI(NG::RectF& floatButtons)
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, false);
    auto pipelineContext = host->GetContext();
    CHECK_NULL_RETURN(pipelineContext, false);
    auto avoidInfoMgr = pipelineContext->GetAvoidInfoManager();
    CHECK_NULL_RETURN(avoidInfoMgr, false);
    NG::RectF floatContainerModal;
    if (avoidInfoMgr->NeedAvoidContainerModal() &&
        avoidInfoMgr->GetContainerModalButtonsRect(floatContainerModal, floatButtons)) {
        TAG_LOGD(AceLogTag::ACE_SHEET, "When hidden, floatButtons rect is %{public}s", floatButtons.ToString().c_str());
        return true;
    };
    TAG_LOGD(AceLogTag::ACE_SHEET, "Window title builder shown");
    return false;
}

float SheetPresentationPattern::InitialSingleGearHeight(NG::SheetStyle& sheetStyle)
{
    auto largeHeight = sheetMaxHeight_ - SHEET_BLANK_MINI_HEIGHT.ConvertToPx();
    float sheetHeight = largeHeight;
    auto sheetNode = GetHost();
    CHECK_NULL_RETURN(sheetNode, sheetHeight);
    if (sheetStyle.sheetHeight.sheetMode.has_value()) {
        auto pipelineContext = sheetNode->GetContext();
        CHECK_NULL_RETURN(pipelineContext, sheetHeight);
        auto sheetTheme = pipelineContext->GetTheme<SheetTheme>();
        CHECK_NULL_RETURN(sheetTheme, sheetHeight);
        if (sheetStyle.sheetHeight.sheetMode == SheetMode::MEDIUM) {
            sheetHeight = pageHeight_ * sheetTheme->GetMediumPercent();
            if (!Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_ELEVEN)) {
                sheetHeight = pageHeight_ * MEDIUM_SIZE_PRE;
            }
        } else if (sheetStyle.sheetHeight.sheetMode == SheetMode::LARGE) {
            sheetHeight = sheetTheme->GetHeightApplyFullScreen() ? pageHeight_ : largeHeight;
            sheetHeight *= sheetTheme->GetLargePercent();
        } else if (sheetStyle.sheetHeight.sheetMode == SheetMode::AUTO) {
            sheetHeight = GetFitContentHeight();
            if (sheetHeight > largeHeight) {
                sheetHeight = largeHeight;
            }
            HandleFitContontChange(sheetHeight);
        }
    } else {
        float height = 0.0f;
        if (sheetStyle.sheetHeight.height->Unit() == DimensionUnit::PERCENT) {
            height = sheetStyle.sheetHeight.height->ConvertToPxWithSize(sheetMaxHeight_);
        } else {
            height = sheetStyle.sheetHeight.height->ConvertToPx();
        }
        if (GreatNotEqual(height, largeHeight)) {
            sheetHeight = largeHeight;
        } else if (LessNotEqual(height, 0)) {
            sheetHeight = largeHeight;
        } else {
            sheetHeight = height;
        }
    }
    return sheetHeight;
}

void SheetPresentationPattern::BeforeCreateLayoutWrapper()
{
    ContentRootPattern::BeforeCreateLayoutWrapper();
    CHECK_NULL_VOID(sheetObject_);
    sheetObject_->BeforeCreateLayoutWrapper();
}

void SheetPresentationPattern::AvoidSafeArea(bool forceAvoid)
{
    sheetObject_->AvoidKeyboard(forceAvoid);
}

void SheetPresentationPattern::AvoidKeyboard(bool forceAvoid)
{
    auto sheetType = sheetType_;
    if (sheetType == SheetType::SHEET_POPUP || IsCurSheetNeedHalfFoldHover() ||
        sheetType == SheetType::SHEET_BOTTOM_OFFSET) {
        return;
    }
    if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_THIRTEEN)) {
        AvoidKeyboardBySheetMode(forceAvoid);
        return;
    }
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipelineContext = PipelineContext::GetCurrentContext();
    CHECK_NULL_VOID(pipelineContext);
    auto manager = pipelineContext->GetSafeAreaManager();
    if (!forceAvoid && keyboardHeight_ == manager->GetKeyboardInset().Length()) {
        return;
    }
    keyboardHeight_ = manager->GetKeyboardInset().Length();
    CHECK_NULL_VOID(host->GetFocusHub());
    auto heightUp = host->GetFocusHub()->IsCurrentFocus() ? GetSheetHeightChange() : 0.0f;
    sheetHeightUp_ = heightUp;
    if (isDismissProcess_) {
        TAG_LOGD(AceLogTag::ACE_SHEET,
            "The sheet will disappear, so there's no need to handle canceling keyboard avoidance here.");
        return;
    }
    TAG_LOGD(AceLogTag::ACE_SHEET, "To avoid Keyboard, sheet height increase %{public}f.", heightUp);
    auto offset = pageHeight_ - height_ - heightUp;
    auto renderContext = host->GetRenderContext();
    if (isScrolling_) {
        // if scrolling and keyboard will down, scroll needs to reset.
        if (NearZero(heightUp)) {
            ScrollTo(.0f);
            renderContext->UpdateTransformTranslate({ 0.0f, offset, 0.0f });
        } else {
            sheetHeightUp_ = pageHeight_ - (SHEET_BLANK_MINI_HEIGHT.ConvertToPx() + sheetTopSafeArea_) - height_;
            // Otherwise, sheet is necessary to raise and trigger scroll scrolling
            // sheet is raised to the top first
            renderContext->UpdateTransformTranslate(
                { 0.0f, SHEET_BLANK_MINI_HEIGHT.ConvertToPx() + sheetTopSafeArea_, 0.0f });
            // Then adjust the remaining height(heightUp = h - maxH) difference by scrolling
            ScrollTo(heightUp);
        }
    } else {
        // offset: translate endpoint, calculated from top
        renderContext->UpdateTransformTranslate({ 0.0f, offset, 0.0f });
    }
    if (IsSheetBottomStyle()) {
        OnHeightDidChange(height_ + sheetHeightUp_);
    }
}

float SheetPresentationPattern::GetSheetHeightChange()
{
    // TextFieldManagerNG::GetClickPosition: The upper left corner offset of the cursor position relative to rootNode
    // TextFieldManagerNG::GetHeight: the cursor Height + 24vp
    auto host = GetHost();
    CHECK_NULL_RETURN(host, .0f);
    auto pipelineContext = host->GetContext();
    CHECK_NULL_RETURN(pipelineContext, .0f);
    auto manager = pipelineContext->GetSafeAreaManager();
    auto keyboardInsert = manager->GetKeyboardInset();
    if (keyboardInsert.Length() == 0) {
        return 0.f;
    }
    auto textFieldManager = DynamicCast<TextFieldManagerNG>(pipelineContext->GetTextFieldManager());
    // inputH : Distance from input component's Caret to bottom of screen
    // = caret's offset + caret's height + 24vp
    if (textFieldManager && !textFieldManager->GetOptionalClickPosition().has_value() &&
        !pipelineContext->UsingCaretAvoidMode()) {
        TAG_LOGD(AceLogTag::ACE_SHEET, "illegal caret position, don't calc height this time");
        return .0f;
    }
    float inputH = 0.f;
    if (pipelineContext->UsingCaretAvoidMode()) {
        // when user scroll after avoiding keyboard, we need to update scroll offset before avoid keyboard twice.
        GetCurrentScrollHeight();
        // when avoiding keyboard twice, recover input height before avoiding is needed.
        inputH = textFieldManager ? pipelineContext->GetRootHeight() -
            textFieldManager->GetFocusedNodeCaretRect().Top() - textFieldManager->GetHeight() - sheetHeightUp_ -
            scrollHeight_ : 0.f;
    } else {
        inputH = textFieldManager ? (pipelineContext->GetRootHeight() -
            textFieldManager->GetFocusedNodeCaretRect().Top() - textFieldManager->GetHeight()) : 0.f;
    }
    // keyboardH : keyboard height + height of the bottom navigation bar
    auto keyboardH = keyboardInsert.Length() + manager->GetSystemSafeArea().bottom_.Length();
    // The minimum height of the input component from the bottom of the screen after popping up the soft keyboard
    auto inputMinH = keyboardH;
    // the LARGE sheet is 15vp from the status bar, and SHEET_CENTER's Node height not equal to screen height.
    auto largeHeight = pipelineContext->GetRootHeight() - SHEET_BLANK_MINI_HEIGHT.ConvertToPx() - sheetTopSafeArea_;
    // maxH : height that the sheet can reach the stage = the LARGE sheet - Current sheet height
    auto maxH = largeHeight - height_;
    if (inputH >= inputMinH) {
        // sheet needs not up
        TAG_LOGD(AceLogTag::ACE_SHEET, "Sheet needs not up");
        return .0f;
    }
    // The expected height of the sheet to be lifted
    auto h = inputMinH - inputH;
    if (h <= maxH) {
        RecoverScrollOrResizeAvoidStatus();
        // sheet is lifted up with h
        TAG_LOGD(AceLogTag::ACE_SHEET, "Sheet is lifted up with h = %{public}f", h);
        return h;
    }
    // h > maxH, sheet goes up to the LARGE, then adjust the remaining height(h - maxH) difference by scrolling
    if (IsResizeWhenAvoidKeyboard()) {
        // remaing height need to update to (keyboardH - bottomDistance) when in resize mode after translate
        inputH = sheetType_ == SheetType::SHEET_CENTER ? height_ - centerHeight_ : 0.0f;
        h = inputMinH - inputH;
    }
    TAG_LOGD(AceLogTag::ACE_SHEET, "Sheet is LARGE, and there is [%{public}f] height left to be processed.", h - maxH);
    isScrolling_ = true;
    return h - maxH;
}

void SheetPresentationPattern::CreatePropertyCallback()
{
    sheetObject_->CreatePropertyCallback();
}

void SheetPresentationPattern::ModifyFireSheetTransition(float dragVelocity)
{
    sheetObject_->ModifyFireSheetTransition(dragVelocity);
}

/**
 * @brief Get the max height before drag or nestedScroll.
 * the height is relative to the bottom of screen.
 */
float SheetPresentationPattern::GetMaxSheetHeightBeforeDragUpdate()
{
    if (IsCurSheetNeedHalfFoldHover() || sheetType_ == SheetType::SHEET_BOTTOM_OFFSET ||
        IsNotBottomStyleInSubwindow()) {
        return GetPageHeightWithoutOffset() - sheetOffsetY_;
    }
    auto sheetDetentsSize = sheetDetentHeight_.size();
    if (sheetDetentsSize <= 0) {
        TAG_LOGW(AceLogTag::ACE_SHEET, "sheetDetentsSize is nonPositive");
        return 0.0f;
    }
    // The value can be returned in other scenarios as follows:
    // 1. bottom sheet tyle : maxHeight is maxDetent.
    // 2. center and other sheet tyle, except for popup tyle :
    // maxHeight is the height of the top left corner of sheet from the bottom of screen
    // 3. scene in setting offsetY : add offsetY to the following value
    return sheetDetentHeight_[sheetDetentsSize - 1];
}

/**
 * @brief Get the height before drag or nestedScroll.
 * the height is relative to the bottom of screen.
 */
float SheetPresentationPattern::GetSheetHeightBeforeDragUpdate()
{
    if (IsCurSheetNeedHalfFoldHover() || sheetType_ == SheetType::SHEET_BOTTOM_OFFSET ||
        IsNotBottomStyleInSubwindow()) {
        return GetPageHeightWithoutOffset() - sheetOffsetY_;
    }
    // height_ : from the bottom of screen, after the sheet entry action has ended.
    // sheetHeightUp_ : increased height to avoid soft keyboard.
    // -bottomOffsetY_ : increased height by setting offsetY. bottomOffsetY_ is a negative number.
    return height_ + sheetHeightUp_;
}

float SheetPresentationPattern::UpdateSheetTransitionOffset()
{
    // dentets greater than 1 and no rebound
    if (!WillSpringBack() && sheetDetentHeight_.size() > 1) {
        // When avoiding keyboards
        // don't consider the height difference introduced by avoidance after switching detents
        sheetHeightUp_ = 0.0f;
    }
    // apply to springBack scene
    // return the offset before drag
    auto offset = GetPageHeightWithoutOffset() - GetSheetHeightBeforeDragUpdate();
    return offset;
}

void SheetPresentationPattern::SheetTransition(bool isTransitionIn, float dragVelocity)
{
    if ((HasOnHeightDidChange() && IsSheetBottomStyle() && isTransitionIn && isNeedProcessHeight_)
        || (isTransitionIn && IsNeedChangeScrollHeight(height_))) {
        // Pass height_ because it was updated by ChangeSheetHeight() before
        ModifyFireSheetTransition(dragVelocity);
        return;
    }
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    AnimationOption option;
    const RefPtr<InterpolatingSpring> curve = sheetObject_->GetSheetTransitionCurve(dragVelocity);
    option.SetCurve(curve);
    sheetObject_->SetSheetAnimationOption(option);
    auto offset = UpdateSheetTransitionOffset();
    if (!isTransitionIn) {
        const auto& overlayManager = GetOverlayManager();
        CHECK_NULL_VOID(overlayManager);
        auto maskNode = overlayManager->GetSheetMask(host);
        if (maskNode) {
            overlayManager->PlaySheetMaskTransition(maskNode, host, false);
        }
    }
    option.SetOnFinishEvent(sheetObject_->GetSheetTransitionFinishEvent(isTransitionIn));
    StartSheetTransitionAnimation(option, isTransitionIn, offset);
}

void SheetPresentationPattern::SheetTransitionForOverlay(bool isTransitionIn, bool isFirstTransition)
{
    if (GetDismissProcess()) {
        return;
    }
    // get sheet animation option and finishCallback
    AnimationOption option = sheetObject_->GetAnimationOptionForOverlay(isTransitionIn, isFirstTransition);
    // Init other animation information, includes the starting point of the animation.
    sheetObject_->InitAnimationForOverlay(isTransitionIn, isFirstTransition);
    StopModifySheetTransition();
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContextRefPtr();
    AnimationUtils::Animate(option,
        sheetObject_->GetAnimationPropertyCallForOverlay(isTransitionIn), // Moving effect end point
        option.GetOnFinishEvent(), nullptr, pipeline);
    SetBottomStyleHotAreaInSubwindow();
}

void SheetPresentationPattern::SheetInteractiveDismiss(BindSheetDismissReason dismissReason, float dragVelocity)
{
    isDirectionUp_ = false;
    if (HasShouldDismiss() || HasOnWillDismiss()) {
        const auto& overlayManager = GetOverlayManager();
        CHECK_NULL_VOID(overlayManager);
        overlayManager->SetDismissTarget(DismissTarget(sheetKey_));
        auto host = GetHost();
        CHECK_NULL_VOID(host);
        SheetManager::GetInstance().SetDismissSheet(host->GetId());
        if (dismissReason >= BindSheetDismissReason::SLIDE_DOWN) {
            isSpringBack_ = true;
            if (HasSheetSpringBack()) {
                CallSheetSpringBack();
            } else {
                isDismissProcess_ = false;
                SheetTransition(true);
            }
        }
        CallShouldDismiss();
        CallOnWillDismiss(static_cast<int32_t>(dismissReason));
    } else {
        DismissTransition(false, dragVelocity);
    }
}

void SheetPresentationPattern::DismissTransition(bool isTransitionIn, float dragVelocity)
{
    isDismissProcess_ = true;
    const auto& overlayManager = GetOverlayManager();
    CHECK_NULL_VOID(overlayManager);
    overlayManager->ModalPageLostFocus(GetHost());
    if (!isTransitionIn) {
        OnWillDisappear();
    }
    auto sheetType = GetSheetTypeNoProcess();
    if (sheetType == SheetType::SHEET_POPUP) {
        BubbleStyleSheetTransition(isTransitionIn);
    } else {
        SheetTransition(isTransitionIn, dragVelocity);
    }
}

void SheetPresentationPattern::ChangeScrollHeight(float height)
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto geometryNode = host->GetGeometryNode();
    CHECK_NULL_VOID(geometryNode);
    auto scrollNode = GetSheetScrollNode();
    CHECK_NULL_VOID(scrollNode);
    auto scrollProps = scrollNode->GetLayoutProperty<ScrollLayoutProperty>();
    CHECK_NULL_VOID(scrollProps);
    auto scrollHeight = height - GetTitleBuilderHeight() - resizeDecreasedHeight_;
    auto sheetType = GetSheetTypeNoProcess();
    if (sheetType == SheetType::SHEET_POPUP || sheetType == SheetType::SHEET_CENTER ||
        sheetType == SheetType::SHEET_BOTTOM_OFFSET) {
        auto sheetHeight = geometryNode->GetFrameSize().Height();
        scrollHeight = sheetHeight - GetTitleBuilderHeight() - resizeDecreasedHeight_;
    }
    scrollProps->UpdateUserDefinedIdealSize(CalcSize(std::nullopt, CalcLength(scrollHeight)));
    scrollNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
}

bool SheetPresentationPattern::IsSingleDetents(const NG::SheetStyle& sheetStyle)
{
    bool isSingle = true;
    bool isFitContent = false;
    for (const auto& detent : sheetStyle.detents) {
        if (!detent.sheetMode.has_value()) {
            continue;
        }
        if (detent.sheetMode.value() == SheetMode::AUTO) {
            isFitContent = true;
        }
    }
    if (unSortedSheetDentents_.size() == SHEET_DETENTS_TWO) {
        isSingle = unSortedSheetDentents_[SHEET_DETENTS_ZERO] == unSortedSheetDentents_[SHEET_DETENTS_ONE];
    } else if (unSortedSheetDentents_.size() == SHEET_DETENTS_THREE) {
        isSingle = unSortedSheetDentents_[SHEET_DETENTS_ZERO] == unSortedSheetDentents_[SHEET_DETENTS_ONE] &&
                   unSortedSheetDentents_[SHEET_DETENTS_ONE] == unSortedSheetDentents_[SHEET_DETENTS_TWO];
    }
    if (sheetStyle.detents.size() > SHEET_DETENTS_ONE && isFitContent) {
        isSingle = false;
    }
    return isSingle;
}

void SheetPresentationPattern::UpdateDragBarStatus()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(host->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    auto showDragIndicator = sheetStyle.showDragBar.value_or(true);

    auto sheetDragBar = GetDragBarNode();
    CHECK_NULL_VOID(sheetDragBar);
    auto dragBarLayoutProperty = sheetDragBar->GetLayoutProperty();
    CHECK_NULL_VOID(dragBarLayoutProperty);
    if (!host->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_ELEVEN)) {
        dragBarLayoutProperty->UpdateVisibility(showDragIndicator ? VisibleType::VISIBLE : VisibleType::GONE);
        sheetDragBar->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
        return;
    }
    if (IsSheetBottomStyle() && !IsSingleDetents(sheetStyle)) {
        if (sheetStyle.isTitleBuilder.has_value()) {
            dragBarLayoutProperty->UpdateVisibility(showDragIndicator ? VisibleType::VISIBLE : VisibleType::INVISIBLE);
        } else {
            dragBarLayoutProperty->UpdateVisibility(showDragIndicator ? VisibleType::VISIBLE : VisibleType::GONE);
        }
    } else {
        if (sheetStyle.isTitleBuilder.has_value()) {
            dragBarLayoutProperty->UpdateVisibility(VisibleType::INVISIBLE);
        } else {
            dragBarLayoutProperty->UpdateVisibility(VisibleType::GONE);
        }
    }
    int32_t zIndex = sheetStyle.enableFloatingDragBar.value_or(false) ? INT32_MAX : 0;
    auto dragBarRenderContext = sheetDragBar->GetRenderContext();
    CHECK_NULL_VOID(dragBarRenderContext);
    dragBarRenderContext->UpdateZIndex(zIndex);
    sheetDragBar->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
}

void SheetPresentationPattern::UpdateTitleColumnSize()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(host->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    auto operationColumn = GetTitleBuilderNode();
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);

    if (operationColumn && sheetStyle.sheetTitle.has_value() &&
        NearEqual(pipeline->GetFontScale(), sheetTheme->GetSheetNormalScale())) {
        auto layoutProps = operationColumn->GetLayoutProperty<LinearLayoutProperty>();
        CHECK_NULL_VOID(layoutProps);
        layoutProps->UpdateUserDefinedIdealSize(CalcSize(
            std::nullopt, CalcLength(sheetTheme->GetOperationAreaHeight() - sheetTheme->GetSheetTitleAreaMargin() -
                                     GetDragBarHeight(GetDragBarNode()))));
        if (sheetStyle.sheetSubtitle.has_value()) {
            layoutProps->UpdateUserDefinedIdealSize(CalcSize(
                std::nullopt, CalcLength(sheetTheme->GetOperationAreaHeightDouble() -
                                         sheetTheme->GetSheetTitleAreaMargin() - GetDragBarHeight(GetDragBarNode()))));
        }
    }
}

float SheetPresentationPattern::GetCloseIconPosX(const SizeF& sheetSize, const RefPtr<SheetTheme>& sheetTheme)
{
    auto closeIconX = sheetSize.Width() - static_cast<float>(sheetTheme->GetCloseIconButtonWidth().ConvertToPx()) -
                      static_cast<float>(sheetTheme->GetTitleTextMargin().ConvertToPx());
    if (AceApplicationInfo::GetInstance().IsRightToLeft() &&
        AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) {
        closeIconX = static_cast<float>(sheetTheme->GetTitleTextMargin().ConvertToPx());
    }
    return closeIconX;
}

bool SheetPresentationPattern::IsShowCloseIcon()
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, false);
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(host->GetLayoutProperty());
    CHECK_NULL_RETURN(layoutProperty, false);
    return layoutProperty->GetSheetStyleValue().showCloseIcon.value_or(true);
}

RefPtr<FrameNode> SheetPresentationPattern::GetTitleNode()
{
    auto operationNode = GetTitleBuilderNode();
    CHECK_NULL_RETURN(operationNode, nullptr);
    return DynamicCast<FrameNode>(operationNode->GetChildAtIndex(0));
}

void SheetPresentationPattern::UpdateTitleTextColor()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);
    auto firstChild = GetTitleBuilderNode();
    CHECK_NULL_VOID(firstChild);
    auto sheetTitleColumn = firstChild->GetChildAtIndex(0);
    CHECK_NULL_VOID(sheetTitleColumn);
    auto mainRow = sheetTitleColumn->GetChildAtIndex(0);
    CHECK_NULL_VOID(mainRow);
    auto mainTitleText = DynamicCast<FrameNode>(mainRow->GetChildAtIndex(0));
    CHECK_NULL_VOID(mainTitleText);
    auto mainTitleProp = mainTitleText->GetLayoutProperty<TextLayoutProperty>();
    CHECK_NULL_VOID(mainTitleProp);
    mainTitleProp->UpdateTextColor(sheetTheme->GetTitleTextFontColor());
    mainTitleText->MarkDirtyNode(PROPERTY_UPDATE_RENDER);

    auto layoutProperty = DynamicCast<SheetPresentationProperty>(host->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    if (sheetStyle.sheetSubtitle.has_value()) {
        auto subRow = sheetTitleColumn->GetChildAtIndex(1);
        CHECK_NULL_VOID(subRow);
        auto subTitleText = DynamicCast<FrameNode>(subRow->GetChildAtIndex(0));
        CHECK_NULL_VOID(subTitleText);
        auto subTitleProp = subTitleText->GetLayoutProperty<TextLayoutProperty>();
        CHECK_NULL_VOID(subTitleProp);
        subTitleProp->UpdateTextColor(sheetTheme->GetSubtitleTextFontColor());
        subTitleText->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
    }
}

void SheetPresentationPattern::UpdateTitlePadding()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(host->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    if (!layoutProperty->GetSheetStyleValue().isTitleBuilder.has_value()) {
        return;
    }

    auto titleNode = GetTitleNode();
    CHECK_NULL_VOID(titleNode);
    auto titleLayoutProperty = DynamicCast<LinearLayoutProperty>(titleNode->GetLayoutProperty());
    CHECK_NULL_VOID(titleLayoutProperty);
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);
    auto showCloseIcon = true;
    if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_FOURTEEN)) {
        showCloseIcon = IsShowCloseIcon();
    }
    PaddingProperty padding;

    // The title bar area is reserved for the close button area size by default.
    if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) {
        auto sheetCloseIconTitleSpace = sheetTheme->GetSheetCloseIconTitleSpaceNew();
        padding.end =
            CalcLength(showCloseIcon ? sheetCloseIconTitleSpace + sheetTheme->GetCloseIconButtonWidth() : 0.0_vp);
    } else {
        padding.right = CalcLength(SHEET_CLOSE_ICON_TITLE_SPACE + SHEET_CLOSE_ICON_WIDTH);
    }
    titleLayoutProperty->UpdatePadding(padding);
    auto titleColumnPattern = titleNode->GetPattern<LinearLayoutPattern>();
    CHECK_NULL_VOID(titleColumnPattern);
    titleColumnPattern->CheckLocalized();
    titleNode->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
}

void SheetPresentationPattern::UpdateCloseIconStatus()
{
    if (!Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_ELEVEN)) {
        TAG_LOGI(AceLogTag::ACE_SHEET, "PlatformVersion less or equal to version 10");
        return;
    }
    auto showCloseIcon = IsShowCloseIcon();
    auto sheetCloseIcon = GetSheetCloseIcon();
    CHECK_NULL_VOID(sheetCloseIcon);
    auto iconLayoutProperty = sheetCloseIcon->GetLayoutProperty();
    CHECK_NULL_VOID(iconLayoutProperty);
    iconLayoutProperty->UpdateVisibility(showCloseIcon ? VisibleType::VISIBLE : VisibleType::INVISIBLE);
    sheetCloseIcon->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
}

void SheetPresentationPattern::UpdateSheetTitle()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = PipelineContext::GetCurrentContext();
    CHECK_NULL_VOID(pipeline);
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(host->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    if (sheetStyle.sheetTitle.has_value()) {
        auto titleId = GetTitleId();
        auto titleNode = DynamicCast<FrameNode>(ElementRegister::GetInstance()->GetNodeById(titleId));
        CHECK_NULL_VOID(titleNode);
        auto titleProp = titleNode->GetLayoutProperty<TextLayoutProperty>();
        CHECK_NULL_VOID(titleProp);
        titleProp->UpdateContent(sheetStyle.sheetTitle.value());
        if (pipeline->GetFontScale() != scale_) {
            titleNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
        }
        titleNode->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
        if (sheetStyle.sheetSubtitle.has_value()) {
            auto subtitleId = GetSubtitleId();
            auto subtitleNode = DynamicCast<FrameNode>(ElementRegister::GetInstance()->GetNodeById(subtitleId));
            CHECK_NULL_VOID(subtitleNode);
            auto subtitleProp = subtitleNode->GetLayoutProperty<TextLayoutProperty>();
            CHECK_NULL_VOID(subtitleProp);
            subtitleProp->UpdateContent(sheetStyle.sheetSubtitle.value());
            subtitleNode->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
        }
    }
}

Dimension SheetPresentationPattern::GetDragBarHeight(const RefPtr<FrameNode>& dragBarNode)
{
    CHECK_NULL_RETURN(dragBarNode, 0.0_vp);
    auto dragBarLayoutProperty = dragBarNode->GetLayoutProperty();
    CHECK_NULL_RETURN(dragBarLayoutProperty, 0.0_vp);
    if (!dragBarLayoutProperty->HasVisibility()) {
        return 0.0_vp;
    }
    return (dragBarLayoutProperty->GetVisibility() == VisibleType::GONE) ? 0.0_vp : SHEET_DRAG_BAR_HEIGHT;
}

void SheetPresentationPattern::UpdateFontScaleStatus()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = PipelineContext::GetCurrentContext();
    CHECK_NULL_VOID(pipeline);
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(host->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    if (pipeline->GetFontScale() != scale_) {
        auto operationNode = GetTitleBuilderNode();
        CHECK_NULL_VOID(operationNode);
        auto titleColumnNode = DynamicCast<FrameNode>(operationNode->GetChildAtIndex(0));
        CHECK_NULL_VOID(titleColumnNode);
        auto layoutProps = operationNode->GetLayoutProperty<LinearLayoutProperty>();
        CHECK_NULL_VOID(layoutProps);
        auto titleLayoutProps = titleColumnNode->GetLayoutProperty<LinearLayoutProperty>();
        CHECK_NULL_VOID(titleLayoutProps);
        auto sheetTheme = pipeline->GetTheme<SheetTheme>();
        CHECK_NULL_VOID(sheetTheme);
        bool isSheetHasNoTitle = !sheetStyle.isTitleBuilder.has_value();
        bool isFontScaledInSystemTitle = sheetStyle.isTitleBuilder.has_value() && !sheetStyle.isTitleBuilder.value() &&
                                         GreatNotEqual(pipeline->GetFontScale(), sheetTheme->GetSheetNormalScale());
        if (isSheetHasNoTitle || isFontScaledInSystemTitle) {
            layoutProps->ClearUserDefinedIdealSize(false, true);
            titleLayoutProps->ClearUserDefinedIdealSize(false, true);
        } else if (sheetStyle.isTitleBuilder.has_value()) {
            auto sheetTheme = pipeline->GetTheme<SheetTheme>();
            CHECK_NULL_VOID(sheetTheme);
            auto operationAreaHeight = sheetTheme->GetOperationAreaHeight();
            layoutProps->UpdateUserDefinedIdealSize(
                CalcSize(std::nullopt, CalcLength(operationAreaHeight - sheetTheme->GetSheetTitleAreaMargin() -
                                                  GetDragBarHeight(GetDragBarNode()))));
            titleLayoutProps->UpdateUserDefinedIdealSize(CalcSize(std::nullopt, CalcLength(operationAreaHeight)));
            if (sheetStyle.sheetSubtitle.has_value()) {
                layoutProps->UpdateUserDefinedIdealSize(CalcSize(std::nullopt,
                    CalcLength(sheetTheme->GetOperationAreaHeightDouble() - sheetTheme->GetSheetTitleAreaMargin() -
                               GetDragBarHeight(GetDragBarNode()))));
                titleLayoutProps->UpdateUserDefinedIdealSize(CalcSize(std::nullopt,
                    CalcLength(sheetTheme->GetOperationAreaHeightDouble() - SHEET_DOUBLE_TITLE_BOTTON_MARGIN)));
            }
        }
        UpdateSheetTitle();
        scale_ = pipeline->GetFontScale();
        auto sheetWrapper = host->GetParent();
        CHECK_NULL_VOID(sheetWrapper);
        sheetWrapper->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
    }
}

void SheetPresentationPattern::UpdateSheetCloseIcon()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);
    auto sheetCloseIcon = DynamicCast<FrameNode>(host->GetChildAtIndex(2));
    CHECK_NULL_VOID(sheetCloseIcon);
    auto renderContext = sheetCloseIcon->GetRenderContext();
    CHECK_NULL_VOID(renderContext);
    renderContext->UpdateBackgroundColor(sheetTheme->GetCloseIconColor());
    sheetCloseIcon->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
    auto iconNode = DynamicCast<FrameNode>(sheetCloseIcon->GetChildAtIndex(0));
    CHECK_NULL_VOID(iconNode);
    // when api >= 12, use symbol format image, else use image format.
    if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE) &&
        SystemProperties::IsNeedSymbol()) {
        auto symbolLayoutProperty = iconNode->GetLayoutProperty<TextLayoutProperty>();
        CHECK_NULL_VOID(symbolLayoutProperty);
        symbolLayoutProperty->UpdateSymbolColorList({sheetTheme->GetCloseIconSymbolColor()});
    } else {
        auto imagePaintProperty = iconNode->GetPaintProperty<ImageRenderProperty>();
        CHECK_NULL_VOID(imagePaintProperty);
        imagePaintProperty->UpdateSvgFillColor(sheetTheme->GetCloseIconImageColor());
    }
    iconNode->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
}

void SheetPresentationPattern::UpdateSheetBackgroundColor()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(host->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    if (sheetStyle.backgroundColor.has_value()) {
        return;
    }
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);
    auto renderContext = host->GetRenderContext();
    CHECK_NULL_VOID(renderContext);
    renderContext->UpdateBackgroundColor(sheetTheme->GetSheetBackgoundColor());
    host->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
}

void SheetPresentationPattern::OnColorConfigurationUpdate()
{
    UpdateTitleTextColor();
    UpdateSheetCloseIcon();
    UpdateSheetBackgroundColor();
}

float SheetPresentationPattern::GetWrapperHeight()
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, 0.0f);
    auto sheetWrapper = host->GetParent();
    CHECK_NULL_RETURN(sheetWrapper, 0.0f);
    auto sheetWrapperNode = AceType::DynamicCast<FrameNode>(sheetWrapper);
    CHECK_NULL_RETURN(sheetWrapperNode, 0.0f);
    auto sheetWrapperGeometryNode = sheetWrapperNode->GetGeometryNode();
    CHECK_NULL_RETURN(sheetWrapperGeometryNode, 0.0f);
    return sheetWrapperGeometryNode->GetFrameSize().Height();
}

float SheetPresentationPattern::GetWrapperWidth()
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, 0.0f);
    auto sheetWrapper = host->GetParent();
    CHECK_NULL_RETURN(sheetWrapper, 0.0f);
    auto sheetWrapperNode = AceType::DynamicCast<FrameNode>(sheetWrapper);
    CHECK_NULL_RETURN(sheetWrapperNode, 0.0f);
    auto sheetWrapperGeometryNode = sheetWrapperNode->GetGeometryNode();
    CHECK_NULL_RETURN(sheetWrapperGeometryNode, 0.0f);
    return sheetWrapperGeometryNode->GetFrameSize().Width();
}

bool SheetPresentationPattern::SheetHeightNeedChanged()
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, false);
    auto sheetGeometryNode = host->GetGeometryNode();
    CHECK_NULL_RETURN(sheetGeometryNode, false);
    if (!NearEqual(sheetGeometryNode->GetFrameSize().Height(), sheetObject_->GetSheetHeight()) ||
        !NearEqual(GetWrapperHeight(), wrapperHeight_)) {
        return true;
    }
    return false;
}

bool SheetPresentationPattern::SheetWidthNeedChanged()
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, false);
    auto sheetGeometryNode = host->GetGeometryNode();
    CHECK_NULL_RETURN(sheetGeometryNode, false);
    if (!NearEqual(sheetGeometryNode->GetFrameSize().Width(), sheetWidth_) ||
        !NearEqual(GetWrapperWidth(), wrapperWidth_)) {
        return true;
    }
    return false;
}

void SheetPresentationPattern::UpdateMaskBackgroundColor()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);
    auto layoutProperty = host->GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    sheetMaskColor_ = sheetStyle.maskColor.value_or(sheetTheme->GetMaskColor());
    if (!AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_ELEVEN)) {
        if (sheetStyle.maskColor.has_value()) {
            sheetMaskColor_ = sheetStyle.maskColor.value();
        } else {
            sheetMaskColor_ = Color::TRANSPARENT;
        }
    } else {
        if ((!sheetStyle.interactive.has_value() && GetSheetTypeNoProcess() == SheetType::SHEET_POPUP) ||
            sheetStyle.interactive.value_or(false)) {
            sheetMaskColor_ = Color::TRANSPARENT;
        }
    }
}

void SheetPresentationPattern::UpdateMaskBackgroundColorRender()
{
    if (GetDismissProcess()) {
        return;
    }
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    UpdateMaskBackgroundColor();
    const auto& overlayManager = GetOverlayManager();
    CHECK_NULL_VOID(overlayManager);
    auto maskNode = overlayManager->GetSheetMask(host);
    CHECK_NULL_VOID(maskNode);
    auto maskRenderContext = maskNode->GetRenderContext();
    CHECK_NULL_VOID(maskRenderContext);
    maskRenderContext->UpdateBackgroundColor(sheetMaskColor_);
}

void SheetPresentationPattern::FireCommonCallback()
{
    FireOnTypeDidChange();
    FireOnWidthDidChange();
    FireOnHeightDidChange();
}

void SheetPresentationPattern::PopupSheetChanged()
{
    // when sheet height and width not change, but sheetOffsetY changed because of avoiding keyboard, update offsetY.
    if (SheetHeightNeedChanged() || SheetWidthNeedChanged() || typeChanged_ || sheetOffsetYChanged_) {
        FireCommonCallback();
        auto renderContext = GetRenderContext();
        CHECK_NULL_VOID(renderContext);
        renderContext->UpdateTransformTranslate({ 0.0f, Dimension(sheetOffsetY_), 0.0f });
        typeChanged_ = false;
        sheetOffsetYChanged_ = false;
    }
}

void SheetPresentationPattern::CheckSheetHeightChange()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto sheetGeometryNode = host->GetGeometryNode();
    CHECK_NULL_VOID(sheetGeometryNode);
    if (!isFirstInit_) {
        if (typeChanged_) {
            if (sheetType_ == SheetType::SHEET_POPUP) {
                MarkSheetPageNeedRender();
            }
            SetSheetBorderWidth();
        }
        if (sheetType_ == SheetType::SHEET_POPUP) {
            PopupSheetChanged();
        } else if (SheetHeightNeedChanged() || typeChanged_ || windowChanged_ || topSafeAreaChanged_) {
            const auto& overlayManager = GetOverlayManager();
            CHECK_NULL_VOID(overlayManager);
            auto layoutProperty = host->GetLayoutProperty<SheetPresentationProperty>();
            CHECK_NULL_VOID(layoutProperty);
            auto sheetStyle = layoutProperty->GetSheetStyleValue();
            overlayManager->ComputeSheetOffset(sheetStyle, host);
            overlayManager->PlaySheetTransition(host, true, false);
            auto maskNode = overlayManager->GetSheetMask(host);
            if (maskNode) {
                UpdateMaskBackgroundColorRender();
            }
            windowChanged_ = false;
            topSafeAreaChanged_ = false;
            typeChanged_ = false;
        }
    }
    sheetObject_->SetSheetHeight(sheetGeometryNode->GetFrameSize().Height());
    sheetWidth_ = sheetGeometryNode->GetFrameSize().Width();
    wrapperHeight_ = GetWrapperHeight();
    wrapperWidth_ = GetWrapperWidth();
    isFirstInit_ = false;
    GetBuilderInitHeight();
}

void SheetPresentationPattern::IsCustomDetentsChanged(SheetStyle sheetStyle)
{
    unsigned int preDetentsSize = preDetents_.size();
    unsigned int userSetDetentsSize = sheetStyle.detents.size();
    // if preview detents size is not equal to the new one, set detents index to zero
    if (preDetentsSize != userSetDetentsSize) {
        detentsFinalIndex_ = 0;
        return;
    }

    // check whether the new coming one's content is equal to the last time input
    unsigned int length = std::min(preDetentsSize, userSetDetentsSize);
    for (unsigned int index = 0; index < length; index++) {
        if (sheetStyle.detents[index] != preDetents_[index]) {
            // if detents has been changed, set detents index to zero
            detentsFinalIndex_ = 0;
            break;
        }
    }
}

void SheetPresentationPattern::InitSheetDetents()
{
    // record input detents
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    IsCustomDetentsChanged(sheetStyle);
    preDetents_.clear();
    sheetDetentHeight_.clear();
    unSortedSheetDentents_.clear();
    float height = 0.0f;
    auto sheetNode = GetHost();
    CHECK_NULL_VOID(sheetNode);
    auto geometryNode = sheetNode->GetGeometryNode();
    CHECK_NULL_VOID(geometryNode);
    auto pipelineContext = sheetNode->GetContext();
    CHECK_NULL_VOID(pipelineContext);
    auto sheetTheme = pipelineContext->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);
    auto largeHeight = sheetMaxHeight_ - SHEET_BLANK_MINI_HEIGHT.ConvertToPx();
    auto sheetType = GetSheetTypeNoProcess();
    auto sheetFrameHeight = geometryNode->GetFrameSize().Height();
    auto mediumSize = sheetTheme->GetMediumPercent();
    float largeHeightOfTheme = sheetTheme->GetHeightApplyFullScreen() ? pageHeight_ : largeHeight;
    largeHeightOfTheme *= sheetTheme->GetLargePercent();
    if (!Container::GreatOrEqualAPIVersion(PlatformVersion::VERSION_ELEVEN)) {
        mediumSize = MEDIUM_SIZE_PRE;
    }
    switch (sheetType) {
        case SheetType::SHEET_BOTTOMLANDSPACE:
            if (!AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_TWELVE)) {
                height = sheetFrameHeight - SHEET_BLANK_MINI_HEIGHT.ConvertToPx();
                sheetDetentHeight_.emplace_back(height);
                break;
            }
            [[fallthrough]];
        case SheetType::SHEET_BOTTOM:
            [[fallthrough]];
        case SheetType::SHEET_BOTTOM_FREE_WINDOW:
            if (sheetStyle.detents.size() <= 0) {
                height = InitialSingleGearHeight(sheetStyle);
                sheetDetentHeight_.emplace_back(height);
                break;
            }
            InitDetents(sheetStyle, height, mediumSize, largeHeightOfTheme, largeHeight);
            std::sort(sheetDetentHeight_.begin(), sheetDetentHeight_.end(), std::less<float>());
            sheetDetentHeight_.erase(
                std::unique(sheetDetentHeight_.begin(), sheetDetentHeight_.end()), sheetDetentHeight_.end());
            break;
        case SheetType::SHEET_CENTER:
            height = (centerHeight_ + pageHeight_) / SHEET_HALF_HEIGHT;
            sheetDetentHeight_.emplace_back(height);
            break;
        case SheetType::SHEET_BOTTOM_OFFSET:
            height = InitialSingleGearHeight(sheetStyle);
            sheetDetentHeight_.emplace_back(height);
            break;
        default:
            break;
    }
}

void SheetPresentationPattern::InitDetents(
    SheetStyle sheetStyle, float height, double mediumSize, float largeHeightOfTheme, double largeHeight)
{
    for (auto iter : sheetStyle.detents) {
        preDetents_.emplace_back(iter);
        if (iter.sheetMode.has_value()) {
            if (iter.sheetMode == SheetMode::MEDIUM) {
                height = pageHeight_ * mediumSize;
            } else if (iter.sheetMode == SheetMode::LARGE) {
                height = largeHeightOfTheme;
            } else if (iter.sheetMode == SheetMode::AUTO) {
                height = GetFitContentHeight();
                height = GreatNotEqual(height, largeHeight) ? largeHeight : height;
                HandleFitContontChange(height);
            }
        } else {
            if (iter.height->Unit() == DimensionUnit::PERCENT) {
                height = iter.height->ConvertToPxWithSize(sheetMaxHeight_);
            } else {
                height = iter.height->ConvertToPx();
            }
            if (GreatNotEqual(height, largeHeight)) {
                height = largeHeight;
            } else if (LessNotEqual(height, 0)) {
                height = largeHeight;
            }
        }
        sheetDetentHeight_.emplace_back(height);
        unSortedSheetDentents_.emplace_back(height);
    }
}

void SheetPresentationPattern::HandleFitContontChange(float height)
{
    if ((NearEqual(height_, sheetFitContentHeight_)) && (!NearEqual(height, sheetFitContentHeight_))) {
        ChangeSheetHeight(height);
        ChangeSheetPage(height_);
        SheetTransition(true);
    }
    sheetFitContentHeight_ = height;
}

float SheetPresentationPattern::ComputeTransitionOffset(float sheetHeight)
{
    float offset = 0.0f;
    auto sheetType = GetSheetTypeNoProcess();
    if (sheetType == SheetType::SHEET_POPUP ||
        sheetType == SheetType::SHEET_BOTTOM_OFFSET || IsCurSheetNeedHalfFoldHover()
        || IsNotBottomStyleInSubwindow()) {
        offset = GetSheetOffset();
    } else {
        offset = GetPageHeightWithoutOffset() - sheetHeight;
    }
    return offset;
}

int32_t SheetPresentationPattern::GetSubWindowId() const
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, INVALID_SUBWINDOW_ID);
    auto sheetWrapper = host->GetParent();
    CHECK_NULL_RETURN(sheetWrapper, INVALID_SUBWINDOW_ID);
    auto wrapperNode = AceType::DynamicCast<FrameNode>(sheetWrapper);
    auto sheetWrapperPattern = wrapperNode->GetPattern<SheetWrapperPattern>();
    CHECK_NULL_RETURN(sheetWrapperPattern, INVALID_SUBWINDOW_ID);
    return sheetWrapperPattern->GetSubWindowId();
}

SheetType SheetPresentationPattern::ComputeSheetTypeInSubWindow() const
{
    auto instanceId = SubwindowManager::GetInstance()->GetParentContainerId(GetSubWindowId());
    auto container = AceEngine::Get().GetContainer(instanceId);
    CHECK_NULL_RETURN(container, SheetType::SHEET_CENTER);
    auto mainWindowContext = AceType::DynamicCast<NG::PipelineContext>(container->GetPipelineContext());
    CHECK_NULL_RETURN(mainWindowContext, SheetType::SHEET_CENTER);
    auto windowWidth = mainWindowContext->GetDisplayWindowRectInfo().Width();
    auto windowHeight = mainWindowContext->GetDisplayWindowRectInfo().Height();
    auto manager = mainWindowContext->GetWindowManager();
    if (container->IsUIExtensionWindow()) {
        auto subwindow = SubwindowManager::GetInstance()->GetSubwindowByType(GetSubWindowId(),
            SubwindowType::TYPE_SHEET);
        CHECK_NULL_RETURN(subwindow, SheetType::SHEET_CENTER);
        windowWidth = subwindow->GetUIExtensionHostWindowRect().Width();
        windowHeight = subwindow->GetUIExtensionHostWindowRect().Height();
    }
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProperty, SheetType::SHEET_CENTER);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    auto sheetType =  SheetType::SHEET_CENTER;
    if (manager && manager->IsPcOrPadFreeMultiWindowMode()) {
        // Two in one or pad free-window mode
        if (sheetStyle.sheetType.has_value() &&
            sheetStyle.sheetType.value() == SheetType::SHEET_POPUP && sheetKey_.hasValidTargetNode) {
            return SheetType::SHEET_POPUP;
        }
        return sheetType;
    }
    if (LessOrEqual(windowWidth, SHEET_DEVICE_WIDTH_BREAKPOINT.ConvertToPx())) {
        return SheetType::SHEET_BOTTOM;
    }
    if (LessOrEqual(windowWidth, SHEET_PC_DEVICE_WIDTH_BREAKPOINT.ConvertToPx()) &&
        GreatOrEqual(windowWidth, SHEET_DEVICE_WIDTH_BREAKPOINT.ConvertToPx()) &&
        LessOrEqual(windowWidth, BOTTOM_STYLE_RATIO * windowHeight)) {
        // phone in landsapce
        if (sheetStyle.sheetType.has_value() && sheetStyle.sheetType.value() == SheetType::SHEET_BOTTOM) {
            return SheetType::SHEET_BOTTOM;
        }
        return SheetType::SHEET_BOTTOMLANDSPACE;
    }
    if (sheetStyle.sheetType.has_value()) {
        sheetType = sheetStyle.sheetType.value();
    }
    if (sheetStyle.sheetType.value() == SheetType::SHEET_POPUP && !sheetKey_.hasValidTargetNode) {
        sheetType = SheetType::SHEET_CENTER;
    }
    return sheetType;
}

void SheetPresentationPattern::InitSheetTransitionAction(float offset)
{
    auto sheetNode = GetHost();
    CHECK_NULL_VOID(sheetNode);
    auto context = sheetNode->GetRenderContext();
    CHECK_NULL_VOID(context);
    if (IsShowInSubWindowTwoInOne()) {
        context->UpdateOpacity(0.0);
        context->UpdateTransformTranslate({ 0.0f, SUBWINDOW_SHEET_TRANSLATION.ConvertToPx() + offset, 0.0f });
    } else {
        context->UpdateTransformTranslate({ 0.0f, pageHeight_, 0.0f });
    }
}

void SheetPresentationPattern::SheetTransitionAction(float offset, bool isFirstTransition, bool isTransitionIn)
{
    auto sheetNode = GetHost();
    CHECK_NULL_VOID(sheetNode);
    auto context = sheetNode->GetRenderContext();
    CHECK_NULL_VOID(context);
    if (!isTransitionIn) {
        // play sheet dismiss transition and move sheet down to out of screen
        InitSheetTransitionAction(offset);
        return;
    }
    // play sheet enter transition
    if (isFirstTransition) {
        // move sheet down to out of screen
        InitSheetTransitionAction(offset);
    } else {
        // move sheet up
        if (IsShowInSubWindowTwoInOne()) {
            context->UpdateOpacity(1.0);
        }
        context->UpdateTransformTranslate({ 0.0f, offset, 0.0f });
    }
}

SheetType SheetPresentationPattern::GetSheetTypeFromSheetManager() const
{
    SheetType sheetType = SheetType::SHEET_BOTTOM;
    auto host = GetHost();
    CHECK_NULL_RETURN(host, sheetType);
    if (!host->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_ELEVEN)) {
        return SHEET_BOTTOM;
    }
#ifdef PREVIEW
    sheetType = GetSheetType();
#else
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProperty, sheetType);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    if (sheetStyle.instanceId.has_value()) {
        return GetSheetType();
    }
    if (sheetStyle.showInSubWindow.value_or(false)) {
        return ComputeSheetTypeInSubWindow();
    }
    DeviceType deviceType = SystemProperties::GetDeviceType();
    if (sheetStyle.sheetType.has_value() && sheetStyle.sheetType.value() == SheetType::SHEET_BOTTOM) {
        return sheetStyle.bottomOffset.has_value() && deviceType == DeviceType::TWO_IN_ONE ?
            SheetType::SHEET_BOTTOM_OFFSET : SheetType::SHEET_BOTTOM;
    }
    auto pipeline = host->GetContext();
    CHECK_NULL_RETURN(pipeline, sheetType);
    auto windowManager = pipeline->GetWindowManager();
    CHECK_NULL_RETURN(windowManager, sheetType);
    auto widthBreakpoints = windowManager->GetWidthBreakpointCallback();
    auto heightBreakpoints = windowManager->GetHeightBreakpointCallback();
    auto state =
        SheetManager::GetInstance().CreateBreakPointState(widthBreakpoints, heightBreakpoints);
    sheetType = state->HandleType(sheetStyle);
    // When hasValidTargetNode is false, meaning the target node has not been provided,
    // set popup style actually takes effect as the center style.
    if (sheetType == SheetType::SHEET_POPUP && !sheetKey_.hasValidTargetNode) {
        sheetType = SheetType::SHEET_CENTER;
    }
#endif
    return sheetType;
}

SheetType SheetPresentationPattern::GetSheetType() const
{
    SheetType sheetType = SheetType::SHEET_BOTTOM;
    auto host = GetHost();
    CHECK_NULL_RETURN(host, sheetType);
    if (!host->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_ELEVEN)) {
        return SHEET_BOTTOM;
    }
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProperty, sheetType);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    if (sheetStyle.showInSubWindow.value_or(false)) {
        return ComputeSheetTypeInSubWindow();
    }
    auto pipelineContext = host->GetContext();
    CHECK_NULL_RETURN(pipelineContext, sheetType);
    auto windowGlobalRect = pipelineContext->GetDisplayWindowRectInfo();
    TAG_LOGD(AceLogTag::ACE_SHEET, "GetSheetType displayWindowRect info is : %{public}s",
        windowGlobalRect.ToString().c_str());
    // first check SHEET_CONTENT_COVER, then check SHEET_BOTTOM
    if (sheetStyle.sheetType.has_value() && sheetStyle.sheetType.value() == SheetType::SHEET_CONTENT_COVER) {
        return SheetType::SHEET_CONTENT_COVER;
    }
    DeviceType deviceType = SystemProperties::GetDeviceType();
    // only bottom when width is less than 600vp
    if ((windowGlobalRect.Width() < SHEET_DEVICE_WIDTH_BREAKPOINT.ConvertToPx()) ||
        (sheetStyle.sheetType.has_value() && sheetStyle.sheetType.value() == SheetType::SHEET_BOTTOM)) {
        return sheetStyle.bottomOffset.has_value() && deviceType == DeviceType::TWO_IN_ONE ?
            SheetType::SHEET_BOTTOM_OFFSET : SheetType::SHEET_BOTTOM;
    }
    if (sheetStyle.sheetType.has_value() && sheetStyle.sheetType.value() == SheetType::SHEET_SIDE) {
        return SheetType::SHEET_SIDE;
    }
    if (sheetThemeType_ == "auto") {
        GetSheetTypeWithAuto(sheetType);
    } else if (sheetThemeType_ == "popup") {
        GetSheetTypeWithPopup(sheetType);
    } else if (sheetThemeType_ == "center") {
        GetSheetTypeWithCenter(sheetType);
    }
    return sheetType;
}

void SheetPresentationPattern::InitSheetMode()
{
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    scrollSizeMode_ = sheetStyle.scrollSizeMode.value_or(ScrollSizeMode::FOLLOW_DETENT);
    keyboardAvoidMode_ = sheetStyle.sheetKeyboardAvoidMode.value_or(sheetObject_->GetAvoidKeyboardModeByDefault());
    sheetEffectEdge_ = sheetStyle.sheetEffectEdge.value_or(SheetEffectEdge::ALL);
}

void SheetPresentationPattern::GetSheetTypeWithAuto(SheetType& sheetType) const
{
    double rootWidth = 0.0;
    double rootHeight = 0.0;
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    if (windowSize_.has_value()) {
        rootWidth = windowSize_.value().Width();
        rootHeight = windowSize_.value().Height();
    } else {
        rootWidth = pipeline->GetRootWidth();
        rootHeight = pipeline->GetRootHeight();
    }
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_VOID(sheetTheme);
#ifdef PREVIEW
    auto container = Container::Current();
    CHECK_NULL_VOID(container);
    if (container->IsFoldable() && container->GetCurrentFoldStatus() == FoldStatus::EXPAND) {
#else
    // when big fold expand
    if (IsFoldExpand() && !sheetTheme->IsOnlyBottom()) {
#endif
        sheetType = SheetType::SHEET_CENTER;
        auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
        CHECK_NULL_VOID(layoutProperty);
        auto sheetStyle = layoutProperty->GetSheetStyleValue();
        if (AceApplicationInfo::GetInstance().GreatOrEqualTargetAPIVersion(PlatformVersion::VERSION_FOURTEEN) &&
            sheetStyle.sheetType.has_value() && sheetStyle.sheetType.value() == SheetType::SHEET_POPUP) {
            sheetType = SheetType::SHEET_POPUP;
        }
    } else {
        if (LessNotEqual(rootHeight, rootWidth)) {
            sheetType = SheetType::SHEET_BOTTOMLANDSPACE;
        } else {
            sheetType = SheetType::SHEET_BOTTOM;
        }
    }
}

void SheetPresentationPattern::GetSheetTypeWithPopup(SheetType& sheetType) const
{
    auto pipelineContext = PipelineContext::GetCurrentContext();
    double rootWidth = 0.0;
    if (windowSize_.has_value()) {
        rootWidth = windowSize_.value().Width();
    } else {
        rootWidth = PipelineContext::GetCurrentRootWidth();
    }
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
#ifdef PREVIEW
    rootWidth = pipelineContext->GetDisplayWindowRectInfo().Width();
#endif
    if (GreatOrEqual(rootWidth, SHEET_PC_DEVICE_WIDTH_BREAKPOINT.ConvertToPx())) {
        if (sheetStyle.sheetType.has_value()) {
            sheetType = sheetStyle.sheetType.value();
        } else {
            sheetType = SheetType::SHEET_POPUP;
        }
    } else if (GreatOrEqual(rootWidth, SHEET_DEVICE_WIDTH_BREAKPOINT.ConvertToPx()) &&
               LessNotEqual(rootWidth, SHEET_PC_DEVICE_WIDTH_BREAKPOINT.ConvertToPx())) {
        if (sheetStyle.sheetType.has_value()) {
            sheetType = sheetStyle.sheetType.value();
        } else {
            sheetType = SheetType::SHEET_CENTER;
        }
    } else {
        sheetType = SheetType::SHEET_BOTTOM_FREE_WINDOW;
    }
    if (sheetType == SheetType::SHEET_POPUP && !sheetKey_.hasValidTargetNode) {
        sheetType = SheetType::SHEET_CENTER;
    }
}

void SheetPresentationPattern::GetSheetTypeWithCenter(SheetType& sheetType) const
{
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    if (sheetStyle.sheetType.has_value()) {
        sheetType = sheetStyle.sheetType.value();
        return;
    }
    double rootWidth = 0.0;
    if (windowSize_.has_value()) {
        rootWidth = windowSize_.value().Width();
    } else {
        rootWidth = PipelineContext::GetCurrentRootWidth();
    }
    if (GreatOrEqual(rootWidth, SHEET_DEVICE_WIDTH_BREAKPOINT.ConvertToPx())) {
        sheetType = SheetType::SHEET_CENTER;
    } else {
        // SHEET_BOTTOMLANDSPACE need to adapt
        sheetType = SheetType::SHEET_BOTTOM;
    }
}

void SheetPresentationPattern::SetUIFirstSwitch(bool isFirstTransition, bool isNone)
{
#ifdef ENABLE_ROSEN_BACKEND
    if (!isFirstTransition) {
        return;
    }
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto rosenContext = DynamicCast<RosenRenderContext>(host->GetRenderContext());
    CHECK_NULL_VOID(rosenContext);
    rosenContext->SetUIFirstSwitch(
        isNone ? OHOS::Rosen::RSUIFirstSwitch::NONE : OHOS::Rosen::RSUIFirstSwitch::MODAL_WINDOW_CLOSE);
#endif
}

void SheetPresentationPattern::SetWindowUseImplicitAnimation(FrameNode* sheetNode, bool useImplicit)
{
    CHECK_NULL_VOID(sheetNode);
    auto layoutProperty = sheetNode->GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    if (sheetStyle.showInSubWindow.value_or(false)) {
        TAG_LOGD(AceLogTag::ACE_SHEET, "UseImplicitAnimation ShowInSubWindow");
        return;
    }
    auto pipelineContext = sheetNode->GetContext();
    CHECK_NULL_VOID(pipelineContext);
    auto windowManager = pipelineContext->GetWindowManager();
    CHECK_NULL_VOID(windowManager);
    TAG_LOGI(AceLogTag::ACE_SHEET, "WindowUseImplicitAnimation: %{public}d", useImplicit);
    windowManager->SetWindowUseImplicitAnimation(useImplicit);
}

void SheetPresentationPattern::BubbleStyleSheetTransition(bool isTransitionIn)
{
    auto host = this->GetHost();
    CHECK_NULL_VOID(host);
    if (!isTransitionIn) {
        const auto& overlayManager = GetOverlayManager();
        CHECK_NULL_VOID(overlayManager);
        auto maskNode = overlayManager->GetSheetMask(host);
        if (maskNode) {
            overlayManager->PlaySheetMaskTransition(maskNode, host, false);
        }
        StartOffsetExitingAnimation();
        StartAlphaExitingAnimation(
            [weakNode = AceType::WeakClaim(AceType::RawPtr(host)), weakPattern = AceType::WeakClaim(this)]() {
                auto node = weakNode.Upgrade();
                CHECK_NULL_VOID(node);
                auto pattern = weakPattern.Upgrade();
                CHECK_NULL_VOID(pattern);
                const auto& overlayManager = pattern->GetOverlayManager();
                CHECK_NULL_VOID(overlayManager);
                overlayManager->FireAutoSave(node);
                pattern->OnDisappear();
                overlayManager->RemoveSheet(node);;
                pattern->FireCallback("false");
            });
        overlayManager->CleanSheet(host, GetSheetKey());
    }
}

void SheetPresentationPattern::StartOffsetEnteringAnimation()
{
    AnimationOption optionPosition;
    optionPosition.SetDuration(SHEET_ENTRY_ANIMATION_DURATION);
    optionPosition.SetCurve(Curves::FRICTION);
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContextRefPtr();
    AnimationUtils::Animate(
        optionPosition,
        [weak = WeakClaim(this)]() {
            auto pattern = weak.Upgrade();
            CHECK_NULL_VOID(pattern);
            auto renderContext = pattern->GetRenderContext();
            CHECK_NULL_VOID(renderContext);
            renderContext->UpdateTransformTranslate({ 0.0f, Dimension(pattern->sheetOffsetY_), 0.0f });
        },
        nullptr, nullptr, pipeline);
}

void SheetPresentationPattern::StartAlphaEnteringAnimation(std::function<void()> finish)
{
    AnimationOption optionAlpha;
    optionAlpha.SetDuration(SHEET_ENTRY_ANIMATION_DURATION);
    optionAlpha.SetCurve(Curves::SHARP);
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContextRefPtr();
    AnimationUtils::Animate(
        optionAlpha,
        [weak = WeakClaim(this)]() {
            auto pattern = weak.Upgrade();
            CHECK_NULL_VOID(pattern);
            auto renderContext = pattern->GetRenderContext();
            CHECK_NULL_VOID(renderContext);
            renderContext->UpdateOpacity(SHEET_VISIABLE_ALPHA);
        },
        finish, nullptr, pipeline);
}

void SheetPresentationPattern::StartOffsetExitingAnimation()
{
    AnimationOption optionPosition;
    optionPosition.SetDuration(SHEET_EXIT_ANIMATION_DURATION);
    optionPosition.SetCurve(Curves::FRICTION);
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContextRefPtr();
    AnimationUtils::Animate(
        optionPosition,
        [weak = WeakClaim(this)]() {
            auto pattern = weak.Upgrade();
            CHECK_NULL_VOID(pattern);
            auto renderContext = pattern->GetRenderContext();
            CHECK_NULL_VOID(renderContext);
            renderContext->UpdateTransformTranslate(
                { 0.0f, Dimension(pattern->sheetOffsetY_ - SHEET_INVISIABLE_OFFSET), 0.0f });
        },
        nullptr, nullptr, pipeline);
}

void SheetPresentationPattern::StartAlphaExitingAnimation(std::function<void()> finish)
{
    AnimationOption optionAlpha;
    optionAlpha.SetDuration(SHEET_EXIT_ANIMATION_DURATION);
    optionAlpha.SetCurve(Curves::SHARP);
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContextRefPtr();
    AnimationUtils::Animate(
        optionAlpha,
        [weak = WeakClaim(this)]() {
            auto pattern = weak.Upgrade();
            CHECK_NULL_VOID(pattern);
            auto renderContext = pattern->GetRenderContext();
            CHECK_NULL_VOID(renderContext);
            renderContext->UpdateOpacity(SHEET_INVISIABLE_ALPHA);
        },
        finish, nullptr, pipeline);
}

RefPtr<RenderContext> SheetPresentationPattern::GetRenderContext()
{
    auto frameNode = GetHost();
    CHECK_NULL_RETURN(frameNode, nullptr);
    return frameNode->GetRenderContext();
}

bool SheetPresentationPattern::PostTask(const TaskExecutor::Task& task, const std::string& name)
{
    auto pipeline = PipelineBase::GetCurrentContext();
    CHECK_NULL_RETURN(pipeline, false);
    auto taskExecutor = pipeline->GetTaskExecutor();
    CHECK_NULL_RETURN(taskExecutor, false);
    return taskExecutor->PostTask(task, TaskExecutor::TaskType::UI, name);
}

void SheetPresentationPattern::ResetToInvisible()
{
    auto renderContext = GetRenderContext();
    CHECK_NULL_VOID(renderContext);
    renderContext->UpdateOpacity(SHEET_INVISIABLE_ALPHA);
    renderContext->UpdateTransformTranslate({ 0.0f, Dimension(sheetOffsetY_ - SHEET_INVISIABLE_OFFSET), 0.0f });
}

bool SheetPresentationPattern::IsFoldExpand() const
{
    bool isExpand = false;
    auto container = Container::CurrentSafelyWithCheck();
    CHECK_NULL_RETURN(container, false);
    auto foldStatus = container->GetCurrentFoldStatus();
    isExpand = foldStatus != FoldStatus::FOLDED && foldStatus != FoldStatus::UNKNOWN;
    if (isExpand) {
        TAG_LOGD(AceLogTag::ACE_SHEET, "Get Fold status IsFoldExpand is true");
        return true;
    } else {
        return false;
    }
}

void SheetPresentationPattern::ChangeSheetHeight(float height)
{
    if (!NearEqual(height_, height)) {
        isDirectionUp_ = GreatNotEqual(height, height_);
        height_ = height;
        SetCurrentHeightToOverlay(height_);
    }
}

void SheetPresentationPattern::StartSheetTransitionAnimation(
    const AnimationOption& option, bool isTransitionIn, float offset)
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto context = host->GetRenderContext();
    CHECK_NULL_VOID(context);
    isAnimationProcess_ = true;
    auto sheetPattern = host->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(sheetPattern);
    auto pipeline = host->GetContextRefPtr();
    if (isTransitionIn) {
        HandleDragEndAccessibilityEvent();
        animation_ = AnimationUtils::StartAnimation(option,
            sheetObject_->GetSheetAnimationEvent(isTransitionIn, offset), option.GetOnFinishEvent(), nullptr, pipeline);
        SetBottomStyleHotAreaInSubwindow();
    } else {
        StopModifySheetTransition();
        animation_ = AnimationUtils::StartAnimation(option,
            sheetObject_->GetSheetAnimationEvent(isTransitionIn, offset), option.GetOnFinishEvent(), nullptr, pipeline);
        const auto& overlayManager = GetOverlayManager();
        CHECK_NULL_VOID(overlayManager);
        overlayManager->CleanSheet(host, GetSheetKey());
    }
}

void SheetPresentationPattern::DismissSheetShadow(const RefPtr<RenderContext>& context)
{
    auto shadow = context->GetBackShadow();
    if (!shadow.has_value()) {
        shadow = Shadow::CreateShadow(ShadowStyle::None);
    }
    auto color = shadow->GetColor();
    auto newColor = color.ChangeAlpha(0);
    shadow->SetColor(newColor);
    context->UpdateBackShadow(shadow.value());
}

void SheetPresentationPattern::ClipSheetNode()
{
    sheetObject_->ClipSheetNode();
}

bool SheetPresentationPattern::IsWindowSizeChangedWithUndefinedReason(
    int32_t width, int32_t height, WindowSizeChangeReason type)
{
    bool isWindowChanged = false;
    if (windowSize_.has_value()) {
        isWindowChanged = (type == WindowSizeChangeReason::UNDEFINED &&
                           (windowSize_->Width() != width || windowSize_->Height() != height));
    }
    return isWindowChanged;
}

void SheetPresentationPattern::OnWindowSizeChanged(int32_t width, int32_t height, WindowSizeChangeReason type)
{
    TAG_LOGD(AceLogTag::ACE_SHEET, "Sheet WindowSizeChangeReason type is: %{public}d", type);
    ACE_SCOPED_TRACE("Sheet OnWindowSizeChanged: WindowSizeChangeReason type is: %d", type);
    if (type == WindowSizeChangeReason::DRAG_START || type == WindowSizeChangeReason::DRAG_END ||
        type == WindowSizeChangeReason::DRAG_MOVE) {
        return;
    }
    auto sheetType = GetSheetType();
    if ((type == WindowSizeChangeReason::ROTATION) &&
        ((sheetType == SheetType::SHEET_BOTTOM) || (sheetType == SheetType::SHEET_BOTTOMLANDSPACE) ||
         (sheetType == SheetType::SHEET_BOTTOM_OFFSET))) {
        windowRotate_ = true;
        SetColumnMinSize(true);
        // Before rotation, reset to the initial mode sheet ratio of the current vertical or horizontal screen
        // It's actually a state where the soft keyboard is not pulled up
        if (isScrolling_) {
            resizeDecreasedHeight_ = 0.f;
            ScrollTo(.0f);
        }
    }
    if (IsWindowSizeChangedWithUndefinedReason(width, height, type)) {
        windowChanged_ = true;
    }
    windowSize_ = SizeT<int32_t>(width, height);
    if (type == WindowSizeChangeReason::ROTATION || type == WindowSizeChangeReason::DRAG ||
        type == WindowSizeChangeReason::RESIZE) {
        windowChanged_ = true;
    }

    if (type == WindowSizeChangeReason::ROTATION && sheetType == SheetType::SHEET_CENTER) {
        auto recoverTask = [weak = WeakClaim(this), id = Container::CurrentId()] () {
            ContainerScope scope(id);
            auto pattern = weak.Upgrade();
            CHECK_NULL_VOID(pattern);
            pattern->RecoverHalfFoldOrAvoidStatus();
        };
        PostTask(recoverTask, "ArkUISheetHalfFoldStatusSwitch");
    }

    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipelineContext = host->GetContext();
    CHECK_NULL_VOID(pipelineContext);
    UpdateSheetWhenSheetTypeChanged();
    auto windowManager = pipelineContext->GetWindowManager();
    if (windowManager && windowManager->GetWindowMode() == WindowMode::WINDOW_MODE_FLOATING) {
        host->MarkDirtyNode(PROPERTY_UPDATE_LAYOUT);
    }
}

void SheetPresentationPattern::TranslateTo(float height)
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto context = host->GetRenderContext();
    CHECK_NULL_VOID(context);
    context->UpdateTransformTranslate({ 0.0f, height, 0.0f });
}

void SheetPresentationPattern::ScrollTo(float height)
{
    // height = 0 or height > 0
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto scroll = GetSheetScrollNode();
    CHECK_NULL_VOID(scroll);
    auto scrollPattern = scroll->GetPattern<ScrollPattern>();
    CHECK_NULL_VOID(scrollPattern);
    auto layoutProp = scrollPattern->GetLayoutProperty<ScrollLayoutProperty>();
    CHECK_NULL_VOID(layoutProp);
    auto geometryNode = scroll->GetGeometryNode();
    CHECK_NULL_VOID(geometryNode);
    // height > 0, Scroll will reduce height, and become scrolling.
    isScrolling_ = height > 0;
    SetColumnMinSize(!isScrolling_);
    if (!AdditionalScrollTo(scroll, height)) {
        scrollHeight_ = height;
        float maxScrollDecreaseHeight = scrollHeight_;
        float maxAvoidSize = keyboardHeight_ - (sheetType_ == SheetType::SHEET_CENTER ? height_ - centerHeight_ : 0.f);
        auto pipelineContext = host->GetContext();
        CHECK_NULL_VOID(pipelineContext);
        auto useCaretAvoidMode = pipelineContext->UsingCaretAvoidMode();
        /*
         * when the screen rotates from portrait to landscape, and the sheet needs to avoid caret twice,
         * there is a condition that, the caret position that does not exceed the height of sheet in portrait mode,
         * may be exceed the height of sheet in landscape mode. In that case,
         * the distance to avoid caret may exceed as well. To keep bindSheet display normally,
         * we need to obtain the minimum content height and then the avoidance is made.
         */
        if (useCaretAvoidMode && NonNegative(maxAvoidSize) && NonNegative(maxAvoidSize - sheetHeightUp_) &&
            maxScrollDecreaseHeight > maxAvoidSize - sheetHeightUp_) {
            maxScrollDecreaseHeight = maxAvoidSize - sheetHeightUp_;
        }
        layoutProp->UpdateUserDefinedIdealSize(CalcSize(std::nullopt,
            CalcLength(GetScrollHeight() - maxScrollDecreaseHeight)));
        auto curScrollOffset = (useCaretAvoidMode && Positive(height)) ? scrollPattern->GetTotalOffset() : 0.f;
        scrollPattern->UpdateCurrentOffset(-height + curScrollOffset, SCROLL_FROM_JUMP);
    }
    scroll->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
}

bool SheetPresentationPattern::AdditionalScrollTo(const RefPtr<FrameNode>& scroll, float height)
{
    if (NonPositive(height)) {
        return false;
    }
    // If ScrollHeight is larger than childHeight
    // there will be a scene that is still larger than childHeight after reducing Scrollheight to moving sheet up
    // At this point, even if JumpToPosition is negative, the Scroll will still not to scroll
    auto buildContent = GetFirstFrameNodeOfBuilder();
    CHECK_NULL_RETURN(buildContent, false);
    auto scrollHeight = scroll->GetGeometryNode() ? scroll->GetGeometryNode()->GetFrameSize().Height() : .0f;
    auto host = GetHost();
    CHECK_NULL_RETURN(host, false);
    auto pipelineContext = host->GetContext();
    CHECK_NULL_RETURN(pipelineContext, false);
    auto useCaretAvoidMode = pipelineContext->UsingCaretAvoidMode();
    if (useCaretAvoidMode) {
        scrollHeight = GetScrollHeight();
    }
    auto childHeight = buildContent->GetGeometryNode() ? buildContent->GetGeometryNode()->GetFrameSize().Height() : .0f;
    if (scrollHeight <= childHeight) {
        return false;
    }
    auto layoutProp = scroll->GetLayoutProperty<ScrollLayoutProperty>();
    CHECK_NULL_RETURN(layoutProp, false);
    auto geometryNode = scroll->GetGeometryNode();
    CHECK_NULL_RETURN(geometryNode, false);
    auto scrollPattern = scroll->GetPattern<ScrollPattern>();
    CHECK_NULL_RETURN(scrollPattern, false);
    // Scroll first shrinks to the same size as childHeight, then reduces the height to allow it to scroll
    scrollHeight_ = scrollHeight - childHeight + height;
    layoutProp->UpdateUserDefinedIdealSize(
        CalcSize(std::nullopt, CalcLength(GetScrollHeight() - (scrollHeight - childHeight + height))));
    // And then scroll move the content with '-height' offset
    auto curScrollOffset = (useCaretAvoidMode && Positive(height)) ? scrollPattern->GetTotalOffset() : 0.f;
    scrollPattern->UpdateCurrentOffset(-height + curScrollOffset, SCROLL_FROM_JUMP);
    return true;
}

void SheetPresentationPattern::SetColumnMinSize(bool reset)
{
    auto buildContent = GetFirstFrameNodeOfBuilder();
    CHECK_NULL_VOID(buildContent);
    auto geometryNode = buildContent->GetGeometryNode();
    CHECK_NULL_VOID(geometryNode);
    auto props = buildContent->GetLayoutProperty<LayoutProperty>();
    CHECK_NULL_VOID(props);
    if (reset) {
        props->ResetCalcMinSize();
        return;
    }
    props->UpdateCalcMinSize(CalcSize(std::nullopt, CalcLength(builderHeight_)));
}

void SheetPresentationPattern::CalculateSheetRadius(BorderRadiusProperty& sheetRadius)
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto geometryNode = host->GetGeometryNode();
    CHECK_NULL_VOID(geometryNode);
    auto sheetSize = geometryNode->GetFrameSize();
    auto layoutProperty = host->GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    if (sheetSize.IsPositive()) {
        CalculateAloneSheetRadius(sheetRadius.radiusTopLeft, sheetStyle.radius->radiusTopLeft);
        CalculateAloneSheetRadius(sheetRadius.radiusTopRight, sheetStyle.radius->radiusTopRight);
        CalculateAloneSheetRadius(sheetRadius.radiusBottomLeft, sheetStyle.radius->radiusBottomLeft);
        CalculateAloneSheetRadius(sheetRadius.radiusBottomRight, sheetStyle.radius->radiusBottomRight);
    }
}

void SheetPresentationPattern::CalculateAloneSheetRadius(
    std::optional<Dimension>& sheetRadius, const std::optional<Dimension>& sheetStyleRadius)
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto geometryNode = host->GetGeometryNode();
    CHECK_NULL_VOID(geometryNode);
    auto sheetSize = geometryNode->GetFrameSize();
    float half = 0.5f;
    if (sheetStyleRadius.has_value() && GreatOrEqual(sheetStyleRadius->Value(), 0.0f)) {
        if (sheetStyleRadius->Unit() == DimensionUnit::PERCENT) {
            sheetRadius = Dimension(sheetStyleRadius->Value() * sheetSize.Width());
        } else {
            sheetRadius = sheetStyleRadius;
        }
    }
    // The maximum value of radius is half the width of the page.
    if (sheetSize.Width() * half < sheetRadius->ConvertToPx()) {
        sheetRadius = Dimension(sheetSize.Width() * half);
    }
}

std::string SheetPresentationPattern::GetPopupStyleSheetClipPath(
    const SizeF& sheetSize, const BorderRadiusProperty& sheetRadius)
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, "");
    if (host->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_EIGHTEEN)) {
        return GetPopupStyleSheetClipPathNew(sheetSize, sheetRadius);
    }
    auto radiusTopLeft = sheetRadius.radiusTopLeft->ConvertToPx();
    auto radiusTopRight = sheetRadius.radiusTopRight->ConvertToPx();
    auto radiusBottomRight = sheetRadius.radiusBottomRight->ConvertToPx();
    auto radiusBottomLeft = sheetRadius.radiusBottomLeft->ConvertToPx();
    std::string path = MoveTo(0.0f, SHEET_ARROW_HEIGHT.ConvertToPx() + radiusTopLeft);
    path += ArcTo(radiusTopLeft, radiusTopLeft, 0.0f, 0, radiusTopLeft, SHEET_ARROW_HEIGHT.ConvertToPx());
    path +=
        LineTo(arrowOffset_.GetX() - ARROW_VERTICAL_P1_OFFSET_X.ConvertToPx(), SHEET_ARROW_HEIGHT.ConvertToPx()); // P1
    path += LineTo(arrowOffset_.GetX() - ARROW_VERTICAL_P2_OFFSET_X.ConvertToPx(),
        SHEET_ARROW_HEIGHT.ConvertToPx() - ARROW_VERTICAL_P2_OFFSET_Y.ConvertToPx()); // P2
    path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
        arrowOffset_.GetX() + ARROW_VERTICAL_P4_OFFSET_X.ConvertToPx(),
        SHEET_ARROW_HEIGHT.ConvertToPx() - ARROW_VERTICAL_P4_OFFSET_Y.ConvertToPx()); // P4
    path +=
        LineTo(arrowOffset_.GetX() + ARROW_VERTICAL_P5_OFFSET_X.ConvertToPx(), SHEET_ARROW_HEIGHT.ConvertToPx()); // P5
    path += LineTo(sheetSize.Width() - radiusTopRight, SHEET_ARROW_HEIGHT.ConvertToPx());
    path += ArcTo(
        radiusTopRight, radiusTopRight, 0.0f, 0, sheetSize.Width(), SHEET_ARROW_HEIGHT.ConvertToPx() + radiusTopRight);
    path += LineTo(sheetSize.Width(), sheetSize.Height() - radiusBottomRight);
    path +=
        ArcTo(radiusBottomRight, radiusBottomRight, 0.0f, 0, sheetSize.Width() - radiusBottomRight, sheetSize.Height());
    path += LineTo(radiusBottomLeft, sheetSize.Height());
    path += ArcTo(radiusBottomLeft, radiusBottomLeft, 0.0f, 0, 0.0f, sheetSize.Height() - radiusBottomLeft);
    return path + "Z";
}

std::string SheetPresentationPattern::GetCenterStyleSheetClipPath(SizeF sheetSize, Dimension sheetRadius)
{
    std::string path = MoveTo(0.0f, sheetRadius.ConvertToPx());
    path += ArcTo(sheetRadius.ConvertToPx(), sheetRadius.ConvertToPx(), 0.0f, 0, sheetRadius.ConvertToPx(), 0.0f);
    path += LineTo(sheetSize.Width() - sheetRadius.ConvertToPx(), 0.0f);
    path += ArcTo(
        sheetRadius.ConvertToPx(), sheetRadius.ConvertToPx(), 0.0f, 0, sheetSize.Width(), sheetRadius.ConvertToPx());
    path += LineTo(sheetSize.Width(), sheetSize.Height() - sheetRadius.ConvertToPx());
    path += ArcTo(sheetRadius.ConvertToPx(), sheetRadius.ConvertToPx(), 0.0f, 0,
        sheetSize.Width() - sheetRadius.ConvertToPx(), sheetSize.Height());
    path += LineTo(sheetRadius.ConvertToPx(), sheetSize.Height());
    path += ArcTo(sheetRadius.ConvertToPx(), sheetRadius.ConvertToPx(), 0.0f, 0, 0.0f,
        sheetSize.Height() - sheetRadius.ConvertToPx());
    return path + "Z";
}

std::string SheetPresentationPattern::GetBottomStyleSheetClipPath(SizeF sheetSize, Dimension sheetRadius)
{
    std::string path = MoveTo(0.0f, sheetRadius.ConvertToPx());
    path += ArcTo(sheetRadius.ConvertToPx(), sheetRadius.ConvertToPx(), 0.0f, 0, sheetRadius.ConvertToPx(), 0.0f);
    path += LineTo(sheetSize.Width() - sheetRadius.ConvertToPx(), 0.0f);
    path += ArcTo(
        sheetRadius.ConvertToPx(), sheetRadius.ConvertToPx(), 0.0f, 0, sheetSize.Width(), sheetRadius.ConvertToPx());
    path += LineTo(sheetSize.Width(), sheetSize.Height());
    path += LineTo(0.0f, sheetSize.Height());
    return path + "Z";
}

std::string SheetPresentationPattern::MoveTo(double x, double y)
{
    return "M" + std::to_string(x) + " " + std::to_string(y) + " ";
}

std::string SheetPresentationPattern::LineTo(double x, double y)
{
    return "L" + std::to_string(x) + " " + std::to_string(y) + " ";
}

std::string SheetPresentationPattern::ArcTo(double rx, double ry, double rotation, int32_t arc_flag, double x, double y)
{
    int32_t sweep_flag = 1;
    return "A" + std::to_string(rx) + " " + std::to_string(ry) + " " + std::to_string(rotation) + " " +
           std::to_string(arc_flag) + " " + std::to_string(sweep_flag) + " " + std::to_string(x) + " " +
           std::to_string(y) + " ";
}

float SheetPresentationPattern::GetFitContentHeight()
{
    auto builderNode = GetFirstFrameNodeOfBuilder();
    CHECK_NULL_RETURN(builderNode, 0.0f);
    auto builderGeometryNode = builderNode->GetGeometryNode();
    return builderGeometryNode->GetMarginFrameSize().Height() + GetTitleBuilderHeight();
}

float SheetPresentationPattern::GetTitleBuilderHeight() const
{
    auto titleColumn = GetTitleBuilderNode();
    CHECK_NULL_RETURN(titleColumn, 0.0f);
    auto titleGeometryNode = titleColumn->GetGeometryNode();
    CHECK_NULL_RETURN(titleGeometryNode, 0.0f);
    OffsetF titleOffset = titleGeometryNode->GetMarginFrameOffset();
    float titleOffsetY = titleOffset.GetY();
    float titleHeight = Positive(
        titleGeometryNode->GetFrameSize().Height()) ? titleGeometryNode->GetFrameSize().Height() : 0.0f;
    float titleBottomY = titleOffsetY + titleHeight;
    return titleBottomY;
}

RefPtr<OverlayManager> SheetPresentationPattern::GetOverlayManager()
{
    const auto& layoutProp = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProp, nullptr);
    auto showInPage = layoutProp->GetSheetStyleValue(SheetStyle()).showInPage.value_or(false);

    if (layoutProp->GetSheetStyleValue(SheetStyle()).showInSubWindow.value_or(false)) {
        auto aceContainer = AceEngine::Get().GetContainer(GetSubWindowId());
        CHECK_NULL_RETURN(aceContainer, nullptr);
        auto context = DynamicCast<NG::PipelineContext>(aceContainer->GetPipelineContext());
        CHECK_NULL_RETURN(context, nullptr);
        auto overlayManager = context->GetOverlayManager();
        return overlayManager;
    }
    if (!showInPage) {
        auto host = GetHost();
        CHECK_NULL_RETURN(host, nullptr);
        auto pipeline = host->GetContext();
        CHECK_NULL_RETURN(pipeline, nullptr);
        return pipeline->GetOverlayManager();
    }
    auto host = GetHost();
    CHECK_NULL_RETURN(host, nullptr);
    auto sheetWrapper = host->GetParent();
    CHECK_NULL_RETURN(sheetWrapper, nullptr);
    auto node = AceType::DynamicCast<FrameNode>(sheetWrapper->GetParent());
    CHECK_NULL_RETURN(node, nullptr);
    RefPtr<OverlayManager> overlay;
    if (node->GetTag() == V2::PAGE_ETS_TAG) {
        auto pattern = node->GetPattern<PagePattern>();
        CHECK_NULL_RETURN(pattern, nullptr);
        overlay = pattern->GetOverlayManager();
    } else if (node->GetTag() == V2::NAVDESTINATION_VIEW_ETS_TAG) {
        auto pattern = node->GetPattern<NavDestinationPattern>();
        CHECK_NULL_RETURN(pattern, nullptr);
        overlay = pattern->GetOverlayManager();
    }
    if (!overlay) {
        auto overlayManager = overlayManager_.Upgrade();
        overlay = overlayManager;
    }
    return overlay;
}

RefPtr<FrameNode> SheetPresentationPattern::GetFirstFrameNodeOfBuilder() const
{
    auto scrollNode = GetSheetScrollNode();
    CHECK_NULL_RETURN(scrollNode, nullptr);
    auto buildNode = scrollNode->GetChildAtIndex(0);
    CHECK_NULL_RETURN(buildNode, nullptr);
    return AceType::DynamicCast<FrameNode>(buildNode->GetFrameChildByIndex(0, true));
}

void SheetPresentationPattern::GetBuilderInitHeight()
{
    auto buildContent = GetFirstFrameNodeOfBuilder();
    CHECK_NULL_VOID(buildContent);
    auto geometryNode = buildContent->GetGeometryNode();
    CHECK_NULL_VOID(geometryNode);
    builderHeight_ = geometryNode->GetFrameSize().Height();
}

RefPtr<FrameNode> SheetPresentationPattern::GetOverlayRoot()
{
    const auto& layoutProp = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProp, nullptr);
    auto showInPage = layoutProp->GetSheetStyleValue(SheetStyle()).showInPage.value_or(false);
    auto host = GetHost();
    CHECK_NULL_RETURN(host, nullptr);
    if (!showInPage) {
        auto pipelineContext = host->GetContext();
        CHECK_NULL_RETURN(pipelineContext, nullptr);
        auto overlay = pipelineContext->GetOverlayManager();
        CHECK_NULL_RETURN(overlay, nullptr);
        return AceType::DynamicCast<FrameNode>(overlay->GetRootNode().Upgrade());
    }
    auto sheetWrapper = host->GetParent();
    CHECK_NULL_RETURN(sheetWrapper, nullptr);
    return AceType::DynamicCast<FrameNode>(sheetWrapper->GetParent());
}

float SheetPresentationPattern::GetRootOffsetYToWindow()
{
    const auto& layoutProp = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProp, .0f);
    const auto& showInPage = layoutProp->GetSheetStyleValue(SheetStyle()).showInPage.value_or(false);
    CHECK_NULL_RETURN(showInPage, .0f);
    const auto& overlayNode = GetOverlayRoot();
    CHECK_NULL_RETURN(overlayNode, .0f);
    auto parertOffset = overlayNode->GetOffsetRelativeToWindow();
    TAG_LOGD(AceLogTag::ACE_OVERLAY, "PageLevel Node's offset to window: %{public}s", parertOffset.ToString().c_str());
    return parertOffset.GetY();
}

void SheetPresentationPattern::DumpAdvanceInfo()
{
    DumpLog::GetInstance().AddDesc("------------------------------------------");
    DumpLog::GetInstance().AddDesc(
        "TargetId: " + std::to_string(static_cast<int32_t>(targetId_)) + " , TargetTag : " + targetTag_);
    DumpLog::GetInstance().AddDesc("------------ SheetPage Pattern : ");
    DumpLog::GetInstance().AddDesc(
        std::string("SheetType: ").append(std::to_string(static_cast<int32_t>(GetSheetTypeNoProcess()))));
    DumpLog::GetInstance().AddDesc(std::string("SheetPage Node Height: ").append(std::to_string(centerHeight_)));
    DumpLog::GetInstance().AddDesc(
        std::string("Sheet Height [start from the bottom, KeyboardHeight = 0]: ").append(std::to_string(height_)));
    DumpLog::GetInstance().AddDesc(
        std::string("SheetMaxHeight [start from the bottom, pageHeight - sheetTopSafeArea]: ")
            .append(std::to_string(sheetMaxHeight_)));
    DumpLog::GetInstance().AddDesc(std::string("Page Height: ").append(std::to_string(pageHeight_)));
    DumpLog::GetInstance().AddDesc(
        std::string("StatusBar Height [current sheetType needed]: ").append(std::to_string(sheetTopSafeArea_)));
    DumpLog::GetInstance().AddDesc(std::string("PopupSheet OffsetX: ").append(std::to_string(sheetOffsetX_)));
    DumpLog::GetInstance().AddDesc(std::string("PopupSheet OffsetY: ").append(std::to_string(sheetOffsetY_)));
    DumpLog::GetInstance().AddDesc(std::string("SheetMaxWidth: ").append(std::to_string(sheetMaxWidth_)));
    DumpLog::GetInstance().AddDesc(std::string("FitContent Height: ").append(std::to_string(sheetFitContentHeight_)));
    DumpLog::GetInstance().AddDesc("SheetThemeType: " + sheetThemeType_);
    DumpLog::GetInstance().AddDesc(std::string("currentOffset: ").append(std::to_string(currentOffset_)));
    DumpLog::GetInstance().AddDesc("------------");
    DumpLog::GetInstance().AddDesc(
        std::string("Height ScrollTo [KeyboardHeight > 0, and is scrolling]: ").append(std::to_string(-scrollHeight_)));
    DumpLog::GetInstance().AddDesc(std::string("KeyboardHeight: ").append(std::to_string(keyboardHeight_)));
    DumpLog::GetInstance().AddDesc(std::string("is scrolling: ").append(isScrolling_ ? "true" : "false"));
    DumpLog::GetInstance().AddDesc(std::string("SheetHeightUp[sheet offset to move up when avoiding keyboard]: ")
                                       .append(std::to_string(sheetHeightUp_)));
    DumpLog::GetInstance().AddDesc("------------");
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    DumpLog::GetInstance().AddDesc(
        std::string("height: ").append(sheetStyle.sheetHeight.height.has_value() ?
        sheetStyle.sheetHeight.height->ToString() : "None"));
    DumpLog::GetInstance().AddDesc(
        ("sheetMode: ") + (sheetStyle.sheetHeight.sheetMode.has_value()
                                  ? std::to_string(static_cast<int32_t>(sheetStyle.sheetHeight.sheetMode.value()))
                                  : "None"));
    DumpLog::GetInstance().AddDesc(std::string("detents' Size: ").append(std::to_string(sheetStyle.detents.size())));
    DumpLog::GetInstance().AddDesc(std::string("IsShouldDismiss: ").append(shouldDismiss_ ? "true" : "false"));
}

void SheetPresentationPattern::FireOnHeightDidChange()
{
    auto height = 0.0f;
    if (!IsSheetBottomStyle()) {
        height = centerHeight_;
    } else {
        height = height_;
    }
    if (NearEqual(preDidHeight_, height)) {
        return;
    }
    OnHeightDidChange(height);
    preDidHeight_ = height;
}

void SheetPresentationPattern::FireOnDetentsDidChange(float height)
{
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    if (!IsSheetBottomStyle() || NearEqual(preDetentsHeight_, height) ||
        LessOrEqual(sheetStyle.detents.size(), 0)) {
        return;
    }
    OnDetentsDidChange(height);
    preDetentsHeight_ = height;
}

void SheetPresentationPattern::FireOnWidthDidChange()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto sheetGeo = host->GetGeometryNode();
    CHECK_NULL_VOID(sheetGeo);
    auto width = sheetGeo->GetFrameSize().Width();
    if (NearEqual(preWidth_, width)) {
        return;
    }
    onWidthDidChange(width);
    preWidth_ = width;
}

void SheetPresentationPattern::FireOnTypeDidChange()
{
    auto sheetType = sheetType_;
    if (IsSheetBottomStyle() || sheetType == SheetType::SHEET_BOTTOM_OFFSET) {
        sheetType = SheetType::SHEET_BOTTOM;
    }
    if (preType_ == sheetType) {
        return;
    }
    onTypeDidChange(sheetType);
    preType_ = sheetType;
}

bool SheetPresentationPattern::IsScrollOutOfBoundary()
{
    auto scrollNode = GetSheetScrollNode();
    CHECK_NULL_RETURN(scrollNode, false);
    auto scrollPattern = scrollNode->GetPattern<ScrollPattern>();
    CHECK_NULL_RETURN(scrollPattern, false);
    return scrollPattern->OutBoundaryCallback();
}

void SheetPresentationPattern::OnScrollStartRecursive(
    WeakPtr<NestableScrollContainer> child, float position, float velocity)
{
    return sheetObject_->OnScrollStartRecursive(position, velocity);
}

ScrollResult SheetPresentationPattern::HandleScroll(float scrollOffset, int32_t source, NestedState state,
    float velocity)
{
    return sheetObject_->HandleScroll(scrollOffset, source, state, velocity);
}

void SheetPresentationPattern::OnScrollEndRecursive(const std::optional<float>& velocity)
{
    sheetObject_->OnScrollEndRecursive(velocity);
}

bool SheetPresentationPattern::HandleScrollVelocity(float velocity, const RefPtr<NestableScrollContainer>& child)
{
    return sheetObject_->HandleScrollVelocity(velocity);
}

bool SheetPresentationPattern::IsTypeNeedAvoidAiBar()
{
    auto overlay = GetOverlayManager();
    auto layoutProp = GetLayoutProperty<SheetPresentationProperty>();
    if (overlay && overlay->IsRootExpansive() &&
        layoutProp->GetSheetStyleValue(SheetStyle()).showInPage.value_or(false)) {
        return false;
    }
    return sheetType_ == SheetType::SHEET_BOTTOM || sheetType_ == SheetType::SHEET_BOTTOMLANDSPACE ||
           sheetType_ == SheetType::SHEET_BOTTOM_OFFSET || sheetType_ == SheetType::SHEET_SIDE;
}

void SheetPresentationPattern::IsNeedPlayTransition(const SheetStyle& inputStyle)
{
    isPlayTransition_ = false;
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto preStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    if (preStyle.sheetHeight.height != inputStyle.sheetHeight.height) {
        isPlayTransition_ = true;
        return;
    }
    if (preStyle.detents != inputStyle.detents) {
        isPlayTransition_ = true;
        return;
    }
    if (preStyle.sheetHeight.sheetMode != inputStyle.sheetHeight.sheetMode) {
        isPlayTransition_ = true;
        return;
    }
    isPlayTransition_ = UpdateIndexByDetentSelection(inputStyle, false) || isPlayTransition_;
}

bool SheetPresentationPattern::UpdateIndexByDetentSelection(const SheetStyle& inputStyle, bool isFirstTransition)
{
    if (!inputStyle.detentSelection.has_value() || inputStyle.detents.size() == 0) {
        // when input detentSelection or detent selection is invalid
        return false;
    }
    auto selection = inputStyle.detentSelection.value();
    if ((selection.sheetMode.has_value() && selection.sheetMode.value() == NG::SheetMode::AUTO) ||
        (selection.height.has_value() && selection.height.value().IsNegative())) {
        return false;
    }
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProperty, false);
    auto preStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    if (!isFirstTransition && preStyle.detentSelection == inputStyle.detentSelection) {
        // only when sheet is first pulled up or pre-detents equal to current detents, otherwise false
        return false;
    }
    for (uint32_t index = 0; index < inputStyle.detents.size(); index++) {
        if (inputStyle.detents[index] == inputStyle.detentSelection.value()) {
            detentsFinalIndex_ = index;
            TAG_LOGI(AceLogTag::ACE_SHEET, "find detent selection is %u", index);
            return true;
        }
    }
    return false;
}

void SheetPresentationPattern::OverlayDismissSheet()
{
    auto overlayManager = GetOverlayManager();
    CHECK_NULL_VOID(overlayManager);
    overlayManager->DismissSheet();
}

void SheetPresentationPattern::OverlaySheetSpringBack()
{
    auto overlayManager = GetOverlayManager();
    CHECK_NULL_VOID(overlayManager);
    overlayManager->SheetSpringBack();
}

PipelineContext* SheetPresentationPattern::GetSheetMainPipeline() const
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, nullptr);
    auto pipelineContext = host->GetContext();
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProperty, nullptr);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());

    if (sheetStyle.instanceId.has_value()) {
        // need to get mainWindow's pipeline, and get mainWindow's cutoutSafeArea
        auto container = Container::GetContainer(sheetStyle.instanceId.value());
        CHECK_NULL_RETURN(container, nullptr);
        auto parentId = container->GetParentId();
        TAG_LOGI(AceLogTag::ACE_SHEET, "mainWindow id : %{public}d", parentId);
        auto parentContainer = Container::GetContainer(parentId);
        CHECK_NULL_RETURN(parentContainer, nullptr);
        auto parentPipelineBase = parentContainer->GetPipelineContext();
        CHECK_NULL_RETURN(parentPipelineBase, nullptr);
        auto parentPipelineContext = AceType::DynamicCast<PipelineContext>(parentPipelineBase);
        pipelineContext = RawPtr(parentPipelineContext);
    }
    return pipelineContext;
}

float SheetPresentationPattern::GetBottomSafeArea()
{
    auto pipelineContext = GetSheetMainPipeline();
    CHECK_NULL_RETURN(pipelineContext, .0f);
    auto safeAreaInsets = pipelineContext->GetSafeAreaWithoutProcess();
    auto manager = pipelineContext->GetSafeAreaManager();
    CHECK_NULL_RETURN(manager, .0f);
    auto cutoutSafeArea = manager->GetCutoutSafeAreaWithoutProcess();
    if (cutoutSafeArea.top_.IsValid()) {
        auto topAreaInWindow = GetTopAreaInWindow();
        TAG_LOGD(AceLogTag::ACE_SHEET, "rosen window sheetTopSafeArea of sheet is : %{public}f", topAreaInWindow);
        return topAreaInWindow;
    } else {
        return safeAreaInsets.top_.Length();
    }
}

// Height of status bar
float SheetPresentationPattern::GetTopAreaInWindow() const
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, 0.0f);
    auto pipelineContext = host->GetContext();
    CHECK_NULL_RETURN(pipelineContext, 0.0f);
    auto window = pipelineContext->GetWindow();
    CHECK_NULL_RETURN(window, 0.0f);
    return window->GetStatusBarHeight();
}

void SheetPresentationPattern::MarkSheetPageNeedRender()
{
    auto parentHost = GetHost()->GetParent();
    CHECK_NULL_VOID(parentHost);
    auto frameNode = AceType::DynamicCast<FrameNode>(parentHost);
    CHECK_NULL_VOID(frameNode);
    frameNode->MarkNeedRenderOnly();
}

void SheetPresentationPattern::SetSheetOuterBorderWidth(
    const RefPtr<SheetTheme>& sheetTheme, const NG::SheetStyle& sheetStyle)
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto renderContext = host->GetRenderContext();
    CHECK_NULL_VOID(renderContext);
    auto layoutProperty = host->GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetType = sheetType_;
    if (sheetTheme->IsOuterBorderEnable() && !sheetStyle.borderWidth.has_value()) {
        BorderWidthProperty borderWidth;
        BorderWidthProperty outBorderWidth;
        BorderColorProperty borderColor;
        BorderColorProperty outBorderColor;
        borderWidth.SetBorderWidth(0.0_vp);
        outBorderWidth.SetBorderWidth(0.0_vp);
        if (sheetObject_->CheckIfNeedSetOuterBorderProp()) {
            borderColor.SetColor(sheetTheme->GetSheetInnerBorderColor());
            outBorderColor.SetColor(sheetTheme->GetSheetOuterBorderColor());
            renderContext->UpdateOuterBorderColor(outBorderColor);
            renderContext->UpdateBorderColor(borderColor);
            if (sheetType == SheetType::SHEET_CENTER || sheetType == SheetType::SHEET_BOTTOM_OFFSET) {
                borderWidth.SetBorderWidth(sheetTheme->GetSheetInnerBorderWidth());
                outBorderWidth.SetBorderWidth(sheetTheme->GetSheetOuterBorderWidth());
            } else {
                borderWidth.leftDimen = sheetTheme->GetSheetInnerBorderWidth();
                borderWidth.topDimen = sheetTheme->GetSheetInnerBorderWidth();
                borderWidth.rightDimen = sheetTheme->GetSheetInnerBorderWidth();
                outBorderWidth.leftDimen = sheetTheme->GetSheetOuterBorderWidth();
                outBorderWidth.topDimen = sheetTheme->GetSheetOuterBorderWidth();
                outBorderWidth.rightDimen = sheetTheme->GetSheetOuterBorderWidth();
            }
        }
        layoutProperty->UpdateBorderWidth(borderWidth);
        renderContext->UpdateBorderWidth(borderWidth);
        layoutProperty->UpdateOuterBorderWidth(outBorderWidth);
        renderContext->UpdateOuterBorderWidth(outBorderWidth);
    }
}

void SheetPresentationPattern::DumpAdvanceInfo(std::unique_ptr<JsonValue>& json)
{
    json->Put("TargetId", static_cast<int32_t>(targetId_));
    json->Put("TargetTag", targetTag_.c_str());
    std::unique_ptr<JsonValue> children = JsonUtil::Create(true);
    children->Put("SheetType", static_cast<int32_t>(GetSheetTypeNoProcess()));
    children->Put("SheetPage Node Height", centerHeight_);
    children->Put("Sheet Height [start from the bottom, KeyboardHeight = 0]", height_);
    children->Put("SheetMaxHeight [start from the bottom, pageHeight - sheetTopSafeArea]", sheetMaxHeight_);
    children->Put("Page Height", pageHeight_);
    children->Put("StatusBar Height [current sheetType needed]", sheetTopSafeArea_);
    children->Put("PopupSheet OffsetX", sheetOffsetX_);
    children->Put("PopupSheet OffsetX", sheetOffsetY_);
    children->Put("SheetMaxWidth", sheetMaxWidth_);
    children->Put("FitContent Height", sheetFitContentHeight_);
    children->Put("SheetThemeType", sheetThemeType_.c_str());
    children->Put("currentOffset", currentOffset_);
    json->Put("SheetPage Pattern", children);

    json->Put("Height ScrollTo [KeyboardHeight > 0, and is scrolling]", -scrollHeight_);
    json->Put("KeyboardHeight", static_cast<int32_t>(keyboardHeight_));
    json->Put("is scrolling", isScrolling_);
    json->Put("SheetHeightUp[sheet offset to move up when avoiding keyboard]", sheetHeightUp_);

    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    json->Put("height", sheetStyle.sheetHeight.height.has_value() ?
        sheetStyle.sheetHeight.height->ToString().c_str() : "None");
    json->Put("sheetMode", sheetStyle.sheetHeight.sheetMode.has_value()
                               ? std::to_string(static_cast<int32_t>(sheetStyle.sheetHeight.sheetMode.value())).c_str()
                               : "None");
    json->Put("detents Size", static_cast<int32_t>(sheetStyle.detents.size()));
    json->Put("IsShouldDismiss", shouldDismiss_ ? "true" : "false");
}

void SheetPresentationPattern::StopModifySheetTransition()
{
    if (isAnimationProcess_ && animation_) {
        AnimationUtils::StopAnimation(animation_);
    }
}

void SheetPresentationPattern::AvoidKeyboardBySheetMode(bool forceAvoid)
{
    if (keyboardAvoidMode_ == SheetKeyboardAvoidMode::NONE ||
        keyboardAvoidMode_ == SheetKeyboardAvoidMode::POPUP_SHEET) {
        TAG_LOGD(AceLogTag::ACE_SHEET, "Sheet will not avoid keyboard.");
        return;
    }
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipelineContext = host->GetContext();
    CHECK_NULL_VOID(pipelineContext);
    auto manager = pipelineContext->GetSafeAreaManager();
    if (keyboardHeight_ == manager->GetKeyboardInset().Length() && !forceAvoid) {
        return;
    }
    keyboardHeight_ = manager->GetKeyboardInset().Length();

    if (isDismissProcess_) {
        TAG_LOGD(AceLogTag::ACE_SHEET, "Sheet will disappear, not need to handle canceling keyboard avoidance here.");
        return;
    }
    StopModifySheetTransition();
    // 1.handle non upward logic: avoidKeyboardMode::RESIZE_ONLY
    if (AvoidKeyboardBeforeTranslate()) {
        return;
    }

    // 2.handle upward logic
    CHECK_NULL_VOID(host->GetFocusHub());
    // When bindSheet lift height exceed the max height, hightUp = the remaining height that needs to scroll,
    // otherwise, hightUp = the height to be lifted up
    auto heightUp = host->GetFocusHub()->IsCurrentFocus() ? GetSheetHeightChange() : 0.0f;
    sheetHeightUp_ = heightUp;
    TAG_LOGD(AceLogTag::ACE_SHEET, "To avoid Keyboard, sheet needs to deal with %{public}f height.", heightUp);
    auto offset = pageHeight_ - height_ - heightUp;
    auto renderContext = host->GetRenderContext();

    // when bindSheet height exceed the max height, lift it up to the maxHeight,
    // otherwise, lift it up to show input area
    if (isScrolling_) {
        if (NearZero(heightUp)) {
            // scroll needs to reset first when keyboard is down.
            renderContext->UpdateTransformTranslate({ 0.0f, offset, 0.0f });
        } else {
            auto sheetHeightUp = pageHeight_ - (SHEET_BLANK_MINI_HEIGHT.ConvertToPx() + sheetTopSafeArea_) - height_;
            sheetHeightUp_ = LessNotEqual(sheetHeightUp, 0.0f) ? 0.0f : sheetHeightUp;
            if (GreatNotEqual(sheetHeightUp_, 0.0f)) {
                // sheet is raised to the top first
                renderContext->UpdateTransformTranslate(
                    { 0.0f, SHEET_BLANK_MINI_HEIGHT.ConvertToPx() + sheetTopSafeArea_, 0.0f });
            }
        }
    } else {
        // offset: translate endpoint, calculated from top
        renderContext->UpdateTransformTranslate({ 0.0f, offset, 0.0f });
    }

    // 3.deal with left height, scroll or resize
    if (isScrolling_) {
        AvoidKeyboardAfterTranslate(heightUp);
    }

    if (IsSheetBottomStyle()) {
        OnHeightDidChange(height_ + sheetHeightUp_);
    }
}

bool SheetPresentationPattern::AvoidKeyboardBeforeTranslate()
{
    if (keyboardAvoidMode_ == SheetKeyboardAvoidMode::RESIZE_ONLY) {
        // resize bindSheet need to keep safe distance from keyboard
        auto distanceFromBottom = sheetType_ == SheetType::SHEET_CENTER ? height_ - centerHeight_ : 0.0f;
        DecreaseScrollHeightInSheet(keyboardHeight_ == 0 ? 0.0f : keyboardHeight_ - distanceFromBottom);
        return true;
    }
    return false;
}

void SheetPresentationPattern::AvoidKeyboardAfterTranslate(float height)
{
    switch (keyboardAvoidMode_) {
    case SheetKeyboardAvoidMode::NONE:
    case SheetKeyboardAvoidMode::RESIZE_ONLY:
        break;
    case SheetKeyboardAvoidMode::TRANSLATE_AND_RESIZE:
        // resize bindSheet need to keep safe distance from keyboard
        DecreaseScrollHeightInSheet(keyboardHeight_ == 0 ? 0.0f : height);
        break;
    case SheetKeyboardAvoidMode::TRANSLATE_AND_SCROLL:
        ScrollTo(height);
        break;
    default:
        TAG_LOGW(AceLogTag::ACE_SHEET, "Invalid keyboard avoid mode %{public}d", keyboardAvoidMode_);
        break;
    }
}

void SheetPresentationPattern::DecreaseScrollHeightInSheet(float decreaseHeight)
{
    auto scroll = GetSheetScrollNode();
    CHECK_NULL_VOID(scroll);
    auto layoutProp = scroll->GetLayoutProperty<ScrollLayoutProperty>();
    CHECK_NULL_VOID(layoutProp);

    // height > 0, Scroll will reduce height, and need to set isScrolling true
    isScrolling_ = (decreaseHeight > 0);

    TAG_LOGD(AceLogTag::ACE_SHEET, "To avoid Keyboard, Scroll Height reduces by height %{public}f.", decreaseHeight);
    layoutProp->UpdateUserDefinedIdealSize(CalcSize(std::nullopt, CalcLength(GetScrollHeight() - decreaseHeight)));
    resizeDecreasedHeight_ = decreaseHeight;
    scroll->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
}

bool SheetPresentationPattern::IsResizeWhenAvoidKeyboard()
{
    return keyboardAvoidMode_ == SheetKeyboardAvoidMode::TRANSLATE_AND_RESIZE ||
        keyboardAvoidMode_ == SheetKeyboardAvoidMode::RESIZE_ONLY;
}

void SheetPresentationPattern::ResetClipShape()
{
    // need reset clip path，when system clip path change to user defined
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto renderContext = host->GetRenderContext();
    CHECK_NULL_VOID(renderContext);
    renderContext->UpdateClipShape(nullptr);
    renderContext->ResetClipShape();
}

void SheetPresentationPattern::GetCurrentScrollHeight()
{
    if (!isScrolling_) {
        return;
    }
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto scrollNode = GetSheetScrollNode();
    CHECK_NULL_VOID(scrollNode);
    auto scrollPattern = scrollNode->GetPattern<ScrollPattern>();
    CHECK_NULL_VOID(scrollPattern);
    auto curOffset = scrollPattern->GetTotalOffset();
    if (NearEqual(scrollHeight_, curOffset)) {
        return;
    }
    TAG_LOGD(AceLogTag::ACE_SHEET, "scroll height changed because of user scrolling, %{public}f", curOffset);
    scrollHeight_ = curOffset;
}

void SheetPresentationPattern::UpdateSheetWhenSheetTypeChanged()
{
    auto sheetType = GetSheetTypeFromSheetManager();
    if (sheetType_ != sheetType) {
        // It can only be MarkOuterBorder When the SheetType switches and the sheetType_ was SHEET_POPUP
        if (sheetType_ == SheetType::SHEET_POPUP) {
            // Clear the current double outline, as it is drawn on the sheetWrapper.
            MarkSheetPageNeedRender();
        }
        sheetType_ = sheetType;
        UpdateSheetObject(sheetType_);
        typeChanged_ = true;
        SetSheetBorderWidth();
    }
}

bool SheetPresentationPattern::IsWaterfallWindowMode()
{
    if (!SystemProperties::IsSuperFoldDisplayDevice()) {
        return false;
    }

    auto container = Container::Current();
    if (!container) {
        TAG_LOGW(AceLogTag::ACE_DIALOG, "container is null");
        return false;
    }

    if (container->IsSubContainer()) {
        auto instanceId = SubwindowManager::GetInstance()->GetParentContainerId(GetSubWindowId());
        container = AceEngine::Get().GetContainer(instanceId);
        if (!container) {
            TAG_LOGW(AceLogTag::ACE_DIALOG, "parent container is null");
            return false;
        }
    }

    auto halfFoldStatus = container->GetCurrentFoldStatus() == FoldStatus::HALF_FOLD;
    auto isWaterfallWindow = container->IsWaterfallWindow();
    return halfFoldStatus && isWaterfallWindow;
}

bool SheetPresentationPattern::IsCurSheetNeedHalfFoldHover()
{
    auto host = GetHost();
    CHECK_NULL_RETURN(host, false);
    auto pipeline = host->GetContext();
    CHECK_NULL_RETURN(pipeline, false);
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_RETURN(sheetTheme, false);
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProperty, false);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    DeviceType deviceType = SystemProperties::GetDeviceType();
    auto enableHoverMode = sheetStyle.enableHoverMode.value_or((deviceType == DeviceType::TWO_IN_ONE) ? true : false);
    bool isHoverMode = enableHoverMode ? pipeline->IsHalfFoldHoverStatus() : false;
    if (deviceType == DeviceType::TWO_IN_ONE) {
        TAG_LOGD(AceLogTag::ACE_SHEET, "sheet IsOuterBorderEnable is true.");
        isHoverMode = enableHoverMode ? IsWaterfallWindowMode() : false;
    }
    return isHoverMode && GetSheetTypeNoProcess() == SheetType::SHEET_CENTER;
}

bool SheetPresentationPattern::IsShowInSubWindowTwoInOne()
{
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProperty, false);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    if (!sheetStyle.showInSubWindow.value_or(false)) {
        return false;
    }
    auto host = GetHost();
    CHECK_NULL_RETURN(host, false);
    auto pipeline = host->GetContext();
    CHECK_NULL_RETURN(pipeline, false);
    auto sheetTheme = pipeline->GetTheme<SheetTheme>();
    CHECK_NULL_RETURN(sheetTheme, false);
    return sheetTheme->IsOuterBorderEnable();
}

bool SheetPresentationPattern::IsShowInSubWindow() const
{
    auto layoutProperty = GetLayoutProperty<SheetPresentationProperty>();
    CHECK_NULL_RETURN(layoutProperty, false);
    auto sheetStyle = layoutProperty->GetSheetStyleValue(SheetStyle());
    return sheetStyle.showInSubWindow.value_or(false);
}

void SheetPresentationPattern::InitFoldCreaseRegion()
{
    if (!currentFoldCreaseRegion_.empty()) {
        return;
    }
    auto container = Container::Current();
    CHECK_NULL_VOID(container);
    if (container->IsSubContainer()) {
        auto instanceId = SubwindowManager::GetInstance()->GetParentContainerId(container->GetInstanceId());
        container = AceEngine::Get().GetContainer(instanceId);
    }
    CHECK_NULL_VOID(container);
    auto displayInfo = container->GetDisplayInfo();
    CHECK_NULL_VOID(displayInfo);
    currentFoldCreaseRegion_ = displayInfo->GetCurrentFoldCreaseRegion();
}

Rect SheetPresentationPattern::GetFoldScreenRect() const
{
    if (currentFoldCreaseRegion_.empty()) {
        TAG_LOGW(AceLogTag::ACE_SHEET, "FoldCreaseRegion is invalid.");
        return Rect();
    }
    return currentFoldCreaseRegion_.front();
}

Shadow SheetPresentationPattern::GetShadowFromTheme(ShadowStyle shadowStyle)
{
    if (shadowStyle == ShadowStyle::None || !sheetObject_->CheckIfNeedShadowByDefault()) {
        return Shadow();
    }
    auto host = GetHost();
    CHECK_NULL_RETURN(host, Shadow());
    auto pipelineContext = host->GetContext();
    CHECK_NULL_RETURN(pipelineContext, Shadow());
    auto colorMode = pipelineContext->GetColorMode();
    auto shadowTheme = pipelineContext->GetTheme<ShadowTheme>();
    CHECK_NULL_RETURN(shadowTheme, Shadow());
    auto shadow = shadowTheme->GetShadow(shadowStyle, colorMode);
    return shadow;
}

void SheetPresentationPattern::FireHoverModeChangeCallback()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    if (!IsCurSheetNeedHalfFoldHover()) {
        TAG_LOGD(AceLogTag::ACE_SHEET, "halfFoldHoverStatus: %{public}d, Sheet is not half folded.",
            pipeline->IsHalfFoldHoverStatus());
        return;
    }
    OnHeightDidChange(centerHeight_);
}

void SheetPresentationPattern::GetArrowOffsetByPlacement(
    const RefPtr<SheetPresentationLayoutAlgorithm>& layoutAlgorithm)
{
    CHECK_NULL_VOID(layoutAlgorithm);
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    if (!host->GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_EIGHTEEN)) {
        return;
    }
    finalPlacement_ = sheetPopupInfo_.finalPlacement;
    showArrow_ = sheetPopupInfo_.showArrow;
    arrowPosition_ = sheetPopupInfo_.arrowPosition;
    if (!showArrow_ || finalPlacement_ == Placement::NONE) {
        arrowOffset_ = OffsetF(0.f, 0.f);
        return;
    }

    switch (finalPlacement_) {
        case Placement::BOTTOM_LEFT:
            [[fallthrough]];
        case Placement::BOTTOM_RIGHT:
            [[fallthrough]];
        case Placement::BOTTOM:
            [[fallthrough]];
        case Placement::TOP_LEFT:
            [[fallthrough]];
        case Placement::TOP_RIGHT:
            [[fallthrough]];
        case Placement::TOP: {
            arrowOffset_ = OffsetF(sheetPopupInfo_.arrowOffsetX, 0.f);
            break;
        }
        case Placement::RIGHT_TOP:
            [[fallthrough]];
        case Placement::RIGHT_BOTTOM:
            [[fallthrough]];
        case Placement::RIGHT:
            [[fallthrough]];
        case Placement::LEFT_TOP:
            [[fallthrough]];
        case Placement::LEFT_BOTTOM:
            [[fallthrough]];
        case Placement::LEFT: {
            arrowOffset_ = OffsetF(0.f, sheetPopupInfo_.arrowOffsetY);
            break;
        }
        default:
            break;
    }
}

std::string SheetPresentationPattern::GetPopupStyleSheetClipPathNew(
    const SizeF& sheetSize, const BorderRadiusProperty& sheetRadius)
{
    std::string drawPath;
    switch (finalPlacement_) {
        case Placement::BOTTOM_LEFT:
            [[fallthrough]];
        case Placement::BOTTOM_RIGHT:
            [[fallthrough]];
        case Placement::BOTTOM: {
            drawPath = DrawClipPathBottom(sheetSize, sheetRadius);
            break;
        }
        case Placement::TOP_LEFT:
            [[fallthrough]];
        case Placement::TOP_RIGHT:
            [[fallthrough]];
        case Placement::TOP: {
            drawPath = DrawClipPathTop(sheetSize, sheetRadius);
            break;
        }
        case Placement::RIGHT_TOP:
            [[fallthrough]];
        case Placement::RIGHT_BOTTOM:
            [[fallthrough]];
        case Placement::RIGHT: {
            drawPath = DrawClipPathRight(sheetSize, sheetRadius);
            break;
        }
        case Placement::LEFT_TOP:
            [[fallthrough]];
        case Placement::LEFT_BOTTOM:
            [[fallthrough]];
        case Placement::LEFT: {
            drawPath = DrawClipPathLeft(sheetSize, sheetRadius);
            break;
        }
        default:
            break;
    }
    return drawPath;
}

std::string SheetPresentationPattern::DrawClipPathBottom(const SizeF& sheetSize,
    const BorderRadiusProperty& sheetRadius)
{
    auto radiusTopLeft = sheetRadius.radiusTopLeft->ConvertToPx();
    auto radiusTopRight = sheetRadius.radiusTopRight->ConvertToPx();
    auto radiusBottomRight = sheetRadius.radiusBottomRight->ConvertToPx();
    auto radiusBottomLeft = sheetRadius.radiusBottomLeft->ConvertToPx();
    // clip path start from TopLeft, and draw Right-angled arrow first if needed
    std::string path;
    if (arrowPosition_ == SheetArrowPosition::BOTTOM_LEFT) {
        path += MoveTo(0.f, SHEET_ARROW_HEIGHT.ConvertToPx());  // P5
        path += LineTo(0.f, (SHEET_ARROW_HEIGHT - ARROW_CORNER_P4_OFFSET_Y).ConvertToPx()); // P4
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
            (SHEET_ARROW_WIDTH - ARROW_CORNER_P2_OFFSET_X).ConvertToPx(),
            (SHEET_ARROW_HEIGHT - ARROW_CORNER_P2_OFFSET_Y).ConvertToPx()); // P2
        path += LineTo(SHEET_ARROW_WIDTH.ConvertToPx(), SHEET_ARROW_HEIGHT.ConvertToPx());  // P1
    } else {
        path += MoveTo(0.0f, SHEET_ARROW_HEIGHT.ConvertToPx() + radiusTopLeft);
        path += ArcTo(radiusTopLeft, radiusTopLeft, 0.0f, 0, radiusTopLeft,
            SHEET_ARROW_HEIGHT.ConvertToPx());
    }
    if (arrowPosition_ == SheetArrowPosition::NONE) {
        path += LineTo(arrowOffset_.GetX() - ARROW_VERTICAL_P1_OFFSET_X.ConvertToPx(),
            SHEET_ARROW_HEIGHT.ConvertToPx());  // P1
        path += LineTo(arrowOffset_.GetX() - ARROW_VERTICAL_P2_OFFSET_X.ConvertToPx(),
            (SHEET_ARROW_HEIGHT - ARROW_VERTICAL_P2_OFFSET_Y).ConvertToPx());   // P2
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
            arrowOffset_.GetX() + ARROW_VERTICAL_P4_OFFSET_X.ConvertToPx(),
            (SHEET_ARROW_HEIGHT - ARROW_VERTICAL_P4_OFFSET_Y).ConvertToPx());   // P4
        path += LineTo(arrowOffset_.GetX() + ARROW_VERTICAL_P5_OFFSET_X.ConvertToPx(),
            SHEET_ARROW_HEIGHT.ConvertToPx());  // P5
    }
    if (arrowPosition_ == SheetArrowPosition::BOTTOM_RIGHT) {
        path += LineTo(sheetSize.Width() -
            SHEET_ARROW_WIDTH.ConvertToPx(), SHEET_ARROW_HEIGHT.ConvertToPx());  // P1
        path += LineTo(sheetSize.Width() - (SHEET_ARROW_WIDTH - ARROW_CORNER_P2_OFFSET_X).ConvertToPx(),
            (SHEET_ARROW_HEIGHT - ARROW_CORNER_P2_OFFSET_Y).ConvertToPx()); // P2
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
            sheetSize.Width(), (SHEET_ARROW_HEIGHT - ARROW_CORNER_P4_OFFSET_Y).ConvertToPx());  // P4
        path += LineTo(sheetSize.Width(), SHEET_ARROW_HEIGHT.ConvertToPx());    // P5
    } else {
        path += LineTo(sheetSize.Width() - radiusTopRight, SHEET_ARROW_HEIGHT.ConvertToPx());
        path += ArcTo(radiusTopRight, radiusTopRight, 0.0f, 0, sheetSize.Width(),
            SHEET_ARROW_HEIGHT.ConvertToPx() + radiusTopRight);
    }
    path += LineTo(sheetSize.Width(), sheetSize.Height() - radiusBottomRight);
    path += ArcTo(radiusBottomRight, radiusBottomRight, 0.0f, 0,
        sheetSize.Width() - radiusBottomRight, sheetSize.Height());
    path += LineTo(radiusBottomLeft, sheetSize.Height());
    path += ArcTo(radiusBottomLeft, radiusBottomLeft, 0.0f, 0, 0.0f,
        sheetSize.Height() - radiusBottomLeft);
    return path + "Z";
}

std::string SheetPresentationPattern::DrawClipPathTop(const SizeF& sheetSize,
    const BorderRadiusProperty& sheetRadius)
{
    auto radiusTopLeft = sheetRadius.radiusTopLeft->ConvertToPx();
    auto radiusTopRight = sheetRadius.radiusTopRight->ConvertToPx();
    auto radiusBottomRight = sheetRadius.radiusBottomRight->ConvertToPx();
    auto radiusBottomLeft = sheetRadius.radiusBottomLeft->ConvertToPx();
    // clip path start from TopLeft, and draw sheet radius first
    std::string path;
    path += MoveTo(0.f, radiusTopLeft);
    path += ArcTo(radiusTopLeft, radiusTopLeft, 0.0f, 0, radiusTopLeft, 0.f);
    path += LineTo(sheetSize.Width() - radiusTopRight, 0.f);
    path += ArcTo(radiusTopRight, radiusTopRight, 0.0f, 0,
        sheetSize.Width(), radiusTopRight);
    if (arrowPosition_ == SheetArrowPosition::TOP_RIGHT) {
        path += LineTo(sheetSize.Width(),
            sheetSize.Height() - (SHEET_ARROW_HEIGHT - ARROW_CORNER_P4_OFFSET_Y).ConvertToPx());    // P4
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
            sheetSize.Width() - (SHEET_ARROW_WIDTH - ARROW_CORNER_P2_OFFSET_X).ConvertToPx(),
            sheetSize.Height() - (SHEET_ARROW_HEIGHT - ARROW_CORNER_P2_OFFSET_Y).ConvertToPx());    // P2
        path += LineTo(sheetSize.Width() - SHEET_ARROW_WIDTH.ConvertToPx(),
            sheetSize.Height() - SHEET_ARROW_HEIGHT.ConvertToPx()); // P1
    } else {
        path += LineTo(sheetSize.Width(), sheetSize.Height() - radiusBottomRight - SHEET_ARROW_HEIGHT.ConvertToPx());
        path += ArcTo(radiusBottomRight, radiusBottomRight, 0.0f, 0,
            sheetSize.Width() - radiusBottomRight, sheetSize.Height() - SHEET_ARROW_HEIGHT.ConvertToPx());
    }
    if (arrowPosition_ == SheetArrowPosition::NONE) {
        path += LineTo(arrowOffset_.GetX() + ARROW_VERTICAL_P1_OFFSET_X.ConvertToPx(),
            sheetSize.Height() - SHEET_ARROW_HEIGHT.ConvertToPx()); // P1
        path += LineTo(arrowOffset_.GetX() + ARROW_VERTICAL_P2_OFFSET_X.ConvertToPx(),
            sheetSize.Height() - (SHEET_ARROW_HEIGHT - ARROW_VERTICAL_P2_OFFSET_Y).ConvertToPx());  // P2
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
            arrowOffset_.GetX() - ARROW_VERTICAL_P4_OFFSET_X.ConvertToPx(),
            sheetSize.Height() - (SHEET_ARROW_HEIGHT - ARROW_VERTICAL_P4_OFFSET_Y).ConvertToPx());  // P4
        path += LineTo(arrowOffset_.GetX() - ARROW_VERTICAL_P5_OFFSET_X.ConvertToPx(),
            sheetSize.Height() - SHEET_ARROW_HEIGHT.ConvertToPx()); // P5
    }
    if (arrowPosition_ == SheetArrowPosition::TOP_LEFT) {
        path += LineTo(SHEET_ARROW_WIDTH.ConvertToPx(),
            sheetSize.Height() - SHEET_ARROW_HEIGHT.ConvertToPx()); // P1
        path += LineTo((SHEET_ARROW_WIDTH - ARROW_CORNER_P2_OFFSET_X).ConvertToPx(),
            sheetSize.Height() - (SHEET_ARROW_HEIGHT - ARROW_CORNER_P2_OFFSET_Y).ConvertToPx());    // P2
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0, 0.f,
            sheetSize.Height() - (SHEET_ARROW_HEIGHT - ARROW_CORNER_P4_OFFSET_Y).ConvertToPx());    // P4
        path += LineTo(0.f, sheetSize.Height() - SHEET_ARROW_HEIGHT.ConvertToPx()); // P5
    } else {
        path += LineTo(radiusBottomLeft, sheetSize.Height() - SHEET_ARROW_HEIGHT.ConvertToPx());
        path += ArcTo(radiusBottomLeft, radiusBottomLeft, 0.0f, 0,
            0.f, sheetSize.Height() - radiusBottomLeft - SHEET_ARROW_HEIGHT.ConvertToPx());
    }
    return path + "Z";
}

std::string SheetPresentationPattern::DrawClipPathLeft(const SizeF& sheetSize,
    const BorderRadiusProperty& sheetRadius)
{
    auto radiusTopLeft = sheetRadius.radiusTopLeft->ConvertToPx();
    auto radiusTopRight = sheetRadius.radiusTopRight->ConvertToPx();
    auto radiusBottomRight = sheetRadius.radiusBottomRight->ConvertToPx();
    auto radiusBottomLeft = sheetRadius.radiusBottomLeft->ConvertToPx();
    // clip path start from TopLeft, and draw sheet radius first
    std::string path;
    path += MoveTo(0.f, radiusTopLeft);
    path += ArcTo(radiusTopLeft, radiusTopLeft, 0.0f, 0, radiusTopLeft, 0.f);
    if (arrowPosition_ == SheetArrowPosition::LEFT_TOP) {
        path += LineTo(sheetSize.Width() - (SHEET_ARROW_HEIGHT - ARROW_CORNER_P4_OFFSET_Y).ConvertToPx(), 0.f); // P4
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
            sheetSize.Width() - (SHEET_ARROW_HEIGHT - ARROW_CORNER_P2_OFFSET_Y).ConvertToPx(),
            (SHEET_ARROW_WIDTH - ARROW_CORNER_P2_OFFSET_X).ConvertToPx());  // P2
        path += LineTo(sheetSize.Width() - SHEET_ARROW_HEIGHT.ConvertToPx(),
            SHEET_ARROW_WIDTH.ConvertToPx());  // P1
    } else {
        path += LineTo(sheetSize.Width() - radiusTopRight - SHEET_ARROW_HEIGHT.ConvertToPx(), 0.f);
        path += ArcTo(radiusTopRight, radiusTopRight, 0.0f, 0,
            sheetSize.Width() - SHEET_ARROW_HEIGHT.ConvertToPx(), radiusTopRight);
    }
    if (arrowPosition_ == SheetArrowPosition::NONE) {
        path += LineTo(sheetSize.Width() - SHEET_ARROW_HEIGHT.ConvertToPx(),
            arrowOffset_.GetY() - ARROW_VERTICAL_P1_OFFSET_X.ConvertToPx());    // P1
        path += LineTo(sheetSize.Width() - (SHEET_ARROW_HEIGHT - ARROW_VERTICAL_P2_OFFSET_Y).ConvertToPx(),
            arrowOffset_.GetY() - ARROW_VERTICAL_P2_OFFSET_X.ConvertToPx());    // P2
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
            sheetSize.Width() - (SHEET_ARROW_HEIGHT - ARROW_VERTICAL_P4_OFFSET_Y).ConvertToPx(),
            arrowOffset_.GetY() + ARROW_VERTICAL_P4_OFFSET_X.ConvertToPx());    // P4
        path += LineTo(sheetSize.Width() - SHEET_ARROW_HEIGHT.ConvertToPx(),
            arrowOffset_.GetY() + ARROW_VERTICAL_P5_OFFSET_X.ConvertToPx());    // P5
    }
    if (arrowPosition_ == SheetArrowPosition::LEFT_BOTTOM) {
        path += LineTo(sheetSize.Width() - SHEET_ARROW_HEIGHT.ConvertToPx(),
            sheetSize.Height() - SHEET_ARROW_WIDTH.ConvertToPx());  // P1
        path += LineTo(sheetSize.Width() - (SHEET_ARROW_HEIGHT - ARROW_CORNER_P2_OFFSET_Y).ConvertToPx(),
            sheetSize.Height() - (SHEET_ARROW_WIDTH - ARROW_CORNER_P2_OFFSET_X).ConvertToPx()); // P2
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0, sheetSize.Width() -
            (SHEET_ARROW_HEIGHT - ARROW_CORNER_P4_OFFSET_Y).ConvertToPx(), sheetSize.Height()); // P4
        path += LineTo(sheetSize.Width() - SHEET_ARROW_HEIGHT.ConvertToPx(), sheetSize.Height());   // P5
    } else {
        path += LineTo(sheetSize.Width() - SHEET_ARROW_HEIGHT.ConvertToPx(),
            sheetSize.Height() - radiusBottomRight);
        path += ArcTo(radiusBottomRight, radiusBottomRight, 0.0f, 0,
            sheetSize.Width() - radiusBottomRight - SHEET_ARROW_HEIGHT.ConvertToPx(), sheetSize.Height());
    }
    path += LineTo(radiusBottomLeft, sheetSize.Height());
    path += ArcTo(radiusBottomLeft, radiusBottomLeft, 0.0f, 0,
        0.f, sheetSize.Height() - radiusBottomLeft);
    return path + "Z";
}

std::string SheetPresentationPattern::DrawClipPathRight(const SizeF& sheetSize,
    const BorderRadiusProperty& sheetRadius)
{
    auto radiusTopLeft = sheetRadius.radiusTopLeft->ConvertToPx();
    auto radiusTopRight = sheetRadius.radiusTopRight->ConvertToPx();
    auto radiusBottomRight = sheetRadius.radiusBottomRight->ConvertToPx();
    auto radiusBottomLeft = sheetRadius.radiusBottomLeft->ConvertToPx();
    // clip path start from TopLeft, and if left side need draw left top Right-angled arrow, draw it first
    std::string path;
    if (arrowPosition_ == SheetArrowPosition::RIGHT_TOP) {
        path += MoveTo(SHEET_ARROW_HEIGHT.ConvertToPx(), SHEET_ARROW_WIDTH.ConvertToPx());  // P1
        path += LineTo((SHEET_ARROW_HEIGHT - ARROW_CORNER_P2_OFFSET_Y).ConvertToPx(),
            (SHEET_ARROW_WIDTH - ARROW_CORNER_P2_OFFSET_X).ConvertToPx());  // P2
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
            (SHEET_ARROW_HEIGHT - ARROW_CORNER_P4_OFFSET_Y).ConvertToPx(), 0.f);    // P4
        path += LineTo(SHEET_ARROW_HEIGHT.ConvertToPx(), 0.f);  // P5
    } else {
        path += MoveTo(SHEET_ARROW_HEIGHT.ConvertToPx(), radiusTopLeft);
        path += ArcTo(radiusTopLeft, radiusTopLeft, 0.0f, 0,
            radiusTopLeft + SHEET_ARROW_HEIGHT.ConvertToPx(), 0.f);
    }
    path += LineTo(sheetSize.Width() - radiusTopRight, 0.f);
    path += ArcTo(radiusTopRight, radiusTopRight, 0.0f, 0,
        sheetSize.Width(), radiusTopRight);
    path += LineTo(sheetSize.Width(), sheetSize.Height() - radiusBottomRight);
    path += ArcTo(radiusBottomRight, radiusBottomRight, 0.0f, 0,
        sheetSize.Width() - radiusBottomRight, sheetSize.Height());
    if (arrowPosition_ == SheetArrowPosition::RIGHT_BOTTOM) {
        path += LineTo(SHEET_ARROW_HEIGHT.ConvertToPx(), sheetSize.Height());   // P5
        path += LineTo((SHEET_ARROW_HEIGHT - ARROW_CORNER_P4_OFFSET_Y).ConvertToPx(), sheetSize.Height());  // P4
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
            (SHEET_ARROW_HEIGHT - ARROW_CORNER_P2_OFFSET_Y).ConvertToPx(),
            sheetSize.Height() - (SHEET_ARROW_WIDTH - ARROW_CORNER_P2_OFFSET_X).ConvertToPx()); // P2
        path += LineTo(SHEET_ARROW_HEIGHT.ConvertToPx(),
            sheetSize.Height() - SHEET_ARROW_WIDTH.ConvertToPx()); // P1
    } else {
        path += LineTo(radiusBottomLeft + SHEET_ARROW_HEIGHT.ConvertToPx(), sheetSize.Height());
        path += ArcTo(radiusBottomLeft, radiusBottomLeft, 0.0f, 0,
            SHEET_ARROW_HEIGHT.ConvertToPx(), sheetSize.Height() - radiusBottomLeft);
    }
    if (arrowPosition_ == SheetArrowPosition::NONE) {
        path += LineTo(SHEET_ARROW_HEIGHT.ConvertToPx(),
            arrowOffset_.GetY() + ARROW_VERTICAL_P1_OFFSET_X.ConvertToPx());    // P1
        path += LineTo((SHEET_ARROW_HEIGHT - ARROW_VERTICAL_P2_OFFSET_Y).ConvertToPx(),
            arrowOffset_.GetY() + ARROW_VERTICAL_P2_OFFSET_X.ConvertToPx());    // P2
        path += ArcTo(ARROW_RADIUS.ConvertToPx(), ARROW_RADIUS.ConvertToPx(), 0.0f, 0,
            (SHEET_ARROW_HEIGHT - ARROW_VERTICAL_P4_OFFSET_Y).ConvertToPx(),
            arrowOffset_.GetY() - ARROW_VERTICAL_P4_OFFSET_X.ConvertToPx());    // P4
        path += LineTo(SHEET_ARROW_HEIGHT.ConvertToPx(),
            arrowOffset_.GetY() - ARROW_VERTICAL_P5_OFFSET_X.ConvertToPx());    // P5
    }
    return path + "Z";
}

void SheetPresentationPattern::RecoverHalfFoldOrAvoidStatus()
{
    TAG_LOGD(AceLogTag::ACE_SHEET, "recover half fold status because of window rotate");
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto pipeline = host->GetContext();
    CHECK_NULL_VOID(pipeline);
    if (IsCurSheetNeedHalfFoldHover()) {
        RecoverAvoidKeyboardStatus();
    } else {
        AvoidSafeArea(true);
    }
}

void SheetPresentationPattern::RecoverAvoidKeyboardStatus()
{
    RecoverScrollOrResizeAvoidStatus();
    sheetHeightUp_ = 0.f;
    OnHeightDidChange(centerHeight_);
}

void SheetPresentationPattern::RecoverScrollOrResizeAvoidStatus()
{
    auto scroll = GetSheetScrollNode();
    CHECK_NULL_VOID(scroll);
    auto layoutProp = scroll->GetLayoutProperty<ScrollLayoutProperty>();
    CHECK_NULL_VOID(layoutProp);
    layoutProp->UpdateUserDefinedIdealSize(CalcSize(std::nullopt, CalcLength(GetScrollHeight())));
    resizeDecreasedHeight_ = 0.f;
    scrollHeight_ = 0.f;
    ScrollTo(0.f);
    isScrolling_ = false;
}

void SheetPresentationPattern::OnWillAppear()
{
    isOnAppearing_ = true;
    TAG_LOGI(AceLogTag::ACE_SHEET, "bindsheet lifecycle change to onWillAppear state.");
    if (onWillAppear_) {
        onWillAppear_();
    }
    // "SendMessagesBeforeXX" and "SendMessagesAfterXX" need to be called in conjunction.
    // Currently, this is ensured through the lifecycle, and it is not recommended to call them separately.
    SendMessagesBeforeFirstTransitionIn(true);
}

void SheetPresentationPattern::OnAppear()
{
    isOnAppearing_ = false;
    TAG_LOGI(AceLogTag::ACE_SHEET, "bindsheet lifecycle change to onAppear state.");
    if (onAppear_) {
        onAppear_();
    }
    if (Container::GreatOrEqualAPITargetVersion(PlatformVersion::VERSION_TWELVE)) {
        SendMessagesAfterFirstTransitionIn(true);
    }
}

bool SheetPresentationPattern::IsNeedChangeScrollHeight(float height)
{
    auto it = std::min_element(sheetDetentHeight_.begin(), sheetDetentHeight_.end());
    if (it == sheetDetentHeight_.end()) {
        return false;
    }
    if (IsAvoidingKeyboard()) {
        return false;
    }
    float lowestDetentHeight = *it;
    bool isNeedChangeScrollHeight =
        scrollSizeMode_ == ScrollSizeMode::CONTINUOUS && GreatOrEqual(height, lowestDetentHeight);
    return isNeedChangeScrollHeight;
}

void SheetPresentationPattern::OnWillDisappear()
{
    isOnDisappearing_ = true;
    TAG_LOGI(AceLogTag::ACE_SHEET, "bindsheet lifecycle change to onWillDisappear state.");
    if (onWillDisappear_) {
        onWillDisappear_();
    }
    SendMessagesBeforeTransitionOut();
    auto hostNode = GetHost();
    CHECK_NULL_VOID(hostNode);
    auto pipelineContext = hostNode->GetContextRefPtr();
    CHECK_NULL_VOID(pipelineContext);
    auto navigationManager = pipelineContext->GetNavigationManager();
    CHECK_NULL_VOID(navigationManager);
    navigationManager->FireOverlayLifecycle(hostNode, static_cast<int32_t>(NavDestinationLifecycle::ON_INACTIVE),
        static_cast<int32_t>(NavDestinationActiveReason::SHEET));
}

void SheetPresentationPattern::OnDisappear()
{
    isOnDisappearing_ = false;
    TAG_LOGI(AceLogTag::ACE_SHEET, "bindsheet lifecycle change to onDisappear state.");
    if (onDisappear_) {
        isExecuteOnDisappear_ = true;
        onDisappear_();
    }
    isDismissProcess_ = false;
}

void SheetPresentationPattern::OnFontScaleConfigurationUpdate()
{
    auto hostNode = GetHost();
    CHECK_NULL_VOID(hostNode);
    auto pipeline = hostNode->GetContext();
    CHECK_NULL_VOID(pipeline);
    pipeline->AddAfterReloadAnimationTask([weak = WeakClaim(this)]() {
        auto pattern = weak.Upgrade();
        CHECK_NULL_VOID(pattern);
        pattern->AvoidSafeArea(true);
    });
}

void SheetPresentationPattern::OnAvoidInfoChange(const ContainerModalAvoidInfo& info)
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    host->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
}

void SheetPresentationPattern::RegisterAvoidInfoChangeListener(const RefPtr<FrameNode>& hostNode)
{
    CHECK_NULL_VOID(hostNode);
    auto pipeline = hostNode->GetContext();
    CHECK_NULL_VOID(pipeline);
    auto mgr = pipeline->GetAvoidInfoManager();
    CHECK_NULL_VOID(mgr);
    mgr->AddAvoidInfoListener(WeakClaim(this));
}

void SheetPresentationPattern::UnRegisterAvoidInfoChangeListener(FrameNode* hostNode)
{
    CHECK_NULL_VOID(hostNode);
    auto pipeline = hostNode->GetContext();
    CHECK_NULL_VOID(pipeline);
    auto mgr = pipeline->GetAvoidInfoManager();
    CHECK_NULL_VOID(mgr);
    mgr->RemoveAvoidInfoListener(WeakClaim(this));
}

/**
 * @brief Update and Send messages in other fields before the sheet entrance animation starts.
 * Its timing is equivalent to the callback "onWillAppear".
 * "SendMessagesBeforeXX" and "SendMessagesAfterXX" need to be called in conjunction.
 * Currently, this is ensured through the lifecycle, and it is not recommended to call them separately.
 */
void SheetPresentationPattern::SendMessagesBeforeFirstTransitionIn(bool isFirstTransition)
{
    if (!isFirstTransition) {
        return;
    }
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    // Close UIFirst
    SetUIFirstSwitch(isFirstTransition, false);
    // WindowMaximize
    SetWindowUseImplicitAnimation(RawPtr(host), true);
    auto context = host->GetRenderContext();
    CHECK_NULL_VOID(context);
    context->UpdateRenderGroup(true, false, true);
    TAG_LOGD(AceLogTag::ACE_SHEET, "UpdateRenderGroup start");
    const auto& overlayManager = GetOverlayManager();
    CHECK_NULL_VOID(overlayManager);
    UpdateAccessibilityDetents(overlayManager->GetSheetHeight());
    auto sheetParent = DynamicCast<FrameNode>(host->GetParent());
    CHECK_NULL_VOID(sheetParent);
    auto levelOrder = overlayManager->GetLevelOrder(sheetParent);
    if (overlayManager->IsTopOrder(levelOrder)) {
        host->OnAccessibilityEvent(AccessibilityEventType::PAGE_OPEN,
            WindowsContentChangeTypes::CONTENT_CHANGE_TYPE_SUBTREE);
    }
    ACE_SCOPED_TRACE("Sheet BeforeFirstTransitionIn end");
    host->AddToOcclusionMap(true);
}

/**
 * @brief Update and Send messages in other fields after the sheet entrance animation ends.
 * Its timing is equivalent to the callback "onAppear".
 */
void SheetPresentationPattern::SendMessagesAfterFirstTransitionIn(bool isFirstTransition)
{
    if (!isFirstTransition) {
        return;
    }
    SetUIFirstSwitch(isFirstTransition, true);
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    auto context = host->GetRenderContext();
    CHECK_NULL_VOID(context);
    context->UpdateRenderGroup(false, false, true);
    TAG_LOGD(AceLogTag::ACE_SHEET, "UpdateRenderGroup finished");
    ACE_SCOPED_TRACE("Sheet AfterFirstTransitionIn end");
}

/**
 * @brief Update and Send messages in other fields before the sheet exit animation starts.
 * Its timing is equivalent to the callback "onWillDisappear".
 */
void SheetPresentationPattern::SendMessagesBeforeTransitionOut()
{
    auto host = GetHost();
    CHECK_NULL_VOID(host);
    host->OnAccessibilityEvent(
        AccessibilityEventType::PAGE_CLOSE, WindowsContentChangeTypes::CONTENT_CHANGE_TYPE_SUBTREE);
    // supports Gesture durring transition
    auto sheetParent = DynamicCast<FrameNode>(host->GetParent());
    CHECK_NULL_VOID(sheetParent);
    auto hub = sheetParent->GetEventHub<EventHub>();
    CHECK_NULL_VOID(hub);
    hub->GetOrCreateGestureEventHub()->SetHitTestMode(HitTestMode::HTMTRANSPARENT);
    ACE_SCOPED_TRACE("Sheet BeforeTransitionOut end");
}

/**
 * @brief Update and Send messages in other fields after the sheet exit animation ends.
 * Its timing is equivalent to the callback "onDisappear".
 */
void SheetPresentationPattern::SendMessagesAfterTransitionOut(FrameNode* sheetNode)
{
    CHECK_NULL_VOID(sheetNode);
    // WindowMaximize
    SetWindowUseImplicitAnimation(sheetNode, false);
    ACE_SCOPED_TRACE("Sheet AfterTransitionOut end");
    sheetNode->AddToOcclusionMap(false);
}

void SheetPresentationPattern::UpdateSheetType()
{
    auto sheetType = GetSheetTypeFromSheetManager();
    if (sheetType_ != sheetType) {
        // It can only be MarkOuterBorder When the SheetType switches and the sheetType_ was SHEET_POPUP
        if (sheetType_ == SheetType::SHEET_POPUP) {
            // Clear the current double outline, as it is drawn on the sheetWrapper.
            MarkSheetPageNeedRender();
        }
        sheetType_ = sheetType;
        typeChanged_ = true;
    }
}

void SheetPresentationPattern::InitSheetObject()
{
    // The first CreateObject must be later than UpdateSheetStyle, must be earlier than MarkModifyDone.
    // And must be earlier than the entry animation.
    if (sheetType_ == SheetType::SHEET_SIDE) {
        sheetObject_ = AceType::MakeRefPtr<SheetSideObject>(sheetType_);
    } else if (sheetType_ == SheetType::SHEET_CONTENT_COVER) {
        sheetObject_ = AceType::MakeRefPtr<SheetContentCoverObject>(sheetType_);
    } else {
        sheetObject_ = AceType::MakeRefPtr<SheetObject>(sheetType_);
    }
    sheetObject_->BindPattern(WeakClaim(this));
    // Don't process information here, such as events, etc
    // Because here only the SheetStyle is updated to the layoutProperty, but the properties are not parsed,
    // and the data is not updated to the pattern.
}

/**
 * @brief Update SheetObject according to the new SheetType
 *
 * UpdateSheetObject must be called after Update sheetType.
 *
 * UpdateSheetRender is a function which can handle the differentiating capabilities of 2in1.
 * The capabilities are include about default shadow, double border.
 * UpdateSheetObject must be called before UpdateSheetRender.
 * Default shadow and double border depend on new SheetObject.
 *
 * MarkModifyDone will be called after UpdateSheetRender.
 *
 * UpdateSheetType -> UpdateSheetObject -> UpdateSheetRender -> MarkModifyDone
 *
 * @param newType new SheetType
 */
void SheetPresentationPattern::UpdateSheetObject(SheetType newType)
{
    CHECK_NULL_VOID(sheetObject_);
    RefPtr<SheetObject> sheetObject = sheetObject_;
    if (sheetObject->GetSheetType() == newType) {
        return;
    }
    if (!sheetObject->CheckIfUpdateObject(newType)) {
        sheetObject->UpdateSheetType(newType);
        return;
    }
    if (newType == SheetType::SHEET_SIDE) {
        sheetObject = AceType::MakeRefPtr<SheetSideObject>(newType);
    } else if (newType == SheetType::SHEET_CONTENT_COVER) {
        sheetObject = AceType::MakeRefPtr<SheetContentCoverObject>(newType);
    } else {
        sheetObject = AceType::MakeRefPtr<SheetObject>(newType);
    }
    sheetObject->CopyData(sheetObject_);
    // start clear old sheet data
    RemovePanEvent();
    ResetScrollUserDefinedIdealSize(sheetObject_, sheetObject);
    ResetLayoutInfo();

    SetSheetObject(sheetObject);
    sheetObject_->BindPattern(WeakClaim(this));
    FireOnTypeDidChange();
    // start init new sheet data
    InitPanEvent();
    InitSheetMode();
    isFirstInit_ = false;
    AvoidAiBar();
}

void SheetPresentationPattern::UpdateBgColor(const RefPtr<ResourceObject>& resObj,
    const WeakPtr<FrameNode>& sheetNodeWK)
{
    auto sheetNode = sheetNodeWK.Upgrade();
    CHECK_NULL_VOID(sheetNode);
    // Parse the background olor using the resource object.
    Color backgroundColor;
    bool result = ResourceParseUtils::ParseResColor(resObj, backgroundColor);
    if (!result) {
        auto pipelineContext = sheetNode->GetContext();
        CHECK_NULL_VOID(pipelineContext);
        auto sheetTheme = pipelineContext->GetTheme<OHOS::Ace::NG::SheetTheme>();
        backgroundColor = (sheetTheme != nullptr) ? sheetTheme->GetSheetBackgoundColor() : backgroundColor;
    }

    // Update sheetStyle.
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    NG::SheetStyle currSheetStyle = sheetStyle;
    currSheetStyle.backgroundColor = backgroundColor;
    layoutProperty->UpdateSheetStyle(currSheetStyle);

    // Update sheet mask background color.
    auto renderContext = sheetNode->GetRenderContext();
    renderContext->UpdateBackgroundColor(backgroundColor);
    sheetNode->MarkModifyDone();
}

void SheetPresentationPattern::RegisterBgColorRes(
    const RefPtr<FrameNode>& sheetNode, RefPtr<ResourceObject>& colorResObj)
{
    CHECK_NULL_VOID(sheetNode);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    if (colorResObj) {
        auto&& updateFunc = [sheetNodeWK = AceType::WeakClaim(AceType::RawPtr(sheetNode)), weak = WeakClaim(this)]
            (const RefPtr<ResourceObject>& colorResObj) {
            auto pattern = weak.Upgrade();
            CHECK_NULL_VOID(pattern);
            pattern->UpdateBgColor(colorResObj, sheetNodeWK);
        };
        pattern->AddResObj("sheetPage.backgroundColor", colorResObj, std::move(updateFunc));
    } else {
        pattern->RemoveResObj("sheetPage.backgroundColor");
    }
}

void SheetPresentationPattern::RegisterRadiusRes(const RefPtr<FrameNode>& sheetNode)
{
    CHECK_NULL_VOID(sheetNode);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    auto sheetNodeWK = AceType::WeakClaim(AceType::RawPtr(sheetNode));
    auto&& updateFunc = [sheetNodeWK](const RefPtr<ResourceObject>& resObj) {
        auto sheetNode = sheetNodeWK.Upgrade();
        CHECK_NULL_VOID(sheetNode);
        auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
        CHECK_NULL_VOID(layoutProperty);
        auto sheetStyle = layoutProperty->GetSheetStyleValue();
        NG::SheetStyle currSheetStyle = sheetStyle;
        NG::BorderRadiusProperty radius;
        radius.multiValued = false;
        auto radiusResObj = sheetStyle.GetRadiusResObj();
        // Return directly when the developer does not set the resource type.
        if (!sheetStyle.radius->multiValued && !radiusResObj) {
            return;
        }
        if (sheetStyle.radius->multiValued) {
            // When multiValued is true, the value is set in multiple directions.
            // In this case, invoke ReloadResources to re-parse.
            radius = sheetStyle.radius.value();
            radius.ReloadResources();
        } else if (radiusResObj) {
            // When multiValued is false and resource object is not empty, same value in all directions.
            // In this case, parse the sheet radius using the resource object.
            CalcDimension radiusSingle;
            ResourceParseUtils::ParseResDimensionVpNG(radiusResObj, radiusSingle);
            radius.SetRadius(radiusSingle);
        }
        currSheetStyle.radius = radius;
        // Update sheet style and radius when radius changes.
        layoutProperty->UpdateSheetStyle(currSheetStyle);
        auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
        CHECK_NULL_VOID(pattern);
        pattern->ClipSheetNode();
        sheetNode->MarkModifyDone();
    };
    auto resObj = AceType::MakeRefPtr<ResourceObject>();
    pattern->AddResObj("sheetPage.radius", resObj, std::move(updateFunc));
}

void SheetPresentationPattern::UpdateBorderWidth(const RefPtr<FrameNode>& sheetNode)
{
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    NG::BorderWidthProperty borderWidth;
    auto widthResObj = sheetStyle.GetBorderWidthResObj();
    // Return directly when the developer does not set the resource type.
    if (!sheetStyle.borderWidth->multiValued && !widthResObj) {
        return;
    }
    if (sheetStyle.borderWidth->multiValued) {
        // When multiValued is true, the value is set in multiple directions.
        // In this case, invoke ReloadResources of border width to re-parse.
        borderWidth = sheetStyle.borderWidth.value();
        borderWidth.ReloadResources();
    } else if (widthResObj) {
        // When multiValued is false and resource object is not empty, same value in all directions.
        // In this case, parse the sheet border width using the resource object.
        CalcDimension borderWidthSingle;
        ResourceParseUtils::ParseResDimensionVpNG(widthResObj, borderWidthSingle);
        borderWidth = NG::BorderWidthProperty({ borderWidthSingle, borderWidthSingle,
            borderWidthSingle, borderWidthSingle, std::nullopt, std::nullopt});
    }
    // Update sheet style and border width when border width changes.
    NG::SheetStyle currSheetStyle = sheetStyle;
    currSheetStyle.borderWidth = borderWidth;
    layoutProperty->UpdateSheetStyle(currSheetStyle);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    borderWidth = pattern->GetSheetObject()->PostProcessBorderWidth(borderWidth);
    layoutProperty->UpdateBorderWidth(borderWidth);
    auto renderContext = sheetNode->GetRenderContext();
    CHECK_NULL_VOID(renderContext);
    renderContext->UpdateBorderWidth(borderWidth);
    sheetNode->MarkDirtyNode(PROPERTY_UPDATE_MEASURE_SELF);
}

void SheetPresentationPattern::UpdateBorderColor(const RefPtr<FrameNode>& sheetNode)
{
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    auto colorResObj = sheetStyle.GetBorderColorResObj();
    if (!sheetStyle.borderColor.has_value() || (!sheetStyle.borderColor->multiValued && !colorResObj)) {
        return;
    }
    // re-parse border color when needed
    NG::BorderColorProperty borderColor;
    if (sheetStyle.borderColor->multiValued) {
        // When multiValued is true, the value is set in multiple directions.
        // In this case, invoke ReloadResources of border Color to re-parse.
        borderColor = sheetStyle.borderColor.value();
        borderColor.ReloadResources();
    } else if (colorResObj) {
        // When multiValued is false and resource object is not empty, same value in all directions.
        // In this case, parse the sheet border color using the resource object.
        Color borderColorSingle;
        ResourceParseUtils::ParseResColor(colorResObj, borderColorSingle);
        borderColor.SetColor(borderColorSingle);
    }
    // Update sheet style and border color when border color changes.
    NG::SheetStyle currSheetStyle = sheetStyle;
    currSheetStyle.borderColor = borderColor;
    layoutProperty->UpdateSheetStyle(currSheetStyle);
    auto renderContext = sheetNode->GetRenderContext();
    CHECK_NULL_VOID(renderContext);
    renderContext->UpdateBorderColor(borderColor);
    sheetNode->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
}

void SheetPresentationPattern::RegisterBorderWidthOrColorRes(const RefPtr<FrameNode>& sheetNode)
{
    CHECK_NULL_VOID(sheetNode);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    auto&& updateFunc = [sheetNodeWK= AceType::WeakClaim(AceType::RawPtr(sheetNode)), weak = WeakClaim(this)]
        (const RefPtr<ResourceObject>& resObjWidth) {
        auto pattern = weak.Upgrade();
        CHECK_NULL_VOID(pattern);
        auto sheetNode = sheetNodeWK.Upgrade();
        CHECK_NULL_VOID(sheetNode);
        pattern->UpdateBorderWidth(sheetNode);
        pattern->UpdateBorderColor(sheetNode);
        sheetNode->MarkModifyDone();
    };
    auto resObj = AceType::MakeRefPtr<ResourceObject>();
    pattern->AddResObj("sheetPage.border", resObj, std::move(updateFunc));
}

void SheetPresentationPattern::HandleMultiDetentKeyboardAvoid()
{
    // This function is used to handle the scenario where the semi-modal multi-detent sheet switches to a higher detent
    // when avoiding the keyboard.
    // height_: Target height of the displacement
    // preDetentsHeight_: Height of the previous detent
    if (IsAvoidingKeyboard() && GreatNotEqual(height_, preDetentsHeight_)) {
        isScrolling_ = true;
    }
}

void SheetPresentationPattern::RegisterTitleRes(const RefPtr<FrameNode>& sheetNode,
    RefPtr<ResourceObject>& mainTitleResObj)
{
    CHECK_NULL_VOID(sheetNode);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    if (!mainTitleResObj) {
        pattern->RemoveResObj("sheetPage.title");
    }
    auto&& updateFunc =
        [sheetNodeWK = AceType::WeakClaim(AceType::RawPtr(sheetNode)),
            weak = WeakClaim(this)](const RefPtr<ResourceObject>& mainTitleResObj) {
        // Parse the sheet main title using the resource object.
        // Return when parse failed.
        std::string mainTitle;
        bool result = ResourceParseUtils::ParseResString(mainTitleResObj, mainTitle);
        CHECK_NULL_VOID(result);
        // Update sheetStyle.
        auto sheetNode = sheetNodeWK.Upgrade();
        CHECK_NULL_VOID(sheetNode);
        auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
        CHECK_NULL_VOID(layoutProperty);
        auto sheetStyle = layoutProperty->GetSheetStyleValue();
        NG::SheetStyle currSheetStyle = sheetStyle;
        currSheetStyle.sheetTitle = mainTitle;
        layoutProperty->UpdateSheetStyle(currSheetStyle);
        // Update sheet main title content.
        auto pattern = weak.Upgrade();
        CHECK_NULL_VOID(pattern);
        auto titleNode =
            AceType::DynamicCast<FrameNode>(ElementRegister::GetInstance()->GetNodeById(pattern->GetTitleId()));
        CHECK_NULL_VOID(titleNode);
        auto titleProp = titleNode->GetLayoutProperty<TextLayoutProperty>();
        CHECK_NULL_VOID(titleProp);
        titleProp->UpdateContent(mainTitle);
        titleNode->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
        sheetNode->MarkModifyDone();

        auto subTitleResObj = sheetStyle.GetSubTitleResObj();
        if (sheetStyle.sheetSubtitle.has_value() && subTitleResObj) {
            // Parse the sheet subtitle using the resource object.
            // Return when parse failed.
            std::string subTitle;
            bool result = ResourceParseUtils::ParseResString(subTitleResObj, subTitle);
            CHECK_NULL_VOID(result);
            // Update sheetStyle.
            currSheetStyle.sheetSubtitle = subTitle;
            layoutProperty->UpdateSheetStyle(currSheetStyle);
            // Update sheet subtitle content.
            auto subtitleNode =
                DynamicCast<FrameNode>(ElementRegister::GetInstance()->GetNodeById(pattern->GetSubtitleId()));
            CHECK_NULL_VOID(subtitleNode);
            auto subtitleProp = subtitleNode->GetLayoutProperty<TextLayoutProperty>();
            CHECK_NULL_VOID(subtitleProp);
            subtitleProp->UpdateContent(subTitle);
            subtitleNode->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
            sheetNode->MarkModifyDone();
        }
    };
    pattern->AddResObj("sheetPage.title", mainTitleResObj, std::move(updateFunc));
}

void SheetPresentationPattern::RegisterDetentSelectionRes(const RefPtr<FrameNode>& sheetNode,
    RefPtr<ResourceObject>& resObj)
{
    CHECK_NULL_VOID(sheetNode);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    if (resObj) {
        auto sheetNodeWK = AceType::WeakClaim(AceType::RawPtr(sheetNode));
        auto overlayWk = pattern->GetOverlay();
        auto&& updateFunc = [overlayWk, sheetNodeWK](const RefPtr<ResourceObject>& resObj) {
            auto sheetNode = sheetNodeWK.Upgrade();
            CHECK_NULL_VOID(sheetNode);
            auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
            CHECK_NULL_VOID(layoutProperty);
            auto sheetStyle = layoutProperty->GetSheetStyleValue();
            NG::SheetStyle currSheetStyle = sheetStyle;
            CalcDimension detentSelection;
            currSheetStyle.detentSelection->height.reset();
            currSheetStyle.detentSelection->sheetMode.reset();
            // Parse the sheet detentSelection using the resource object.
            bool result = ResourceParseUtils::ParseResDimensionVpNG(resObj, detentSelection);
            if (result) {
                currSheetStyle.detentSelection->height = detentSelection;
            } else {
                // Use the default detentSelection in sheetTheme for parse failed.
                auto pipelineContext = sheetNode->GetContext();
                CHECK_NULL_VOID(pipelineContext);
                auto sheetTheme = pipelineContext->GetTheme<OHOS::Ace::NG::SheetTheme>();
                CHECK_NULL_VOID(sheetTheme);
                currSheetStyle.detentSelection->sheetMode =
                    static_cast<NG::SheetMode>(sheetTheme->GetSheetHeightDefaultMode());
            }
            auto overlayManager = overlayWk.Upgrade();
            if (overlayManager) {
                // Update sheetpage when detentSelection changes.
                overlayManager->UpdateSheetPage(sheetNode, currSheetStyle);
            }
        };
        pattern->AddResObj("sheetPage.detentSelection", resObj, std::move(updateFunc));
    } else {
        pattern->RemoveResObj("sheetPage.detentSelection");
    }
}

void SheetPresentationPattern::RegisterShowCloseRes(const RefPtr<FrameNode>& sheetNode,
    RefPtr<ResourceObject>& showCloseResObj)
{
    CHECK_NULL_VOID(sheetNode);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    if (showCloseResObj) {
        auto sheetNodeWK = AceType::WeakClaim(AceType::RawPtr(sheetNode));
        auto&& updateFunc = [sheetNodeWK, weak = WeakClaim(this)](const RefPtr<ResourceObject>& showCloseResObj) {
            bool showCloseIcon = true;
            bool result = ResourceParseUtils::ParseResBool(showCloseResObj, showCloseIcon);
            auto sheetNode = sheetNodeWK.Upgrade();
            CHECK_NULL_VOID(sheetNode);
            if (!result) {
                // Use the default showCloseIcon in sheetTheme for parse failed.
                auto pipelineContext = sheetNode->GetContext();
                CHECK_NULL_VOID(pipelineContext);
                auto sheetTheme = pipelineContext->GetTheme<OHOS::Ace::NG::SheetTheme>();
                showCloseIcon = (sheetTheme != nullptr) ? sheetTheme->GetShowCloseIcon() : showCloseIcon;
            }

            // Update sheetStyle.
            auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
            CHECK_NULL_VOID(layoutProperty);
            auto sheetStyle = layoutProperty->GetSheetStyleValue();
            NG::SheetStyle currSheetStyle = sheetStyle;
            currSheetStyle.showCloseIcon = showCloseIcon;
            layoutProperty->UpdateSheetStyle(currSheetStyle);

            // Update sheet close icom visible status.
            auto pattern = weak.Upgrade();
            CHECK_NULL_VOID(pattern);
            auto sheetCloseIcon = pattern->GetSheetCloseIcon();
            CHECK_NULL_VOID(sheetCloseIcon);
            auto iconLayoutProperty = sheetCloseIcon->GetLayoutProperty();
            CHECK_NULL_VOID(iconLayoutProperty);
            iconLayoutProperty->UpdateVisibility(showCloseIcon ? VisibleType::VISIBLE : VisibleType::INVISIBLE);
            sheetCloseIcon->MarkDirtyNode(PROPERTY_UPDATE_RENDER);
            sheetNode->MarkModifyDone();
        };
        pattern->AddResObj("sheetPage.showClose", showCloseResObj, std::move(updateFunc));
    } else {
        pattern->RemoveResObj("sheetPage.showClose");
    }
}

void SheetPresentationPattern::RegisterHeightRes(const RefPtr<FrameNode>& sheetNode,
    RefPtr<ResourceObject>& resObj)
{
    CHECK_NULL_VOID(sheetNode);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    if (resObj) {
        auto sheetNodeWK = AceType::WeakClaim(AceType::RawPtr(sheetNode));
        auto overlayWk = pattern->GetOverlay();
        auto&& updateFunc = [overlayWk, sheetNodeWK](const RefPtr<ResourceObject>& resObj) {
            auto sheetNode = sheetNodeWK.Upgrade();
            CHECK_NULL_VOID(sheetNode);
            auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
            CHECK_NULL_VOID(layoutProperty);
            auto sheetStyle = layoutProperty->GetSheetStyleValue();
            NG::SheetStyle currSheetStyle = sheetStyle;
            CalcDimension sheetHeightValue;
            // Parse the sheet height using the resource object.
            bool result = ResourceParseUtils::ParseResDimensionVpNG(resObj, sheetHeightValue);
            currSheetStyle.sheetHeight.height.reset();
            currSheetStyle.sheetHeight.sheetMode.reset();
            if (result) {
                currSheetStyle.sheetHeight.height = sheetHeightValue;
            } else {
                // Use the default sheetMode in sheetTheme for parse failed.
                auto pipelineContext = sheetNode->GetContext();
                CHECK_NULL_VOID(pipelineContext);
                auto sheetTheme = pipelineContext->GetTheme<OHOS::Ace::NG::SheetTheme>();
                CHECK_NULL_VOID(sheetTheme);
                currSheetStyle.sheetHeight.sheetMode =
                    static_cast<NG::SheetMode>(sheetTheme->GetSheetHeightDefaultMode());
            }
            auto overlayManager = overlayWk.Upgrade();
            if (overlayManager) {
                // Update sheetpage when height changes.
                overlayManager->UpdateSheetPage(sheetNode, currSheetStyle);
            }
        };
        pattern->AddResObj("sheetPage.sheetHeight", resObj, std::move(updateFunc));
    } else {
        pattern->RemoveResObj("sheetPage.sheetHeight");
    }
}

void SheetPresentationPattern::RegisterWidthRes(const RefPtr<FrameNode>& sheetNode,
    RefPtr<ResourceObject>& resObj)
{
    CHECK_NULL_VOID(sheetNode);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    if (resObj) {
        auto sheetNodeWK = AceType::WeakClaim(AceType::RawPtr(sheetNode));
        auto overlayWk = pattern->GetOverlay();
        auto&& updateFunc = [overlayWk, weak = WeakClaim(this), sheetNodeWK](const RefPtr<ResourceObject>& resObj) {
            auto sheetNode = sheetNodeWK.Upgrade();
            CHECK_NULL_VOID(sheetNode);
            auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
            CHECK_NULL_VOID(layoutProperty);
            auto sheetStyle = layoutProperty->GetSheetStyleValue();
            NG::SheetStyle currSheetStyle = sheetStyle;
            CalcDimension width;
            // Parse the sheet width using the resource object.
            bool result = ResourceParseUtils::ParseResDimensionVpNG(resObj, width);
            if (result) {
                currSheetStyle.width = width;
            } else {
                // Use the default width in sheetTheme for parse failed,
                // when sheet type is SHEET_CENTER.
                auto pipeline = sheetNode->GetContext();
                CHECK_NULL_VOID(pipeline);
                auto sheetTheme = pipeline->GetTheme<SheetTheme>();
                auto pattern = weak.Upgrade();
                CHECK_NULL_VOID(pattern);
                currSheetStyle.width = ((sheetTheme != nullptr) && pattern->GetSheetTypeNoProcess() == SHEET_CENTER)
                    ? sheetTheme->GetCenterDefaultWidth()
                    : width;
            }
            auto overlayManager = overlayWk.Upgrade();
            if (overlayManager) {
                // Update sheetpage when width changes.
                overlayManager->UpdateSheetPage(sheetNode, currSheetStyle);
            }
        };
        pattern->AddResObj("sheetPage.width", resObj, std::move(updateFunc));
    } else {
        pattern->RemoveResObj("sheetPage.width");
    }
}

void SheetPresentationPattern::UpdateSheetDetents(const RefPtr<ResourceObject>& resObj,
    const WeakPtr<FrameNode>& sheetNodeWK, const WeakPtr<OverlayManager>& overlayWk)
{
    auto sheetNode = sheetNodeWK.Upgrade();
    CHECK_NULL_VOID(sheetNode);
    auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
    CHECK_NULL_VOID(layoutProperty);
    auto sheetStyle = layoutProperty->GetSheetStyleValue();
    NG::SheetStyle sheetStyleValue = sheetStyle;
    std::vector<RefPtr<ResourceObject>> resObjVector = sheetStyle.GetDetentsResObjs();
    std::vector<NG::SheetHeight> sheetDetents;
    for (const auto& resObj : resObjVector) {
        // Traverse resObjVector and parse each detents height resource.
        if (resObj == nullptr) {
            continue;
        }
        NG::SheetHeight sheetDetent;
        CalcDimension sheetHeightValue;
        bool result = ResourceParseUtils::ParseResDimensionVpNG(resObj, sheetHeightValue);
        if (result) {
            sheetDetent.height = sheetHeightValue;
        } else {
            // Use the default sheetMode in sheetTheme for parse failed.
            auto pipelineContext = sheetNode->GetContext();
            CHECK_NULL_VOID(pipelineContext);
            auto sheetTheme = pipelineContext->GetTheme<OHOS::Ace::NG::SheetTheme>();
            CHECK_NULL_VOID(sheetTheme);
            sheetDetent.sheetMode = static_cast<NG::SheetMode>(sheetTheme->GetSheetHeightDefaultMode());
        }
        sheetDetents.emplace_back(sheetDetent);
    }
    sheetStyleValue.detents = sheetDetents;
    auto overlayManager = overlayWk.Upgrade();
    if (overlayManager) {
        // Update sheetpage when detents changes.
        overlayManager->UpdateSheetPage(sheetNode, sheetStyleValue);
    }
}

void SheetPresentationPattern::RegisterDetentsRes(const RefPtr<FrameNode>& sheetNode,
    std::vector<RefPtr<ResourceObject>>& resObjVec)
{
    CHECK_NULL_VOID(sheetNode);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    bool isNeedRegisterRes =
        !resObjVec.empty() &&
            std::any_of(resObjVec.begin(), resObjVec.end(), [](const RefPtr<ResourceObject>& resObj) {
        return resObj != nullptr;
    });
    if (isNeedRegisterRes) {
        RefPtr<ResourceObject> resObject = AceType::MakeRefPtr<ResourceObject>();
        auto sheetNodeWK = AceType::WeakClaim(AceType::RawPtr(sheetNode));
        auto overlayWk = pattern->GetOverlay();
        auto&& updateFunc = [overlayWk, sheetNodeWK, weak = WeakClaim(this)]
            (const RefPtr<ResourceObject>& resObject) {
            auto pattern = weak.Upgrade();
            CHECK_NULL_VOID(pattern);
            pattern->UpdateSheetDetents(resObject, sheetNodeWK, overlayWk);
        };
        pattern->AddResObj("sheetPage.sheetDetents", resObject, std::move(updateFunc));
    } else {
        pattern->RemoveResObj("sheetPage.sheetDetents");
    }
}

void SheetPresentationPattern::RegisterShadowRes(const RefPtr<FrameNode>& sheetNode)
{
    CHECK_NULL_VOID(sheetNode);
    auto pattern = sheetNode->GetPattern<SheetPresentationPattern>();
    CHECK_NULL_VOID(pattern);
    auto sheetNodeWK = AceType::WeakClaim(AceType::RawPtr(sheetNode));
    auto&& updateFunc = [sheetNodeWK](const RefPtr<ResourceObject>& resObj) {
        auto sheetNode = sheetNodeWK.Upgrade();
        CHECK_NULL_VOID(sheetNode);
        auto layoutProperty = DynamicCast<SheetPresentationProperty>(sheetNode->GetLayoutProperty());
        CHECK_NULL_VOID(layoutProperty);
        auto sheetStyle = layoutProperty->GetSheetStyleValue();
        NG::SheetStyle currSheetStyle = sheetStyle;
        std::optional<Shadow> shadow;
        if (sheetStyle.shadow.has_value()) {
            // If the shadow in the sheetstyle is not empty,
            // reload the shadow to update its value.
            shadow = sheetStyle.shadow.value();
            shadow->ReloadResources();
            currSheetStyle.shadow = shadow;
            layoutProperty->UpdateSheetStyle(currSheetStyle);
            auto renderContext = sheetNode->GetRenderContext();
            CHECK_NULL_VOID(renderContext);
            renderContext->UpdateBackShadow(shadow.value());
            sheetNode->MarkModifyDone();
        }
    };
    RefPtr<ResourceObject> resObj = AceType::MakeRefPtr<ResourceObject>();
    pattern->AddResObj("sheetPage.shadow", resObj, std::move(updateFunc));
}

void SheetPresentationPattern::UpdateSheetParamResource(const RefPtr<FrameNode>& sheetNode,
    NG::SheetStyle& sheetStyle)
{
    if (sheetStyle.sheetHeight.height.has_value()) {
        auto resObj = sheetStyle.GetSheetHeightResObj();
        RegisterHeightRes(sheetNode, resObj);
    }
    if (!sheetStyle.detents.empty()) {
        auto resObjVec = sheetStyle.GetDetentsResObjs();
        RegisterDetentsRes(sheetNode, resObjVec);
    }
    if (sheetStyle.detentSelection.has_value()) {
        auto resObj = sheetStyle.GetDetentSelectionResObj();
        RegisterDetentSelectionRes(sheetNode, resObj);
    }
    if (sheetStyle.showCloseIcon.has_value()) {
        auto resObj = sheetStyle.GetShowCloseResObj();
        RegisterShowCloseRes(sheetNode, resObj);
    }
    if (sheetStyle.sheetTitle.has_value()) {
        auto mainTitleResObj = sheetStyle.GetMainTitleResObj();
        RegisterTitleRes(sheetNode, mainTitleResObj);
    }
    if (sheetStyle.width.has_value()) {
        auto resObj = sheetStyle.GetSheetWidthResObj();
        RegisterWidthRes(sheetNode, resObj);
    }
    if (sheetStyle.backgroundColor.has_value()) {
        auto resObj = sheetStyle.GetBackgroundColorResObj();
        RegisterBgColorRes(sheetNode, resObj);
    }
    if (sheetStyle.borderWidth.has_value()) {
        RegisterBorderWidthOrColorRes(sheetNode);
    }
    if (sheetStyle.radius.has_value()) {
        RegisterRadiusRes(sheetNode);
    }
    if (sheetStyle.shadow.has_value()) {
        RegisterShadowRes(sheetNode);
    }
}

void SheetPresentationPattern::ResetLayoutInfo()
{
    height_ = 0.0f;
    property_.Reset();
    animation_.reset();
}

void SheetPresentationPattern::ResetScrollUserDefinedIdealSize(
    const RefPtr<SheetObject>& oldObject, const RefPtr<SheetObject>& newObject)
{
    CHECK_NULL_VOID(oldObject);
    CHECK_NULL_VOID(newObject);
    if (newObject->GetSheetType() != SheetType::SHEET_SIDE) {
        return;
    }
    auto scrollNode = GetSheetScrollNode();
    CHECK_NULL_VOID(scrollNode);
    auto props = scrollNode->GetLayoutProperty();
    CHECK_NULL_VOID(props);
    props->ClearUserDefinedIdealSize(true, true);
}

void SheetPresentationPattern::OnLanguageConfigurationUpdate()
{
    sheetObject_->OnLanguageConfigurationUpdate();
}
} // namespace OHOS::Ace::NG