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

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

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

@@ -0,0 +1,53 @@
+/**
+ * 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 FLASH_SRC_MAIN_CPP_AUTOLAYOUTVIEWEVENTEMITREQUESTHANDLER_H
+#define FLASH_SRC_MAIN_CPP_AUTOLAYOUTVIEWEVENTEMITREQUESTHANDLER_H
+
+#include "RNOH/ArkJS.h"
+#include "RNOH/EventEmitRequestHandler.h"
+#include "EventEmitters.h"
+
+using namespace facebook;
+namespace rnoh {
+
+class AutoLayoutViewEventEmitRequestHandler : public EventEmitRequestHandler {
+public:
+    void handleEvent(EventEmitRequestHandler::Context const &ctx) override {
+        if (ctx.eventName != "AutoLayoutView") {
+            return;
+        }
+        ArkJS arkJs(ctx.env);
+        auto eventEmitter = ctx.shadowViewRegistry->getEventEmitter<react::AutoLayoutViewEventEmitter>(ctx.tag);
+        if (eventEmitter == nullptr) {
+            return;
+        }
+        facebook::react::Float offsetStart = arkJs.getDouble(arkJs.getObjectProperty(ctx.payload, "offsetStart"));
+        facebook::react::Float offsetEnd = arkJs.getDouble(arkJs.getObjectProperty(ctx.payload, "offsetEnd"));
+        react::AutoLayoutViewEventEmitter::OnBlankAreaEvent event{offsetStart, offsetEnd};
+        eventEmitter->onBlankAreaEvent(event);
+    };
+};
+} // namespace rnoh
+#endif

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

@@ -0,0 +1,50 @@
+/**
+ * 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 FLASH_SRC_MAIN_CPP_AUTOLAYOUTVIEWJSIBINDER_H
+#define FLASH_SRC_MAIN_CPP_AUTOLAYOUTVIEWJSIBINDER_H
+
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class AutoLayoutViewJSIBinder : public ViewComponentJSIBinder {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "horizontal", "boolean");
+        object.setProperty(rt, "scrollOffset", "float");
+        object.setProperty(rt, "windowSize", "float");
+        object.setProperty(rt, "renderAheadOffset", "float");
+        object.setProperty(rt, "enableInstrumentation", "boolean");
+        object.setProperty(rt, "disableAutoLayout", "boolean");
+        return object;
+    }
+
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        events.setProperty(rt, "topBlankAreaEvent", createDirectEvent(rt, "onBlankAreaEvent"));
+        return events;
+    }
+};
+} // namespace rnoh
+#endif

package/harmony/flash_list/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB rnoh_flash_list_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(rnoh_flash_list SHARED ${rnoh_flash_list_SRC})
+target_include_directories(rnoh_flash_list PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(rnoh_flash_list PUBLIC rnoh)

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

@@ -0,0 +1,80 @@
+/**
+ * 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 "CellContainerComponentInstance.h"
+
+namespace rnoh {
+
+CellContainerComponentInstance::CellContainerComponentInstance(Context context)
+    : CppComponentInstance(std::move(context)) {}
+
+void CellContainerComponentInstance::onChildInserted(ComponentInstance::Shared const &childComponentInstance,
+                                                     std::size_t index) {
+    CppComponentInstance::onChildInserted(childComponentInstance, index);
+    m_stackNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index);
+}
+
+void CellContainerComponentInstance::onChildRemoved(ComponentInstance::Shared const &childComponentInstance) {
+    CppComponentInstance::onChildRemoved(childComponentInstance);
+    m_stackNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+};
+
+FlashListStackNode &CellContainerComponentInstance::getLocalRootArkUINode() { return m_stackNode; }
+
+void CellContainerComponentInstance::setIndex(int const &newIndex) { this->index = newIndex; }
+int CellContainerComponentInstance::getIndex() { return index; }
+
+void CellContainerComponentInstance::setLeft(facebook::react::Float const &left) {
+    m_layoutMetrics.frame.origin.x = left;
+}
+facebook::react::Float CellContainerComponentInstance::getLeft() { return m_layoutMetrics.frame.origin.x; }
+void CellContainerComponentInstance::setTop(facebook::react::Float const &top) { m_layoutMetrics.frame.origin.y = top; }
+facebook::react::Float CellContainerComponentInstance::getTop() { return m_layoutMetrics.frame.origin.y; }
+void CellContainerComponentInstance::setRight(facebook::react::Float const &right) {
+    m_layoutMetrics.frame.origin.x = right - m_layoutMetrics.frame.size.width;
+}
+facebook::react::Float CellContainerComponentInstance::getRight() {
+    return m_layoutMetrics.frame.origin.x + m_layoutMetrics.frame.size.width;
+}
+void CellContainerComponentInstance::setBottom(facebook::react::Float const &bottom) {
+    m_layoutMetrics.frame.origin.y = bottom - m_layoutMetrics.frame.size.height;
+}
+facebook::react::Float CellContainerComponentInstance::getBottom() {
+    return m_layoutMetrics.frame.origin.y + m_layoutMetrics.frame.size.height;
+}
+void CellContainerComponentInstance::setHeight(facebook::react::Float const &height) {
+    m_layoutMetrics.frame.size.height = height;
+}
+facebook::react::Float CellContainerComponentInstance::getHeight() { return m_layoutMetrics.frame.size.height; }
+void CellContainerComponentInstance::setWidth(facebook::react::Float const &width) {
+    m_layoutMetrics.frame.size.width = width;
+}
+facebook::react::Float CellContainerComponentInstance::getWidth() { return m_layoutMetrics.frame.size.width; }
+
+void CellContainerComponentInstance::onPropsChanged(SharedConcreteProps const &props) {
+    CppComponentInstance::onPropsChanged(props);
+    this->setIndex(props->index);
+}
+
+} // namespace rnoh

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

@@ -0,0 +1,67 @@
+#ifndef COMPONENT_INSTANCE_H
+#define COMPONENT_INSTANCE_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.
+ */
+
+#pragma once
+#include "RNOH/CppComponentInstance.h"
+#include "ShadowNodes.h"
+#include "FlashListStackNode.h"
+
+namespace rnoh {
+class CellContainerComponentInstance : public CppComponentInstance<facebook::react::CellContainerShadowNode> {
+private:
+    FlashListStackNode m_stackNode;
+    int index{-1};
+
+public:
+    using Shared = std::shared_ptr<CellContainerComponentInstance>;
+    CellContainerComponentInstance(Context context);
+
+    void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override;
+
+    void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override;
+
+    FlashListStackNode &getLocalRootArkUINode() override;
+
+    void setIndex(int const &);
+    int getIndex();
+
+    void setLeft(facebook::react::Float const &);
+    facebook::react::Float getLeft();
+    void setTop(facebook::react::Float const &);
+    facebook::react::Float getTop();
+    void setRight(facebook::react::Float const &);
+    facebook::react::Float getRight();
+    void setBottom(facebook::react::Float const &);
+    facebook::react::Float getBottom();
+    void setHeight(facebook::react::Float const &);
+    facebook::react::Float getHeight();
+    void setWidth(facebook::react::Float const &);
+    facebook::react::Float getWidth();
+
+    void onPropsChanged(SharedConcreteProps const &props) override;
+};
+} // namespace rnoh
+#endif

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

@@ -0,0 +1,39 @@
+/**
+ * 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 FLASH_SRC_MAIN_CPP_CELLCONTAINERJSIBINDER_H
+#define FLASH_SRC_MAIN_CPP_CELLCONTAINERJSIBINDER_H
+
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class CellContainerJSIBinder : public ViewComponentJSIBinder {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "index", "int");
+        return object;
+    }
+};
+} // namespace rnoh
+#endif

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

@@ -0,0 +1,40 @@
+/**
+ * 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 FLASH_SRC_MAIN_CPP_COMPONENTDESCRIPTORS_H
+#define FLASH_SRC_MAIN_CPP_COMPONENTDESCRIPTORS_H
+
+#include "ShadowNodes.h"
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+
+using AutoLayoutViewComponentDescriptor = ConcreteComponentDescriptor<AutoLayoutViewShadowNode>;
+
+using CellContainerComponentDescriptor = ConcreteComponentDescriptor<CellContainerShadowNode>;
+
+} // namespace react
+} // namespace facebook
+#endif

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

@@ -0,0 +1,40 @@
+/**
+ * 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 "EventEmitters.h"
+
+namespace facebook {
+namespace react {
+
+void AutoLayoutViewEventEmitter::onBlankAreaEvent(OnBlankAreaEvent event) const {
+    dispatchEvent("blankAreaEvent", [event = std::move(event)](jsi::Runtime &runtime) {
+        auto payload = jsi::Object(runtime);
+        payload.setProperty(runtime, "offsetStart", event.offsetStart);
+        payload.setProperty(runtime, "offsetEnd", event.offsetEnd);
+        return payload;
+    });
+}
+
+} // namespace react
+} // namespace facebook