@react-native-ohos/react-native-safe-area-context 5.1.1-rc.1

package/harmony/safe_area/src/main/cpp/SafeAreaManagerMap.h

@@ -0,0 +1,57 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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_SAFEAREAMANAGERMAP_H
+#define HARMONY_SAFEAREAMANAGERMAP_H
+
+#include <arkui/native_type.h>
+#include <unordered_map>
+
+class SafeAreaManagerMap {
+
+private:
+
+    SafeAreaManagerMap();
+
+    SafeAreaManagerMap(const SafeAreaManagerMap &) = delete;
+
+    SafeAreaManagerMap &operator=(const SafeAreaManagerMap &) = delete;
+
+    SafeAreaManagerMap(SafeAreaManagerMap &&) = delete;
+
+    SafeAreaManagerMap &operator=(SafeAreaManagerMap &&) = delete;
+
+    std::unordered_map<ArkUI_NodeHandle, bool> hasSafeAreaProviderMap_;
+
+public:
+    static SafeAreaManagerMap &getInstance();
+    
+    void SetHasSafeAreaProviderByNodeHandle(ArkUI_NodeHandle nodeHandle, bool isHasSafeAreaProvider);
+
+    bool GetHasSafeAreaProviderByNodeHandle(ArkUI_NodeHandle nodeHandle);
+    
+    void RemoveSafeAreaProviderByNodeHandle(ArkUI_NodeHandle nodeHandle);
+};
+
+#endif //HARMONY_SAFEAREAMANAGERMAP_H

package/harmony/safe_area/src/main/cpp/SafeAreaProviderComponentInstance.cpp

@@ -0,0 +1,75 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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 <sys/param.h>
+#include "SafeAreaProviderComponentInstance.h"
+#include "TurboModuleRequest.h"
+#include "SafeAreaManagerMap.h"
+
+namespace rnoh {
+
+    SafeAreaProviderComponentInstance::SafeAreaProviderComponentInstance(Context context)
+        : BaseRNCSafeAreaProviderComponentInstance(std::move(context)) {
+            SafeAreaManagerMap::getInstance().SetHasSafeAreaProviderByNodeHandle(m_stackNode.getArkUINodeHandle(), true);
+        }
+
+    void SafeAreaProviderComponentInstance::onChildInserted(ComponentInstance::Shared const &childComponentInstance,
+                                                            std::size_t index) {
+        super::onChildInserted(childComponentInstance, index);
+        m_stackNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index);
+    }
+
+    void SafeAreaProviderComponentInstance::onChildRemoved(ComponentInstance::Shared const &childComponentInstance) {
+        super::onChildRemoved(childComponentInstance);
+        m_stackNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+    };
+
+    SafeAreaStackNode &SafeAreaProviderComponentInstance::getLocalRootArkUINode() { return m_stackNode; }
+
+    void SafeAreaProviderComponentInstance::onPropsChanged(SharedConcreteProps const &props) {
+        super::onPropsChanged(props);
+    }
+
+    void SafeAreaProviderComponentInstance::onEventEmitterChanged(SharedConcreteEventEmitter const &eventEmitter) {
+        auto newEventEmitter = std::dynamic_pointer_cast<const ConcreteEventEmitter>(eventEmitter);
+        if (!newEventEmitter) {
+            return;
+        }
+        TurboModuleRequest request;
+        safeArea::Event data = request.getTurboModuleData(this->m_deps);
+        double x = getLayoutMetrics().frame.origin.x;
+        double y = getLayoutMetrics().frame.origin.y;
+        double width = getLayoutMetrics().frame.size.width;
+        double height = getLayoutMetrics().frame.size.height;
+        double providerTop = MAX(data.insets.top - y, 0);
+        double providerRight = MAX(MIN(x + width - data.frame.width, 0) + data.insets.right, 0);
+        double providerBottom = MAX(MIN(y + height - data.frame.height, 0) + data.insets.bottom, 0);
+        double providerLeft = MAX(data.insets.left - x, 0);
+        facebook::react::RNCSafeAreaProviderEventEmitter::OnInsetsChangeInsets insets = {providerTop, providerRight,
+                                                                                         providerBottom, providerLeft};
+        facebook::react::RNCSafeAreaProviderEventEmitter::OnInsetsChangeFrame frame = {x, y, width, height};
+        facebook::react::RNCSafeAreaProviderEventEmitter::OnInsetsChange insetsChange = {insets, frame};
+        newEventEmitter->onInsetsChange(insetsChange);
+    }
+} // namespace rnoh

package/harmony/safe_area/src/main/cpp/SafeAreaProviderComponentInstance.h

@@ -0,0 +1,49 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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 "SafeAreaStackNode.h"
+#include "generated/RNOH/generated/components/BaseRNCSafeAreaProviderComponentInstance.h"
+#include "generated/react/renderer/components/react_native_safe_area_context/EventEmitters.h"
+namespace rnoh {
+    class SafeAreaProviderComponentInstance : public BaseRNCSafeAreaProviderComponentInstance {
+    
+    using super = BaseRNCSafeAreaProviderComponentInstance;
+
+    private:
+        SafeAreaStackNode m_stackNode;
+    public:
+        SafeAreaProviderComponentInstance(Context context);
+
+        void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override;
+
+        void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override;
+
+        SafeAreaStackNode &getLocalRootArkUINode() override;
+    
+        void onPropsChanged(SharedConcreteProps const &props) override;
+
+        void onEventEmitterChanged(SharedConcreteEventEmitter const &eventEmitter) override;
+    };
+} // namespace rnoh

package/harmony/safe_area/src/main/cpp/SafeAreaStackNode.cpp

@@ -0,0 +1,94 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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 "SafeAreaStackNode.h"
+
+#include <glog/logging.h>
+#include <memory>
+#include "RNOH/arkui/NativeNodeApi.h"
+#include "SafeAreaManagerMap.h"
+
+namespace rnoh {
+
+SafeAreaStackNode::SafeAreaStackNode()
+    : ArkUINode(NativeNodeApi::getInstance()->createNode(
+          ArkUI_NodeType::ARKUI_NODE_STACK)),
+      m_stackNodeDelegate(nullptr) {
+  maybeThrow(NativeNodeApi::getInstance()->registerNodeEvent(
+      m_nodeHandle, NODE_ON_CLICK, NODE_ON_CLICK, this));
+ maybeThrow(NativeNodeApi::getInstance()->registerNodeEvent(
+      m_nodeHandle, NODE_EVENT_ON_APPEAR, NODE_EVENT_ON_APPEAR, this));   
+}
+
+void SafeAreaStackNode::insertChild(ArkUINode& child, std::size_t index) {
+  maybeThrow(NativeNodeApi::getInstance()->insertChildAt(
+      m_nodeHandle, child.getArkUINodeHandle(), static_cast<int32_t>(index)));
+}
+
+void SafeAreaStackNode::removeChild(ArkUINode& child) {
+  maybeThrow(NativeNodeApi::getInstance()->removeChild(
+      m_nodeHandle, child.getArkUINodeHandle()));
+}
+
+void SafeAreaStackNode::setStackNodeDelegate(SafeAreaStackNodeDelegate* SafeAreaStackNodeDelegate) {
+  m_stackNodeDelegate = SafeAreaStackNodeDelegate;
+}
+
+void SafeAreaStackNode::onNodeEvent(
+    ArkUI_NodeEventType eventType,
+    EventArgs& eventArgs) {
+  if (eventType == ArkUI_NodeEventType::NODE_ON_CLICK &&
+      eventArgs[3].i32 != 2) {
+    onClick();
+  }
+ 
+  if (eventType == ArkUI_NodeEventType::NODE_EVENT_ON_APPEAR) {
+      if(m_stackNodeDelegate != nullptr) {
+         m_stackNodeDelegate->onAppear();
+      }
+  }
+    
+}
+
+void SafeAreaStackNode::onClick() {
+  if (m_stackNodeDelegate != nullptr) {
+    m_stackNodeDelegate->onClick();
+  }
+}
+
+SafeAreaStackNode::~SafeAreaStackNode() {
+  NativeNodeApi::getInstance()->unregisterNodeEvent(
+      m_nodeHandle, NODE_ON_CLICK);
+    NativeNodeApi::getInstance()->unregisterNodeEvent(
+      m_nodeHandle, NODE_EVENT_ON_APPEAR);
+    SafeAreaManagerMap::getInstance().RemoveSafeAreaProviderByNodeHandle(m_nodeHandle);
+}
+
+SafeAreaStackNode& SafeAreaStackNode::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));
+  return *this;
+}
+} // namespace rnoh

package/harmony/safe_area/src/main/cpp/SafeAreaStackNode.h

@@ -0,0 +1,53 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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"
+
+namespace rnoh {
+class SafeAreaStackNodeDelegate {
+ public:
+  virtual ~SafeAreaStackNodeDelegate() = default;
+  virtual void onClick() {};
+  virtual void onAppear(){};
+};
+
+class SafeAreaStackNode : public ArkUINode {
+ protected:
+  SafeAreaStackNodeDelegate* m_stackNodeDelegate;
+
+ public:
+  SafeAreaStackNode();
+  ~SafeAreaStackNode() override;
+
+  void insertChild(ArkUINode& child, std::size_t index);
+  void removeChild(ArkUINode& child);
+  void onNodeEvent(ArkUI_NodeEventType eventType, EventArgs& eventArgs)
+      override;
+  void onClick();
+  void setStackNodeDelegate(SafeAreaStackNodeDelegate* safeAreaStackNodeDelegate);
+  SafeAreaStackNode& setAlign(int32_t align);
+};
+
+} // namespace rnoh

package/harmony/safe_area/src/main/cpp/SafeAreaViewComponentInstance.cpp

@@ -0,0 +1,94 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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 "SafeAreaViewComponentInstance.h"
+#include "TurboModuleRequest.h"
+#include "SafeAreaManagerMap.h"
+
+namespace rnoh {
+
+SafeAreaViewComponentInstance::SafeAreaViewComponentInstance(Context context)
+    : BaseRNCSafeAreaViewComponentInstance(std::move(context)) {
+    m_safeAreaViewStackNode.setStackNodeDelegate(this);
+}
+
+void SafeAreaViewComponentInstance::onChildInserted(ComponentInstance::Shared const &childComponentInstance,
+                                                    std::size_t index) {
+    super::onChildInserted(childComponentInstance, index);
+    m_safeAreaViewStackNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index);
+}
+
+void SafeAreaViewComponentInstance::onChildRemoved(ComponentInstance::Shared const &childComponentInstance) {
+    super::onChildRemoved(childComponentInstance);
+    m_safeAreaViewStackNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+};
+
+SafeAreaStackNode &SafeAreaViewComponentInstance::getLocalRootArkUINode() { return m_safeAreaViewStackNode; }
+
+void SafeAreaViewComponentInstance::updateInsert(SharedConcreteProps p) {
+    auto parentNodeHandle = findParentNodeHandle(m_safeAreaViewStackNode.getArkUINodeHandle());
+    DLOG(INFO) << "SafeAreaViewComponentInstance findParentNodeHandle " << parentNodeHandle.nodeHandle << " hasSafeAreaProvider " << parentNodeHandle.hasSafeAreaProvider;
+    if (parentNodeHandle.hasSafeAreaProvider) {
+        TurboModuleRequest request;
+        safeArea::Event data = request.getTurboModuleData(this->m_deps);
+        facebook::react::RNCSafeAreaViewEventEmitter::OnSafeAreaValueChange inset = {data.insets.top, data.insets.right,
+                                                                                data.insets.bottom, data.insets.left};
+        m_eventEmitter->onSafeAreaValueChange(inset);
+    }
+    else {
+        facebook::react::RNCSafeAreaViewEventEmitter::OnSafeAreaValueChange inset = {0, 0, 0, 0};
+        m_eventEmitter->onSafeAreaValueChange(inset);
+    }
+}
+
+SafeAreaViewComponentInstance::ParentNodeInfo SafeAreaViewComponentInstance::findParentNodeHandle(ArkUI_NodeHandle nodehandle) {
+    ParentNodeInfo parentNodeInfo;
+    if(!nodehandle) return parentNodeInfo;
+    auto parentNode  = OH_ArkUI_NodeUtils_GetParentInPageTree(nodehandle);
+    bool hasSafeAreaProvider =  SafeAreaManagerMap::getInstance().GetHasSafeAreaProviderByNodeHandle(parentNode);
+    parentNodeInfo.hasSafeAreaProvider = hasSafeAreaProvider;
+    parentNodeInfo.nodeHandle = parentNode;
+    if (!hasSafeAreaProvider && parentNode) {
+        return findParentNodeHandle(parentNode);
+    }
+    return parentNodeInfo;
+}
+
+void SafeAreaViewComponentInstance::onPropsChanged(SharedConcreteProps const &props) {
+    super::onPropsChanged(props);
+    this->m_SharedConcreteProps = props;
+    if(this->m_isFirstShow) {
+        return;
+    }
+    updateInsert(props);
+}
+
+void SafeAreaViewComponentInstance::onAppear(){
+    if(this->m_isFirstShow && this->m_SharedConcreteProps) {
+        updateInsert(this->m_SharedConcreteProps);
+        this->m_isFirstShow = false;
+    }
+}
+
+
+} // namespace rnoh

package/harmony/safe_area/src/main/cpp/SafeAreaViewComponentInstance.h

@@ -0,0 +1,64 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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 "SafeAreaBeanData.h"
+#include "SafeAreaColumnNode.h"
+#include "SafeAreaStackNode.h"
+#include "SafeAreaProviderComponentInstance.h"
+#include "generated/RNOH/generated/components/BaseRNCSafeAreaViewComponentInstance.h"
+#include "generated/react/renderer/components/react_native_safe_area_context/EventEmitters.h"
+
+namespace rnoh {
+    class SafeAreaViewComponentInstance : public BaseRNCSafeAreaViewComponentInstance,SafeAreaStackNodeDelegate {
+    
+    using super = BaseRNCSafeAreaViewComponentInstance;
+    
+    struct ParentNodeInfo {
+        ArkUI_NodeHandle nodeHandle = nullptr;
+        bool hasSafeAreaProvider = false;
+    };
+    
+    private:
+        SafeAreaStackNode m_safeAreaViewStackNode;
+        bool m_isFirstShow = true;
+        SharedConcreteProps m_SharedConcreteProps;
+    public:
+        SafeAreaViewComponentInstance(Context context);
+
+        void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override;
+
+        void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override;
+
+        void onPropsChanged(SharedConcreteProps const &props) override;
+
+        SafeAreaStackNode &getLocalRootArkUINode() override;
+
+        void updateInsert(SharedConcreteProps p);
+    
+        void onAppear() override;
+    
+        ParentNodeInfo findParentNodeHandle(ArkUI_NodeHandle nodehandle);
+    };
+} // namespace rnoh

package/harmony/safe_area/src/main/cpp/SafeAreaViewPackage.h

@@ -0,0 +1,60 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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 "RNOH/Package.h"
+#include "generated/RNOH/generated/BaseReactNativeSafeAreaContextPackage.h"
+#include "SafeAreaViewComponentInstance.h"
+#include "SafeAreaProviderComponentInstance.h"
+
+using namespace rnoh;
+using namespace facebook;
+
+namespace rnoh {
+
+class SafeAreaPackageComponentInstanceFactoryDelegate : public ComponentInstanceFactoryDelegate {
+public:
+    using ComponentInstanceFactoryDelegate::ComponentInstanceFactoryDelegate;
+
+    ComponentInstance::Shared create(ComponentInstance::Context ctx) override {
+        if (ctx.componentName == "RNCSafeAreaProvider") {
+            return std::make_shared<SafeAreaProviderComponentInstance>(std::move(ctx));
+        } else if (ctx.componentName == "RNCSafeAreaView") {
+            return std::make_shared<SafeAreaViewComponentInstance>(std::move(ctx));
+        }
+        return nullptr;
+    }
+};
+
+    class SafeAreaViewPackage : public BaseReactNativeSafeAreaContextPackage {
+        using Super = BaseReactNativeSafeAreaContextPackage;
+
+    public:
+        SafeAreaViewPackage(Package::Context ctx) : Super(ctx) {}
+    
+        ComponentInstanceFactoryDelegate::Shared createComponentInstanceFactoryDelegate() override {
+            return std::make_shared<SafeAreaPackageComponentInstanceFactoryDelegate>();
+        }
+
+    };
+} // namespace rnoh

package/harmony/safe_area/src/main/cpp/TurboModuleRequest.cpp

@@ -0,0 +1,63 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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 "TurboModuleRequest.h"
+
+safeArea::Event TurboModuleRequest::getTurboModuleData(rnoh::ComponentInstance::Dependencies::Shared deps) {
+    safeArea::Event data = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+    auto rnInstancePtr = deps->rnInstance.lock();
+    folly::dynamic result1;
+    if (rnInstancePtr != nullptr) {
+        auto turboModule = rnInstancePtr->getTurboModule("RNCSafeAreaContext");
+        auto arkTsTurboModule = std::dynamic_pointer_cast<rnoh::ArkTSTurboModule>(turboModule);
+        result1 = arkTsTurboModule->callSync("getConstants", {});
+        DLOG(INFO) << "[safeArea] <SafeAreaViewComponentInstance::setProps> initialWindowMetrics: x:"
+                  << result1["initialWindowMetrics"]["frame"]["x"].asDouble();
+        DLOG(INFO) << "[safeArea] <SafeAreaViewComponentInstance::setProps> initialWindowMetrics: y:"
+                  << result1["initialWindowMetrics"]["frame"]["y"].asDouble();
+        DLOG(INFO) << "[safeArea] <SafeAreaViewComponentInstance::setProps> initialWindowMetrics: width:"
+                  << result1["initialWindowMetrics"]["frame"]["width"].asDouble();
+        DLOG(INFO) << "[safeArea] <SafeAreaViewComponentInstance::setProps> initialWindowMetrics: height:"
+                  << result1["initialWindowMetrics"]["frame"]["height"].asDouble();
+        DLOG(INFO) << "[safeArea] <SafeAreaViewComponentInstance::setProps> initialWindowMetrics: top:"
+                  << result1["initialWindowMetrics"]["insets"]["top"].asDouble();
+        DLOG(INFO) << "[safeArea] <SafeAreaViewComponentInstance::setProps> initialWindowMetrics: right:"
+                  << result1["initialWindowMetrics"]["insets"]["right"].asDouble();
+        DLOG(INFO) << "[safeArea] <SafeAreaViewComponentInstance::setProps> initialWindowMetrics: bottom:"
+                  << result1["initialWindowMetrics"]["insets"]["bottom"].asDouble();
+        DLOG(INFO) << "[safeArea] <SafeAreaViewComponentInstance::setProps> initialWindowMetrics: left:"
+                  << result1["initialWindowMetrics"]["insets"]["left"].asDouble();
+        double_t frameX = result1["initialWindowMetrics"]["frame"]["x"].asDouble();
+        double_t frameY = result1["initialWindowMetrics"]["frame"]["y"].asDouble();
+        double_t frameWidth = result1["initialWindowMetrics"]["frame"]["width"].asDouble();
+        double_t frameHeight = result1["initialWindowMetrics"]["frame"]["height"].asDouble();
+        double_t insetsTop = result1["initialWindowMetrics"]["insets"]["top"].asDouble();
+        double_t insetsRight = result1["initialWindowMetrics"]["insets"]["right"].asDouble();
+        double_t insetsBottom = result1["initialWindowMetrics"]["insets"]["bottom"].asDouble();
+        double_t insetsLeft = result1["initialWindowMetrics"]["insets"]["left"].asDouble();
+
+        data = {{insetsTop, insetsRight, insetsBottom, insetsLeft}, {frameX, frameY, frameWidth, frameHeight}};
+    }
+    return data;
+};

package/harmony/safe_area/src/main/cpp/TurboModuleRequest.h

@@ -0,0 +1,33 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 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_TURBOMODULEREQUEST_H
+#define HARMONY_TURBOMODULEREQUEST_H
+#include "RNOH/CppComponentInstance.h"
+#include "SafeAreaBeanData.h"
+class TurboModuleRequest {
+public:
+    safeArea::Event getTurboModuleData(rnoh::ComponentInstance::Dependencies::Shared deps);
+};
+
+#endif // HARMONY_TURBOMODULEREQUEST_H