OpenHarmony-v4.1-Release/s

/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_PATTERN_H
#define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_PATTERN_H

#include <optional>

#include "base/geometry/ng/rect_t.h"
#include "base/memory/ace_type.h"
#include "base/memory/referenced.h"
#include "base/utils/noncopyable.h"
#include "base/view_data/view_data_wrap.h"
#include "core/common/recorder/event_recorder.h"
#include "core/components_ng/base/frame_node.h"
#include "core/components_ng/event/event_hub.h"
#include "core/components_ng/layout/layout_property.h"
#include "core/components_ng/property/property.h"
#include "core/components_ng/render/node_paint_method.h"
#include "core/components_ng/render/paint_property.h"
#include "core/event/pointer_event.h"

namespace OHOS::Accessibility {
class AccessibilityElementInfo;
class AccessibilityEventInfo;
}

namespace OHOS::Ace::NG {
struct DirtySwapConfig {
    bool frameSizeChange = false;
    bool frameOffsetChange = false;
    bool contentSizeChange = false;
    bool contentOffsetChange = false;
    bool skipMeasure = false;
    bool skipLayout = false;
};

class ScrollingListener : public AceType {
    DECLARE_ACE_TYPE(ScrollingListener, AceType);

public:
    explicit ScrollingListener(std::function<void()>&& callback) : callback_(std::move(callback)) {}

    ~ScrollingListener() override = default;

    void NotifyScrollingEvent()
    {
        if (callback_) {
            callback_();
        }
    }

private:
    std::function<void()> callback_;
};

// Pattern is the base class for different measure, layout and paint behavior.
class Pattern : public virtual AceType {
    DECLARE_ACE_TYPE(Pattern, AceType);

public:
    Pattern() = default;
    ~Pattern() override = default;

    // atomic node is like button, image, custom node and so on.
    // In ets UI compiler, the atomic node does not Add Pop function, only have Create function.
    virtual bool IsAtomicNode() const
    {
        return true;
    }

    virtual bool StopExpandMark()
    {
        return false;
    }

    // The pattern needs softkeyboard is like search, rich editor, text area, text field pattern.
    virtual bool NeedSoftKeyboard() const
    {
        return false;
    }

    virtual bool DefaultSupportDrag()
    {
        return false;
    }

    virtual std::optional<RenderContext::ContextParam> GetContextParam() const
    {
        return std::nullopt;
    }

    void DetachFromFrameNode(FrameNode* frameNode)
    {
        OnDetachFromFrameNode(frameNode);
        frameNode_.Reset();
    }

    void AttachToFrameNode(const WeakPtr<FrameNode>& frameNode)
    {
        if (frameNode_ == frameNode) {
            return;
        }
        frameNode_ = frameNode;
        OnAttachToFrameNode();
    }

    virtual RefPtr<AccessibilityProperty> CreateAccessibilityProperty()
    {
        return MakeRefPtr<AccessibilityProperty>();
    }

    virtual RefPtr<PaintProperty> CreatePaintProperty()
    {
        return MakeRefPtr<PaintProperty>();
    }

    virtual RefPtr<LayoutProperty> CreateLayoutProperty()
    {
        return MakeRefPtr<LayoutProperty>();
    }

    virtual RefPtr<LayoutAlgorithm> CreateLayoutAlgorithm()
    {
        return MakeRefPtr<BoxLayoutAlgorithm>();
    }

    virtual RefPtr<NodePaintMethod> CreateNodePaintMethod()
    {
        return nullptr;
    }

    virtual std::optional<RectF> GetOverridePaintRect() const
    {
        return std::nullopt;
    }

    virtual RefPtr<EventHub> CreateEventHub()
    {
        return MakeRefPtr<EventHub>();
    }

    virtual void OnContextAttached() {}

    virtual void OnModifyDone()
    {
#if (defined(__aarch64__) || defined(__x86_64__))
        FrameNode::PostTask(
            [weak = WeakClaim(this)]() {
                if (Recorder::EventRecorder::Get().IsComponentRecordEnable()) {
                    auto pattern = weak.Upgrade();
                    CHECK_NULL_VOID(pattern);
                    pattern->OnAfterModifyDone();
                }
            },
            TaskExecutor::TaskType::UI);
        if (IsNeedInitClickEventRecorder()) {
            InitClickEventRecorder();
        }
#endif
        auto frameNode = frameNode_.Upgrade();
        auto children = frameNode->GetChildren();
        if (children.empty()) {
            return;
        }
        auto renderContext = frameNode->GetRenderContext();
        if (!renderContext->HasForegroundColor() && !renderContext->HasForegroundColorStrategy()) {
            return;
        }
        std::list<RefPtr<FrameNode>> childrenList {};
        std::queue<RefPtr<FrameNode>> queue {};
        queue.emplace(frameNode);
        RefPtr<FrameNode> parentNode;
        while (!queue.empty()) {
            parentNode = queue.front();
            queue.pop();
            auto childs = parentNode->GetChildren();
            if (childs.empty()) {
                continue;
            }
            for (auto child : childs) {
                if (!AceType::InstanceOf<NG::FrameNode>(child)) {
                    continue;
                }
                auto childFrameNode = AceType::DynamicCast<FrameNode>(child);
                auto childRenderContext = childFrameNode->GetRenderContext();
                if (childRenderContext->HasForegroundColorFlag() && childRenderContext->GetForegroundColorFlagValue()) {
                    continue;
                }
                queue.emplace(childFrameNode);
                childrenList.emplace_back(childFrameNode);
            }
        }
        bool isForegroundColor = renderContext->HasForegroundColor();
        for (auto child : childrenList) {
            auto childRenderContext = child->GetRenderContext();
            if (!childRenderContext->HasForegroundColor() && !childRenderContext->HasForegroundColorStrategy()) {
                if (isForegroundColor) {
                    childRenderContext->UpdateForegroundColor(renderContext->GetForegroundColorValue());
                    childRenderContext->ResetForegroundColorStrategy();
                    childRenderContext->UpdateForegroundColorFlag(false);
                } else {
                    childRenderContext->UpdateForegroundColorStrategy(renderContext->GetForegroundColorStrategyValue());
                    childRenderContext->ResetForegroundColor();
                    childRenderContext->UpdateForegroundColorFlag(false);
                }
            } else {
                if (!childRenderContext->HasForegroundColorFlag()) {
                    continue;
                }
                if (childRenderContext->GetForegroundColorFlagValue()) {
                    continue;
                }
                if (isForegroundColor) {
                    childRenderContext->UpdateForegroundColor(renderContext->GetForegroundColorValue());
                    childRenderContext->ResetForegroundColorStrategy();
                    childRenderContext->UpdateForegroundColorFlag(false);
                } else {
                    childRenderContext->UpdateForegroundColorStrategy(renderContext->GetForegroundColorStrategyValue());
                    childRenderContext->ResetForegroundColor();
                    childRenderContext->UpdateForegroundColorFlag(false);
                }
            }
        }
    }

    virtual void OnAfterModifyDone() {}

    virtual void OnMountToParentDone() {}

    virtual bool IsRootPattern() const
    {
        return false;
    }

    virtual bool IsMeasureBoundary() const
    {
        return false;
    }

    virtual bool IsRenderBoundary() const
    {
        return true;
    }

    virtual void UpdateScrollOffset(SizeF /* frameSize */) {}

    // TODO: for temp use, need to delete this.
    virtual bool OnDirtyLayoutWrapperSwap(
        const RefPtr<LayoutWrapper>& /*dirty*/, bool /*skipMeasure*/, bool /*skipLayout*/)
    {
        return false;
    }

    // Called on main thread to check if need rerender of the content.
    virtual bool OnDirtyLayoutWrapperSwap(
        const RefPtr<LayoutWrapper>& /*dirty*/, const DirtySwapConfig& /*changeConfig*/)
    {
        return false;
    }

    virtual bool UsResRegion()
    {
        return true;
    }

    std::optional<SizeF> GetHostFrameSize() const
    {
        auto frameNode = frameNode_.Upgrade();
        if (!frameNode) {
            return std::nullopt;
        }
        return frameNode->GetGeometryNode()->GetMarginFrameSize();
    }

    std::optional<OffsetF> GetHostFrameOffset() const
    {
        auto frameNode = frameNode_.Upgrade();
        if (!frameNode) {
            return std::nullopt;
        }
        return frameNode->GetGeometryNode()->GetFrameOffset();
    }

    std::optional<OffsetF> GetHostFrameGlobalOffset() const
    {
        auto frameNode = frameNode_.Upgrade();
        if (!frameNode) {
            return std::nullopt;
        }
        return frameNode->GetGeometryNode()->GetFrameOffset() + frameNode->GetGeometryNode()->GetParentGlobalOffset();
    }

    std::optional<SizeF> GetHostContentSize() const
    {
        auto frameNode = frameNode_.Upgrade();
        if (!frameNode) {
            return std::nullopt;
        }
        const auto& content = frameNode->GetGeometryNode()->GetContent();
        if (!content) {
            return std::nullopt;
        }
        return content->GetRect().GetSize();
    }

    RefPtr<FrameNode> GetHost() const
    {
        return frameNode_.Upgrade();
    }

    virtual void DumpInfo() {}
    virtual void DumpAdvanceInfo() {}
    virtual void DumpViewDataPageNode(RefPtr<ViewDataWrap> viewDataWrap) {}
    virtual void NotifyFillRequestSuccess(RefPtr<PageNodeInfoWrap> nodeWrap, AceAutoFillType autoFillType) {}
    virtual void NotifyFillRequestFailed(int32_t errCode) {}
    virtual bool CheckAutoSave()
    {
        return false;
    }

    template<typename T>
    RefPtr<T> GetLayoutProperty() const
    {
        auto host = GetHost();
        CHECK_NULL_RETURN(host, nullptr);
        return DynamicCast<T>(host->GetLayoutProperty<T>());
    }

    template<typename T>
    RefPtr<T> GetPaintProperty() const
    {
        auto host = GetHost();
        CHECK_NULL_RETURN(host, nullptr);
        return DynamicCast<T>(host->GetPaintProperty<T>());
    }

    template<typename T>
    RefPtr<T> GetEventHub() const
    {
        auto host = GetHost();
        CHECK_NULL_RETURN(host, nullptr);
        return DynamicCast<T>(host->GetEventHub<T>());
    }

    // Called after frameNode RebuildRenderContextTree.
    virtual void OnRebuildFrame() {}
    // Called before frameNode CreateLayoutWrapper.
    virtual void BeforeCreateLayoutWrapper() {}
    // Called before frameNode CreatePaintWrapper.
    virtual void BeforeCreatePaintWrapper() {}

    virtual FocusPattern GetFocusPattern() const
    {
        return { FocusType::DISABLE, false, FocusStyleType::NONE };
    }

    virtual ScopeFocusAlgorithm GetScopeFocusAlgorithm()
    {
        return ScopeFocusAlgorithm();
    }

    virtual bool ScrollToNode(const RefPtr<FrameNode>& focusFrameNode)
    {
        return false;
    }

    virtual int32_t GetFocusNodeIndex(const RefPtr<FocusHub>& focusNode)
    {
        return -1;
    }

    virtual void ScrollToFocusNodeIndex(int32_t index) {}

    // out of viewport or visible is none or gone.
    virtual void OnInActive() {}
    virtual void OnActive() {}

    // called by window life cycle.
    virtual void OnWindowShow() {}
    virtual void OnWindowHide() {}
    virtual void OnWindowFocused() {}
    virtual void OnWindowUnfocused() {}
    virtual void OnPixelRoundFinish(const SizeF& pixelGridRoundSize) {}
    virtual void OnWindowSizeChanged(int32_t width, int32_t height, WindowSizeChangeReason type) {}
    virtual void OnNotifyMemoryLevel(int32_t level) {}

    // get XTS inspector value
    virtual void ToJsonValue(std::unique_ptr<JsonValue>& json) const {}

    // call by recycle framework.
    virtual void OnRecycle() {}
    virtual void OnReuse() {}

    virtual void OnAttachToMainTree() {}
    virtual void OnAttachToBuilderNode(NodeStatus nodeStatus) {}

    virtual void OnDetachFromMainTree() {}

    virtual void FromJson(const std::unique_ptr<JsonValue>& json) {}

    virtual void OnAreaChangedInner() {}
    virtual void OnVisibleChange(bool isVisible) {}
    virtual std::string ProvideRestoreInfo()
    {
        return "";
    }

    virtual void OnRestoreInfo(const std::string& restoreInfo) {}

    virtual bool IsNeedAdjustByAspectRatio()
    {
        auto host = GetHost();
        CHECK_NULL_RETURN(host, false);
        auto layoutProperty = host->GetLayoutProperty();
        CHECK_NULL_RETURN(host, false);
        return layoutProperty->HasAspectRatio();
    }

    virtual void OnTouchTestHit(SourceType hitTestType) {}

    virtual int32_t GetDragRecordSize()
    {
        return -1;
    }

    virtual void HandleOnDragStatusCallback(
        const DragEventType& dragEventType, const RefPtr<NotifyDragEvent>& notifyDragEvent) {};

    virtual void HandleDragEvent(const PointerEvent& info) {};
    virtual void OnLanguageConfigurationUpdate() {}
    virtual void OnColorConfigurationUpdate() {}
    virtual void OnDirectionConfigurationUpdate() {}
    virtual void OnDpiConfigurationUpdate() {}
    virtual void OnIconConfigurationUpdate() {}

    virtual bool ShouldDelayChildPressedState() const
    {
        return false;
    }

    virtual void RegisterScrollingListener(const RefPtr<ScrollingListener> listener) {}
    virtual void FireAndCleanScrollingListener() {}
    virtual void CleanScrollingListener() {}
    virtual void ResetDragOption() {}

    virtual int64_t WrapExtensionAbilityId(int64_t extensionOffset, int64_t abilityId)
    {
        return -1;
    }

    virtual void SearchExtensionElementInfoByAccessibilityId(int64_t elementId, int32_t mode,
        int64_t baseParent, std::list<Accessibility::AccessibilityElementInfo>& output) {}
    virtual void SearchElementInfosByText(int64_t elementId, const std::string& text,
        int64_t baseParent, std::list<Accessibility::AccessibilityElementInfo>& output) {}
    virtual void FindFocusedElementInfo(int64_t elementId, int32_t focusType,
        int64_t baseParent, Accessibility::AccessibilityElementInfo& output) {}
    virtual void FocusMoveSearch(int64_t elementId, int32_t direction,
        int64_t baseParent, Accessibility::AccessibilityElementInfo& output) {}
    virtual bool TransferExecuteAction(
        int64_t elementId, const std::map<std::string, std::string>& actionArguments, int32_t action, int64_t offset)
    {
        return false;
    }

    virtual int32_t GetUiExtensionId()
    {
        return -1;
    }

    GestureEventFunc GetLongPressEventRecorder()
    {
        auto longPressCallback = [weak = WeakClaim(this)](GestureEvent& info) {
            if (!Recorder::EventRecorder::Get().IsComponentRecordEnable()) {
                return;
            }
            auto pattern = weak.Upgrade();
            CHECK_NULL_VOID(pattern);
            auto host = pattern->GetHost();
            CHECK_NULL_VOID(host);
            auto inspectorId = host->GetInspectorId().value_or("");
            auto text = host->GetAccessibilityProperty<NG::AccessibilityProperty>()->GetAccessibilityText(true);
            auto desc = host->GetAutoEventParamValue("");
            if (inspectorId.empty() && text.empty() && desc.empty()) {
                return;
            }

            Recorder::EventParamsBuilder builder;
            builder.SetId(inspectorId)
                .SetType(host->GetTag())
                .SetEventType(Recorder::LONG_PRESS)
                .SetText(text)
                .SetDescription(desc);
            Recorder::EventRecorder::Get().OnEvent(std::move(builder));
        };
        return longPressCallback;
    }

protected:
    virtual void OnAttachToFrameNode() {}
    virtual void OnDetachFromFrameNode(FrameNode* frameNode) {}

    virtual bool IsNeedInitClickEventRecorder() const
    {
        return false;
    }

    void InitClickEventRecorder()
    {
        if (clickCallback_) {
            return;
        }

        auto host = GetHost();
        CHECK_NULL_VOID(host);
        auto gesture = host->GetOrCreateGestureEventHub();
        CHECK_NULL_VOID(gesture);
        if (!gesture->IsClickable()) {
            return;
        }

        auto clickCallback = [weak = WeakClaim(this)](GestureEvent& info) {
            if (!Recorder::EventRecorder::Get().IsComponentRecordEnable()) {
                return;
            }
            auto pattern = weak.Upgrade();
            CHECK_NULL_VOID(pattern);
            auto host = pattern->GetHost();
            CHECK_NULL_VOID(host);
            auto inspectorId = host->GetInspectorId().value_or("");
            auto text = host->GetAccessibilityProperty<NG::AccessibilityProperty>()->GetAccessibilityText(true);
            auto desc = host->GetAutoEventParamValue("");
            if (inspectorId.empty() && text.empty() && desc.empty()) {
                return;
            }

            Recorder::EventParamsBuilder builder;
            builder.SetId(inspectorId).SetType(host->GetTag()).SetText(text).SetDescription(desc);
            Recorder::EventRecorder::Get().OnClick(std::move(builder));
        };
        clickCallback_ = MakeRefPtr<ClickEvent>(std::move(clickCallback));
        gesture->AddClickEvent(clickCallback_);
    }

    WeakPtr<FrameNode> frameNode_;
    RefPtr<ClickEvent> clickCallback_;

private:
    ACE_DISALLOW_COPY_AND_MOVE(Pattern);
};
} // namespace OHOS::Ace::NG

#endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_PATTERN_H