@react-native-ohos/flash-list 1.8.3-rc.1

package/harmony/flash_list/index.ets

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+
+export * from './src/main/ets/RNAutoLayoutView'
+export * from './src/main/ets/RNAutoLayoutShadow'
+export * from "./src/main/ets/RNCellContainer"

package/harmony/flash_list/obfuscation-rules.txt

@@ -0,0 +1,18 @@
+# Define project specific obfuscation rules here.
+# You can include the obfuscation configuration files in the current module's build-profile.json5.
+#
+# For more details, see
+#   https://gitee.com/openharmony/arkcompiler_ets_frontend/blob/master/arkguard/README.md
+
+# Obfuscation options:
+# -disable-obfuscation: disable all obfuscations
+# -enable-property-obfuscation: obfuscate the property names
+# -enable-toplevel-obfuscation: obfuscate the names in the global scope
+# -compact: remove unnecessary blank spaces and all line feeds
+# -remove-log: remove all console.* statements
+# -print-namecache: print the name cache that contains the mapping from the old names to new names
+# -apply-namecache: reuse the given cache file
+
+# Keep options:
+# -keep-property-name: specifies property names that you want to keep
+# -keep-global-name: specifies names that you want to keep in the global scope

package/harmony/flash_list/oh-package.json5

@@ -0,0 +1,24 @@
+{
+  "name": "@react-native-ohos/flash-list",
+  "version": "1.8.3-rc.1",
+  "description": "FlashList is a more performant FlatList replacement",
+  "main": "index.ets",
+  "author": "Huawei",
+  "license": "MIT",
+  "devDependencies": {
+
+  },
+  "dependencies": {
+    "@rnoh/react-native-openharmony": "file:../../node_modules/react-native-harmony/harmony/react_native_openharmony.har"
+  },
+  "modelVersion": "",
+  "metadata": {
+    "sourceRoots": [
+      "./src/main"
+    ],
+    "debug": true
+  },
+  "compatibleSdkVersion": 12,
+  "compatibleSdkType": "HarmonyOS",
+  "obfuscated": false
+}

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

@@ -0,0 +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 "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

@@ -0,0 +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);
+};
+
+} // namespace rnoh

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

@@ -0,0 +1,133 @@
+/**
+ * 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"
+
+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];
+        // Only apply correction if the next cell is consecutive.
+        bool isNeighbourConsecutive = neighbour->getIndex() == cell->getIndex() + 1;
+        if (isWithinBounds(*cell)) {
+            if (!horizontal) {
+                maxBound = MAX(maxBound, cell->getBottom());
+                minBound = MIN(minBound, cell->getTop());
+                maxBoundNeighbour = maxBound;
+                if (isNeighbourConsecutive) {
+                    if (cell->getLeft() < neighbour->getLeft()) {
+                        if (cell->getRight() != neighbour->getLeft()) {
+                            neighbour->setRight(cell->getRight() + neighbour->getWidth());
+                            neighbour->setLeft(cell->getRight());
+                        }
+                        if (cell->getTop() != neighbour->getTop()) {
+                            neighbour->setBottom(cell->getTop() + neighbour->getHeight());
+                            neighbour->setTop(cell->getTop());
+                        }
+                    } else {
+                        neighbour->setBottom(maxBound + neighbour->getHeight());
+                        neighbour->setTop(maxBound);
+                    }
+                }
+                if (isWithinBounds(*neighbour)) {
+                    maxBoundNeighbour = MAX(maxBound, neighbour->getBottom());
+                }
+            } else {
+                maxBound = MAX(maxBound, cell->getRight());
+                minBound = MIN(minBound, cell->getLeft());
+                maxBoundNeighbour = maxBound;
+                if (isNeighbourConsecutive) {
+                    if (cell->getTop() < neighbour->getTop()) {
+                        if (cell->getBottom() != neighbour->getTop()) {
+                            neighbour->setBottom(cell->getBottom() + neighbour->getHeight());
+                            neighbour->setTop(cell->getBottom());
+                        }
+                        if (cell->getLeft() != neighbour->getLeft()) {
+                            neighbour->setRight(cell->getLeft() + neighbour->getWidth());
+                            neighbour->setLeft(cell->getLeft());
+                        }
+                    } else {
+                        neighbour->setRight(maxBound + neighbour->getWidth());
+                        neighbour->setLeft(maxBound);
+                    }
+                }
+                if (isWithinBounds(*neighbour)) {
+                    maxBoundNeighbour = MAX(maxBound, neighbour->getRight());
+                }
+            }
+        }
+        if (horizontal) {
+            lastMaxBoundOverall = MAX(lastMaxBoundOverall, cell->getRight());
+            lastMaxBoundOverall = MAX(lastMaxBoundOverall, neighbour->getRight());
+        } else {
+            lastMaxBoundOverall = MAX(lastMaxBoundOverall, cell->getBottom());
+            lastMaxBoundOverall = MAX(lastMaxBoundOverall, neighbour->getBottom());
+        }
+        cell->setLayout(cell->getLayoutMetrics());
+        neighbour->setLayout(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(CellContainerComponentInstance &cell) {
+    auto boundsStart = scrollOffset - renderOffset;
+    auto boundsEnd = scrollOffset + windowSize;
+    if (!this->horizontal) {
+        return (cell.getTop() >= boundsStart || cell.getBottom() >= boundsStart) &&
+               (cell.getTop() <= boundsEnd || cell.getBottom() <= boundsEnd);
+    } else {
+        return (cell.getLeft() >= boundsStart || cell.getRight() >= boundsStart) &&
+               (cell.getLeft() <= boundsEnd || cell.getRight() <= boundsEnd);
+    }
+}
+} // namespace rnoh

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

@@ -0,0 +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

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

@@ -0,0 +1,208 @@
+/**
+ * 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 "AutoLayoutViewComponentInstance.h"
+#include "RNOHCorePackage/ComponentInstances/ViewComponentInstance.h"
+#include "folly/Synchronized.h"
+#include "folly/synchronization/Lock.h"
+#include <mutex>
+#include <sys/param.h>
+
+namespace rnoh {
+
+AutoLayoutViewComponentInstance::AutoLayoutViewComponentInstance(Context context)
+    : CppComponentInstance(std::move(context)) {
+    m_autoLayoutNode.setAutoLayoutNodeDelegate(this);
+}
+
+void AutoLayoutViewComponentInstance::onChildInserted(ComponentInstance::Shared const &childComponentInstance,
+                                                      std::size_t index) {
+    CppComponentInstance::onChildInserted(childComponentInstance, index);
+    m_autoLayoutNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index);
+}
+
+AutoLayoutNode &AutoLayoutViewComponentInstance::getLocalRootArkUINode() { return m_autoLayoutNode; }
+
+void AutoLayoutViewComponentInstance::onChildRemoved(ComponentInstance::Shared const &childComponentInstance) {
+    CppComponentInstance::onChildRemoved(childComponentInstance);
+    m_autoLayoutNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+};
+
+void AutoLayoutViewComponentInstance::finalizeUpdates() {
+    if (parentScrollView != nullptr) {
+        onAppear();
+    }
+    ComponentInstance::finalizeUpdates();
+}
+
+facebook::react::Float AutoLayoutViewComponentInstance::getLeft() { return m_layoutMetrics.frame.origin.x; }
+facebook::react::Float AutoLayoutViewComponentInstance::getTop() { return m_layoutMetrics.frame.origin.y; }
+facebook::react::Float AutoLayoutViewComponentInstance::getRight() {
+    return m_layoutMetrics.frame.origin.x + m_layoutMetrics.frame.size.width;
+}
+facebook::react::Float AutoLayoutViewComponentInstance::getBottom() {
+    return m_layoutMetrics.frame.origin.y + m_layoutMetrics.frame.size.height;
+}
+facebook::react::Float AutoLayoutViewComponentInstance::getHeight() { return m_layoutMetrics.frame.size.height; }
+facebook::react::Float AutoLayoutViewComponentInstance::getWidth() { return m_layoutMetrics.frame.size.width; }
+
+void AutoLayoutViewComponentInstance::onAppear() {
+    fixLayout();
+    fixFooter();
+    getLocalRootArkUINode().markDirty();
+
+    parentScrollView = getParentScrollView();
+    if (enableInstrumentation && parentScrollView != nullptr) {
+        auto scrollContainerSize = alShadow.horizontal ? parentScrollView->getLayoutMetrics().frame.size.width
+                                                       : parentScrollView->getLayoutMetrics().frame.size.height;
+        auto currentScrollOffset = alShadow.horizontal ? parentScrollView->getScrollViewMetrics().contentOffset.x
+                                                       : parentScrollView->getScrollViewMetrics().contentOffset.y;
+
+        auto startOffset = alShadow.horizontal ? getLeft() : getTop();
+        auto endOffset = alShadow.horizontal ? getRight() : getBottom();
+
+        auto distanceFromWindowStart = MAX(startOffset - currentScrollOffset, 0);
+        auto distanceFromWindowEnd = MAX(currentScrollOffset + scrollContainerSize - endOffset, 0);
+        alShadow.computeBlankFromGivenOffset(currentScrollOffset - startOffset, distanceFromWindowStart,
+                                             distanceFromWindowEnd);
+        emitBlankAreaEvent();
+    }
+}
+
+void AutoLayoutViewComponentInstance::onPropsChanged(SharedConcreteProps const &props) {
+    CppComponentInstance::onPropsChanged(props);
+    horizontal = props->horizontal;
+    alShadow.horizontal = props->horizontal;
+    alShadow.scrollOffset = props->scrollOffset;
+    alShadow.windowSize = props->windowSize;
+    alShadow.renderOffset = props->renderAheadOffset;
+    enableInstrumentation = props->enableInstrumentation;
+    disableAutoLayout = props->disableAutoLayout;
+    if (parentScrollView != nullptr) {
+        onAppear();
+    }
+}
+
+/** Sorts views by index and then invokes clearGaps which does the correction.
+ * Performance: Sort is needed. Given relatively low number of views in RecyclerListView render tree this should be
+ * a non issue.*/
+void AutoLayoutViewComponentInstance::fixLayout() {
+    auto children = getChildren();
+    if (children.size() > 1 && !disableAutoLayout) {
+        std::vector<rnoh::CellContainerComponentInstance::Shared> childrenView;
+        for (int i = 0; i < children.size(); i++) {
+            auto cell = std::dynamic_pointer_cast<rnoh::CellContainerComponentInstance>(children[i]);
+            childrenView.push_back(cell);
+        }
+        std::sort(childrenView.begin(), childrenView.end(),
+                  [](auto &a, auto &b) { return a->getIndex() < b->getIndex(); });
+
+        alShadow.offsetFromStart = alShadow.horizontal ? getLeft() : getTop();
+        alShadow.clearGapsAndOverlaps(childrenView);
+    }
+}
+
+/** Fixes footer position along with rest of the items */
+void AutoLayoutViewComponentInstance::fixFooter() {
+    parentScrollView = getParentScrollView();
+    if (disableAutoLayout || parentScrollView == nullptr) {
+        return;
+    }
+    auto isAutoLayoutEndVisible = alShadow.horizontal
+                                      ? getRight() <= parentScrollView->getLayoutMetrics().frame.size.width
+                                      : getBottom() <= parentScrollView->getLayoutMetrics().frame.size.height;
+    if (!isAutoLayoutEndVisible) {
+        return;
+    }
+    auto autoLayoutParent = getParent().lock();
+    auto footer = getFooter();
+    auto diff = static_cast<facebook::react::Float>(getFooterDiff());
+    if (diff == 0 || footer == nullptr || autoLayoutParent == nullptr) {
+        return;
+    }
+    if (alShadow.horizontal) {
+        auto footerLayoutMetrics = footer->getLayoutMetrics();
+        footerLayoutMetrics.frame.origin.x += diff;
+        footer->setLayout(footerLayoutMetrics);
+
+        m_layoutMetrics.frame.size.width += diff;
+        setLayout(m_layoutMetrics);
+
+        auto parentLayoutMetrics = autoLayoutParent->getLayoutMetrics();
+        parentLayoutMetrics.frame.size.width += diff;
+        autoLayoutParent->setLayout(parentLayoutMetrics);
+    } else {
+        auto footerLayoutMetrics = footer->getLayoutMetrics();
+        footerLayoutMetrics.frame.origin.y += diff;
+        footer->setLayout(footerLayoutMetrics);
+
+        m_layoutMetrics.frame.size.height += diff;
+        setLayout(m_layoutMetrics);
+
+        auto parentLayoutMetrics = autoLayoutParent->getLayoutMetrics();
+        parentLayoutMetrics.frame.size.height += diff;
+        autoLayoutParent->setLayout(parentLayoutMetrics);
+    }
+}
+
+facebook::react::Float AutoLayoutViewComponentInstance::getFooterDiff() {
+    if (getChildren().empty()) {
+        alShadow.lastMaxBoundOverall = 0;
+    } else if (getChildren().size() == 1) {
+        auto firstChild = std::dynamic_pointer_cast<rnoh::CellContainerComponentInstance>(getChildren()[0]);
+        alShadow.lastMaxBoundOverall = alShadow.horizontal ? firstChild->getRight() : firstChild->getBottom();
+    }
+    auto autoLayoutEnd = alShadow.horizontal ? getWidth() : getHeight();
+    return alShadow.lastMaxBoundOverall - autoLayoutEnd;
+}
+
+std::shared_ptr<rnoh::CellContainerComponentInstance> AutoLayoutViewComponentInstance::getFooter() {
+    for (auto const child : getChildren()) {
+        auto childInstance = std::dynamic_pointer_cast<rnoh::CellContainerComponentInstance>(child);
+        if (childInstance != nullptr && childInstance->getIndex() == -1) {
+            return childInstance;
+        }
+    }
+    return nullptr;
+}
+
+std::shared_ptr<rnoh::ScrollViewComponentInstance> AutoLayoutViewComponentInstance::getParentScrollView() {
+    auto autoLayoutParent = getParent().lock();
+    while (autoLayoutParent) {
+        auto scrollView = std::dynamic_pointer_cast<rnoh::ScrollViewComponentInstance>(autoLayoutParent);
+        if (scrollView) {
+            return scrollView;
+        }
+        autoLayoutParent = autoLayoutParent->getParent().lock();
+    }
+    return nullptr;
+}
+
+void AutoLayoutViewComponentInstance::emitBlankAreaEvent() {
+    AutoLayoutViewEventEmitter::OnBlankAreaEvent blankAreaEvent;
+    blankAreaEvent.offsetStart = alShadow.blankOffsetAtStart / pixelDensity;
+    blankAreaEvent.offsetEnd = alShadow.blankOffsetAtEnd / pixelDensity;
+    m_eventEmitter->onBlankAreaEvent(blankAreaEvent);
+}
+} // namespace rnoh

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

@@ -0,0 +1,78 @@
+/**
+ * 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.
+ */
+
+#ifndef HARMONY_AUTOLAYOUTVIEWCOMPONENTINSTANCE_H
+#define HARMONY_AUTOLAYOUTVIEWCOMPONENTINSTANCE_H
+
+#include "RNOH/CppComponentInstance.h"
+#include "RNOHCorePackage/ComponentInstances/ScrollViewComponentInstance.h"
+#include "AutoLayoutShadow.h"
+#include "AutoLayoutNode.h"
+#include "ShadowNodes.h"
+
+namespace rnoh {
+class AutoLayoutViewComponentInstance : public CppComponentInstance<facebook::react::AutoLayoutViewShadowNode>,
+                                        public AutoLayoutNodeDelegate {
+private:
+    AutoLayoutNode m_autoLayoutNode;
+    AutoLayoutShadow alShadow{AutoLayoutShadow()};
+    bool horizontal{false};
+
+    bool enableInstrumentation{false};
+    bool disableAutoLayout{false};
+    Float pixelDensity{1.0};
+
+    std::shared_ptr<rnoh::ScrollViewComponentInstance> parentScrollView;
+
+public:
+    AutoLayoutViewComponentInstance(Context context);
+
+    void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override;
+
+    void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override;
+
+    AutoLayoutNode &getLocalRootArkUINode() override;
+
+    void onPropsChanged(SharedConcreteProps const &props) override;
+    void getNapiProps(facebook::react::Props::Shared props);
+    void finalizeUpdates() override;
+
+    facebook::react::Float getLeft();
+    facebook::react::Float getTop();
+    facebook::react::Float getRight();
+    facebook::react::Float getBottom();
+    facebook::react::Float getHeight();
+    facebook::react::Float getWidth();
+
+    void fixLayout();
+    void fixFooter();
+    facebook::react::Float getFooterDiff();
+    void onAppear() override;
+    std::shared_ptr<rnoh::CellContainerComponentInstance> getFooter();
+    std::shared_ptr<rnoh::ScrollViewComponentInstance> getParentScrollView();
+    void emitBlankAreaEvent() override;
+};
+} // namespace rnoh
+
+#endif // HARMONY_AUTOLAYOUTVIEWCOMPONENTINSTANCE_H