@react-native-ohos/flash-list 1.8.3-rc.2 → 1.8.3-rc.4

package/harmony/flash_list/src/main/cpp/AutoLayoutNode.cpp

@@ -1,140 +1,63 @@
-/**
- * MIT License
- *
- * Copyright (C) 2024 Huawei Device Co., Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include <react/renderer/components/view/ViewProps.h>
-#include <glog/logging.h>
-#include <sys/param.h>
-#include <thread>
-#include "AutoLayoutShadow.h"
-#include <random>
-
-namespace rnoh {
-
-/**checks for overlaps or gaps.between adjacent items and then applies a correction (Only Grid layouts with varying
- * spans) Performance: RecyclerListView renders very small number of views and this is not going to trigger multiple
- * layouts on Android side. Not expecting any major perf issu.*/
-void AutoLayoutShadow::clearGapsAndOverlaps(std::vector<CellContainerComponentInstance::Shared> sortedItems) {
-    if (sortedItems.empty()) {
-        return;
-    }
-    Float maxBound = 0;
-    Float minBound = INT_MAX;
-    Float maxBoundNeighbour = 0;
-    lastMaxBoundOverall = 0;
-    for (int i = 0; i < sortedItems.size() - 1; i++) {
-        auto cell = sortedItems[i];
-        auto neighbour = sortedItems[i + 1];
-        std::optional<facebook::react::LayoutMetrics> neighbourMetrics;
-        // Only apply correction if the next cell is consecutive.
-        bool isNeighbourConsecutive = neighbour->getIndex() == cell->getIndex() + 1;
-        if (isWithinBounds(cell->getLayoutMetrics())) {
-            if (!horizontal) {
-                maxBound = MAX(maxBound, cell->getBottom());
-                minBound = MIN(minBound, cell->getTop());
-                maxBoundNeighbour = maxBound;
-                if (isNeighbourConsecutive) {
-                    neighbourMetrics = neighbour->getLayoutMetrics();
-                    if (cell->getLeft() < neighbour->getLeft()) {
-                        if (cell->getRight() != neighbour->getLeft()) {
-                            neighbourMetrics.value().frame.origin.x = cell->getRight();
-                        }
-                        if (cell->getTop() != neighbour->getTop()) {
-                            neighbourMetrics.value().frame.origin.y = cell->getTop();
-                        }
-                    } else {
-                        neighbourMetrics.value().frame.origin.y = maxBound;
-                    }
-                }
-                if (isWithinBounds(*neighbourMetrics)) {
-                    float bottom = neighbourMetrics->frame.origin.y + neighbourMetrics->frame.size.height;
-                    maxBoundNeighbour = MAX(maxBound, bottom);
-                }
-            } else {
-                maxBound = MAX(maxBound, cell->getRight());
-                minBound = MIN(minBound, cell->getLeft());
-                maxBoundNeighbour = maxBound;
-                if (isNeighbourConsecutive) {
-                    neighbourMetrics = neighbour->getLayoutMetrics();
-                    if (cell->getTop() < neighbour->getTop()) {
-                        if (cell->getBottom() != neighbour->getTop()) {
-                            neighbourMetrics.value().frame.origin.y = cell->getBottom();
-                        }
-                        if (cell->getLeft() != neighbour->getLeft()) {
-                            neighbourMetrics.value().frame.origin.x = cell->getLeft();
-                        }
-                    } else {
-                        neighbourMetrics.value().frame.origin.x = maxBound;
-                    }
-                }
-                if (isWithinBounds(*neighbourMetrics)) {
-                    float right = neighbourMetrics->frame.origin.x + neighbourMetrics->frame.size.width;
-                    maxBoundNeighbour = MAX(maxBound, right);
-                }
-            }
-        }
-        if (horizontal) {
-            lastMaxBoundOverall = MAX(lastMaxBoundOverall, cell->getRight());
-            float right = neighbourMetrics->frame.origin.x + neighbourMetrics->frame.size.width;
-            lastMaxBoundOverall = MAX(lastMaxBoundOverall, neighbour->getRight());
-        } else {
-            lastMaxBoundOverall = MAX(lastMaxBoundOverall, cell->getBottom());
-            float bottom = neighbourMetrics->frame.origin.y + neighbourMetrics->frame.size.height;
-            lastMaxBoundOverall = MAX(lastMaxBoundOverall, bottom);
-        }
-        cell->setLayout(cell->getLayoutMetrics());
-        neighbour->setLayout(neighbourMetrics ? neighbourMetrics.value() : neighbour->getLayoutMetrics());
-    }
-    lastMaxBound = maxBoundNeighbour;
-    lastMinBound = minBound;
-}
-
-/** Offset provider by react can be one frame behind the real one, it's important that this method is called with
- * offset taken directly from scrollview object*/
-Float AutoLayoutShadow::computeBlankFromGivenOffset(Float actualScrollOffset, Float distanceFromWindowStart,
-                                                    Float distanceFromWindowEnd) {
-    blankOffsetAtStart = lastMinBound - actualScrollOffset - distanceFromWindowStart;
-    blankOffsetAtEnd = actualScrollOffset + windowSize - renderOffset - lastMaxBound - distanceFromWindowEnd;
-    return MAX(blankOffsetAtStart, blankOffsetAtEnd);
-}
-
-/**It's importance to aviod correcting views outside the render window. An item that isn't being recycled might
- * still remain in the view tree. If views outside get considered then gaps between unused items will cause
- * algorithm to fail.*/
-bool AutoLayoutShadow::isWithinBounds(const facebook::react::LayoutMetrics& metrics) {
-    auto boundsStart = scrollOffset - renderOffset;
-    auto boundsEnd = scrollOffset + windowSize;
-    float top = metrics.frame.origin.y;
-    float bottom = metrics.frame.origin.y + metrics.frame.size.height;
-    float left = metrics.frame.origin.x;
-    float right = metrics.frame.origin.x + metrics.frame.size.width;
-    
-    if (!this->horizontal) {
-        return (top >= boundsStart || bottom >= boundsStart) &&
-               (top <= boundsEnd || bottom <= boundsEnd);
-    } else {
-        return (left >= boundsStart || right >= boundsStart) &&
-               (left <= boundsEnd || right <= boundsEnd);
-    }
-}
-} // namespace rnoh
+/**
+ * MIT License
+ *
+ * Copyright (C) 2024 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "AutoLayoutNode.h"
+#include <memory>
+#include <glog/logging.h>
+
+namespace rnoh {
+
+AutoLayoutNode::AutoLayoutNode()
+    : ArkUINode(NativeNodeApi::getInstance()->createNode(ArkUI_NodeType::ARKUI_NODE_STACK)) {
+    maybeThrow(NativeNodeApi::getInstance()->registerNodeEvent(m_nodeHandle, NODE_EVENT_ON_APPEAR, 0, this));
+}
+
+void AutoLayoutNode::insertChild(ArkUINode &child, std::size_t index) {
+    maybeThrow(NativeNodeApi::getInstance()->insertChildAt(m_nodeHandle, child.getArkUINodeHandle(), index));
+}
+
+void AutoLayoutNode::removeChild(ArkUINode &child) {
+    maybeThrow(NativeNodeApi::getInstance()->removeChild(m_nodeHandle, child.getArkUINodeHandle()));
+}
+
+void AutoLayoutNode::onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs) {
+    if (eventType == ArkUI_NodeEventType::NODE_EVENT_ON_APPEAR) {
+        m_autoLayoutNodeDelegate->onAppear();
+    }
+}
+
+void AutoLayoutNode::setAutoLayoutNodeDelegate(AutoLayoutNodeDelegate *scrollNodeDelegate) {
+    m_autoLayoutNodeDelegate = scrollNodeDelegate;
+}
+
+AutoLayoutNode::~AutoLayoutNode() {
+    NativeNodeApi::getInstance()->unregisterNodeEvent(m_nodeHandle, NODE_EVENT_ON_APPEAR);
+}
+
+void AutoLayoutNode::setAlign(int32_t align) {
+    ArkUI_NumberValue value[] = {{.i32 = align}};
+    ArkUI_AttributeItem item = {.value = value, .size = 1};
+    maybeThrow(NativeNodeApi::getInstance()->setAttribute(m_nodeHandle, NODE_STACK_ALIGN_CONTENT, &item));
+}
+} // namespace rnoh

package/harmony/flash_list/src/main/cpp/AutoLayoutNode.h

@@ -1,54 +1,54 @@
-/**
- * MIT License
- *
- * Copyright (C) 2024 Huawei Device Co., Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#pragma once
-
-#include "RNOH/arkui/ArkUINode.h"
-#include "RNOH/arkui/NativeNodeApi.h"
-
-namespace rnoh {
-
-class AutoLayoutNodeDelegate {
-public:
-    virtual ~AutoLayoutNodeDelegate() = default;
-    virtual void onAppear(){};
-    virtual void emitBlankAreaEvent(){};
-};
-
-class AutoLayoutNode : public ArkUINode {
-protected:
-    AutoLayoutNodeDelegate *m_autoLayoutNodeDelegate;
-
-public:
-    AutoLayoutNode();
-    ~AutoLayoutNode() override;
-
-    void insertChild(ArkUINode &child, std::size_t index);
-    void removeChild(ArkUINode &child);
-    void onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs) override;
-    void setAutoLayoutNodeDelegate(AutoLayoutNodeDelegate *autoLayoutNodeDelegate);
-    void setAlign(int32_t align);
-};
-
+/**
+ * MIT License
+ *
+ * Copyright (C) 2024 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include "RNOH/arkui/ArkUINode.h"
+#include "RNOH/arkui/NativeNodeApi.h"
+
+namespace rnoh {
+
+class AutoLayoutNodeDelegate {
+public:
+    virtual ~AutoLayoutNodeDelegate() = default;
+    virtual void onAppear(){};
+    virtual void emitBlankAreaEvent(){};
+};
+
+class AutoLayoutNode : public ArkUINode {
+protected:
+    AutoLayoutNodeDelegate *m_autoLayoutNodeDelegate;
+
+public:
+    AutoLayoutNode();
+    ~AutoLayoutNode() override;
+
+    void insertChild(ArkUINode &child, std::size_t index);
+    void removeChild(ArkUINode &child);
+    void onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs) override;
+    void setAutoLayoutNodeDelegate(AutoLayoutNodeDelegate *autoLayoutNodeDelegate);
+    void setAlign(int32_t align);
+};
+
 } // namespace rnoh

package/harmony/flash_list/src/main/cpp/AutoLayoutShadow.cpp

@@ -27,6 +27,7 @@
 #include <sys/param.h>
 #include <thread>
 #include "AutoLayoutShadow.h"
+#include <random>
 
 namespace rnoh {
 
@@ -44,64 +45,65 @@ void AutoLayoutShadow::clearGapsAndOverlaps(std::vector<CellContainerComponentIn
     for (int i = 0; i < sortedItems.size() - 1; i++) {
         auto cell = sortedItems[i];
         auto neighbour = sortedItems[i + 1];
+        std::optional<facebook::react::LayoutMetrics> neighbourMetrics;
         // Only apply correction if the next cell is consecutive.
         bool isNeighbourConsecutive = neighbour->getIndex() == cell->getIndex() + 1;
-        if (isWithinBounds(*cell)) {
+        if (isWithinBounds(cell->getLayoutMetrics())) {
             if (!horizontal) {
                 maxBound = MAX(maxBound, cell->getBottom());
                 minBound = MIN(minBound, cell->getTop());
                 maxBoundNeighbour = maxBound;
                 if (isNeighbourConsecutive) {
+                    neighbourMetrics = neighbour->getLayoutMetrics();
                     if (cell->getLeft() < neighbour->getLeft()) {
                         if (cell->getRight() != neighbour->getLeft()) {
-                            neighbour->setRight(cell->getRight() + neighbour->getWidth());
-                            neighbour->setLeft(cell->getRight());
+                            neighbourMetrics.value().frame.origin.x = cell->getRight();
                         }
                         if (cell->getTop() != neighbour->getTop()) {
-                            neighbour->setBottom(cell->getTop() + neighbour->getHeight());
-                            neighbour->setTop(cell->getTop());
+                            neighbourMetrics.value().frame.origin.y = cell->getTop();
                         }
                     } else {
-                        neighbour->setBottom(maxBound + neighbour->getHeight());
-                        neighbour->setTop(maxBound);
+                        neighbourMetrics.value().frame.origin.y = maxBound;
                     }
                 }
-                if (isWithinBounds(*neighbour)) {
-                    maxBoundNeighbour = MAX(maxBound, neighbour->getBottom());
+                if (isWithinBounds(*neighbourMetrics)) {
+                    float bottom = neighbourMetrics->frame.origin.y + neighbourMetrics->frame.size.height;
+                    maxBoundNeighbour = MAX(maxBound, bottom);
                 }
             } else {
                 maxBound = MAX(maxBound, cell->getRight());
                 minBound = MIN(minBound, cell->getLeft());
                 maxBoundNeighbour = maxBound;
                 if (isNeighbourConsecutive) {
+                    neighbourMetrics = neighbour->getLayoutMetrics();
                     if (cell->getTop() < neighbour->getTop()) {
                         if (cell->getBottom() != neighbour->getTop()) {
-                            neighbour->setBottom(cell->getBottom() + neighbour->getHeight());
-                            neighbour->setTop(cell->getBottom());
+                            neighbourMetrics.value().frame.origin.y = cell->getBottom();
                         }
                         if (cell->getLeft() != neighbour->getLeft()) {
-                            neighbour->setRight(cell->getLeft() + neighbour->getWidth());
-                            neighbour->setLeft(cell->getLeft());
+                            neighbourMetrics.value().frame.origin.x = cell->getLeft();
                         }
                     } else {
-                        neighbour->setRight(maxBound + neighbour->getWidth());
-                        neighbour->setLeft(maxBound);
+                        neighbourMetrics.value().frame.origin.x = maxBound;
                     }
                 }
-                if (isWithinBounds(*neighbour)) {
-                    maxBoundNeighbour = MAX(maxBound, neighbour->getRight());
+                if (isWithinBounds(*neighbourMetrics)) {
+                    float right = neighbourMetrics->frame.origin.x + neighbourMetrics->frame.size.width;
+                    maxBoundNeighbour = MAX(maxBound, right);
                 }
             }
         }
         if (horizontal) {
             lastMaxBoundOverall = MAX(lastMaxBoundOverall, cell->getRight());
+            float right = neighbourMetrics->frame.origin.x + neighbourMetrics->frame.size.width;
             lastMaxBoundOverall = MAX(lastMaxBoundOverall, neighbour->getRight());
         } else {
             lastMaxBoundOverall = MAX(lastMaxBoundOverall, cell->getBottom());
-            lastMaxBoundOverall = MAX(lastMaxBoundOverall, neighbour->getBottom());
+            float bottom = neighbourMetrics->frame.origin.y + neighbourMetrics->frame.size.height;
+            lastMaxBoundOverall = MAX(lastMaxBoundOverall, bottom);
         }
         cell->setLayout(cell->getLayoutMetrics());
-        neighbour->setLayout(neighbour->getLayoutMetrics());
+        neighbour->setLayout(neighbourMetrics ? neighbourMetrics.value() : neighbour->getLayoutMetrics());
     }
     lastMaxBound = maxBoundNeighbour;
     lastMinBound = minBound;
@@ -119,15 +121,20 @@ Float AutoLayoutShadow::computeBlankFromGivenOffset(Float actualScrollOffset, Fl
 /**It's importance to aviod correcting views outside the render window. An item that isn't being recycled might
  * still remain in the view tree. If views outside get considered then gaps between unused items will cause
  * algorithm to fail.*/
-bool AutoLayoutShadow::isWithinBounds(CellContainerComponentInstance &cell) {
+bool AutoLayoutShadow::isWithinBounds(const facebook::react::LayoutMetrics& metrics) {
     auto boundsStart = scrollOffset - renderOffset;
     auto boundsEnd = scrollOffset + windowSize;
+    float top = metrics.frame.origin.y;
+    float bottom = metrics.frame.origin.y + metrics.frame.size.height;
+    float left = metrics.frame.origin.x;
+    float right = metrics.frame.origin.x + metrics.frame.size.width;
+    
     if (!this->horizontal) {
-        return (cell.getTop() >= boundsStart || cell.getBottom() >= boundsStart) &&
-               (cell.getTop() <= boundsEnd || cell.getBottom() <= boundsEnd);
+        return (top >= boundsStart || bottom >= boundsStart) &&
+               (top <= boundsEnd || bottom <= boundsEnd);
     } else {
-        return (cell.getLeft() >= boundsStart || cell.getRight() >= boundsStart) &&
-               (cell.getLeft() <= boundsEnd || cell.getRight() <= boundsEnd);
+        return (left >= boundsStart || right >= boundsStart) &&
+               (left <= boundsEnd || right <= boundsEnd);
     }
 }
 } // namespace rnoh

package/harmony/flash_list/src/main/cpp/AutoLayoutShadow.h

@@ -1,66 +1,66 @@
-/**
- * MIT License
- *
- * Copyright (C) 2024 Huawei Device Co., Ltd.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-//
-// Created on 5/3/2024.
-//
-// Node APIs are not fully supported. To solve the compilation error of the interface cannot be found,
-// please include "napi/native_api.h".
-
-#ifndef HARMONY_AUTOLAYOUTSHADOW_H
-#define HARMONY_AUTOLAYOUTSHADOW_H
-
-#include "react/renderer/graphics/Float.h"
-#include "CellContainerComponentInstance.h"
-
-using namespace facebook;
-using namespace react;
-
-namespace rnoh {
-
-class AutoLayoutShadow {
-private:
-    Float lastMaxBound; // Tracks where the last pixel is drawn in the visible window
-    Float lastMinBound; // Tracks where first pixel is drawn in the visible window
-    bool isWithinBounds(CellContainerComponentInstance &);
-
-public:
-    bool horizontal{false};
-    Float scrollOffset{0};
-    Float offsetFromStart{0};
-    Float windowSize{0};
-    Float renderOffset{0};
-    Float blankOffsetAtStart{0};  // Tracks blank area from the top
-    Float blankOffsetAtEnd{0};    // Tracks blank area from the bottom
-    Float lastMaxBoundOverall{0}; // Tracks where the last pixel is drawn in the overall
-
-    AutoLayoutShadow(){};
-    ~AutoLayoutShadow(){};
-    void clearGapsAndOverlaps(std::vector<CellContainerComponentInstance::Shared> sortedItems);
-    Float computeBlankFromGivenOffset(Float actualScrollOffset, Float distanceFromWindowStart,
-                                      Float distanceFromWindowEnd);
-};
-} // namespace rnoh
-
-#endif // HARMONY_AUTOLAYOUTSHADOW_H
+/**
+ * MIT License
+ *
+ * Copyright (C) 2024 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+//
+// Created on 5/3/2024.
+//
+// Node APIs are not fully supported. To solve the compilation error of the interface cannot be found,
+// please include "napi/native_api.h".
+
+#ifndef HARMONY_AUTOLAYOUTSHADOW_H
+#define HARMONY_AUTOLAYOUTSHADOW_H
+
+#include "react/renderer/graphics/Float.h"
+#include "CellContainerComponentInstance.h"
+
+using namespace facebook;
+using namespace react;
+
+namespace rnoh {
+
+class AutoLayoutShadow {
+private:
+    Float lastMaxBound; // Tracks where the last pixel is drawn in the visible window
+    Float lastMinBound; // Tracks where first pixel is drawn in the visible window
+    bool isWithinBounds(const facebook::react::LayoutMetrics& metrics);
+
+public:
+    bool horizontal{false};
+    Float scrollOffset{0};
+    Float offsetFromStart{0};
+    Float windowSize{0};
+    Float renderOffset{0};
+    Float blankOffsetAtStart{0};  // Tracks blank area from the top
+    Float blankOffsetAtEnd{0};    // Tracks blank area from the bottom
+    Float lastMaxBoundOverall{0}; // Tracks where the last pixel is drawn in the overall
+
+    AutoLayoutShadow(){};
+    ~AutoLayoutShadow(){};
+    void clearGapsAndOverlaps(std::vector<CellContainerComponentInstance::Shared> sortedItems);
+    Float computeBlankFromGivenOffset(Float actualScrollOffset, Float distanceFromWindowStart,
+                                      Float distanceFromWindowEnd);
+};
+} // namespace rnoh
+
+#endif // HARMONY_AUTOLAYOUTSHADOW_H