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

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

@@ -0,0 +1,103 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 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;
+    }
+}
+}

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

@@ -0,0 +1,58 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 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 SAFEAREAVIEWCOMPONENTINSTANCE_H
+#define SAFEAREAVIEWCOMPONENTINSTANCE_H
+#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:
+        explicit 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
+#endif

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

@@ -0,0 +1,60 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 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 SAFEAREAVIEWPACKAGE_H
+#define SAFEAREAVIEWPACKAGE_H
+#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>();
+        }
+    };
+}
+#endif

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

@@ -0,0 +1,63 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 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,32 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 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

package/harmony/safe_area/src/main/cpp/generated/RNOH/generated/BaseReactNativeSafeAreaContextPackage.h

@@ -0,0 +1,75 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+#ifndef BASEREACTNATIVESAFEAREACONTEXTPACKAGE_H
+#define BASEREACTNATIVESAFEAREACONTEXTPACKAGE_H
+#pragma once
+#include <react/renderer/components/react_native_safe_area_context/ComponentDescriptors.h>
+#include "RNOH/Package.h"
+#include "RNOH/ArkTSTurboModule.h"
+#include "RNOH/generated/turbo_modules/RNCSafeAreaContext.h"
+#include "RNOH/generated/components/RNCSafeAreaViewJSIBinder.h"
+#include "RNOH/generated/components/RNCSafeAreaProviderJSIBinder.h"
+
+namespace rnoh {
+
+class BaseReactNativeSafeAreaContextPackageTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override
+    {
+        if (name == "RNCSafeAreaContext") {
+            return std::make_shared<RNCSafeAreaContext>(ctx, name);
+        }
+        return nullptr;
+    };
+};
+
+class BaseReactNativeSafeAreaContextPackageEventEmitRequestHandler : public EventEmitRequestHandler {
+public:
+    void handleEvent(Context const &ctx) override
+    {
+        auto eventEmitter = ctx.shadowViewRegistry->getEventEmitter<facebook::react::EventEmitter>(ctx.tag);
+        if (eventEmitter == nullptr) {
+            return;
+        }
+        std::vector<std::string> supportedEventNames = {
+        };
+        if (std::find(supportedEventNames.begin(),
+            supportedEventNames.end(), ctx.eventName) != supportedEventNames.end()) {
+            eventEmitter->dispatchEvent(ctx.eventName, ArkJS(ctx.env).getDynamic(ctx.payload));
+        }
+    }
+};
+
+class BaseReactNativeSafeAreaContextPackage : public Package {
+public:
+    BaseReactNativeSafeAreaContextPackage(Package::Context ctx) : Package(ctx){};
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override
+    {
+        return std::make_unique<BaseReactNativeSafeAreaContextPackageTurboModuleFactoryDelegate>();
+    }
+    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override
+    {
+        return {
+            facebook::react::concreteComponentDescriptorProvider<
+            facebook::react::RNCSafeAreaViewComponentDescriptor>(),
+            facebook::react::concreteComponentDescriptorProvider<
+            facebook::react::RNCSafeAreaProviderComponentDescriptor>(),
+        };
+    }
+    ComponentJSIBinderByString createComponentJSIBinderByName() override
+    {
+        return {
+            {"RNCSafeAreaView", std::make_shared<RNCSafeAreaViewJSIBinder>()},
+            {"RNCSafeAreaProvider", std::make_shared<RNCSafeAreaProviderJSIBinder>()},
+        };
+    };
+    EventEmitRequestHandlers createEventEmitRequestHandlers() override
+    {
+        return {
+            std::make_shared<BaseReactNativeSafeAreaContextPackageEventEmitRequestHandler>(),
+        };
+    }
+};
+}
+#endif

package/harmony/safe_area/src/main/cpp/generated/RNOH/generated/components/BaseRNCSafeAreaProviderComponentInstance.h

@@ -0,0 +1,19 @@
+
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+#ifndef BASERNCSAFEAREAPROVIDERCOMPONENTINSTANCE_H
+#define BASERNCSAFEAREAPROVIDERCOMPONENTINSTANCE_H
+#pragma once
+
+#include "RNOH/CppComponentInstance.h"
+#include <react/renderer/components/react_native_safe_area_context/ShadowNodes.h>
+
+namespace rnoh {
+    class BaseRNCSafeAreaProviderComponentInstance
+        : public CppComponentInstance<facebook::react::RNCSafeAreaProviderShadowNode> {
+    public:
+        using CppComponentInstance::CppComponentInstance;
+    };
+}
+#endif

package/harmony/safe_area/src/main/cpp/generated/RNOH/generated/components/BaseRNCSafeAreaViewComponentInstance.h

@@ -0,0 +1,19 @@
+
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+#ifndef BASERNCSAFEAREAVIEWCOMPONENTINSTANCE_H
+#define BASERNCSAFEAREAVIEWCOMPONENTINSTANCE_H
+#pragma once
+
+#include "RNOH/CppComponentInstance.h"
+#include <react/renderer/components/react_native_safe_area_context/ShadowNodes.h>
+
+namespace rnoh {
+    class BaseRNCSafeAreaViewComponentInstance
+        : public CppComponentInstance<facebook::react::RNCSafeAreaViewShadowNode> {
+    public:
+        using CppComponentInstance::CppComponentInstance;
+    };
+} // namespace rnoh
+#endif

package/harmony/safe_area/src/main/cpp/generated/RNOH/generated/components/RNCSafeAreaProviderJSIBinder.h

@@ -0,0 +1,28 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#pragma once
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class RNCSafeAreaProviderJSIBinder : public ViewComponentJSIBinder {
+  protected:
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override
+    {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        return object;
+    }
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override
+    {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override
+    {
+        facebook::jsi::Object events(rt);
+        events.setProperty(rt, "topInsetsChange", createDirectEvent(rt, "onInsetsChange"));
+        return events;
+    }
+};
+}

package/harmony/safe_area/src/main/cpp/generated/RNOH/generated/components/RNCSafeAreaViewJSIBinder.h

@@ -0,0 +1,33 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#pragma once
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class RNCSafeAreaViewJSIBinder : public ViewComponentJSIBinder {
+  protected:
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override
+    {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "mode", true);
+        object.setProperty(rt, "edges", "Object");
+        object.setProperty(rt, "isFirstRefresh", true);
+        return object;
+    }
+
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override
+    {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override
+    {
+        facebook::jsi::Object events(rt);
+        events.setProperty(rt, "topSafeAreaValueChange", createDirectEvent(rt, "onSafeAreaValueChange"));
+        return events;
+    }
+};
+} // namespace rnoh

package/harmony/safe_area/src/main/cpp/generated/RNOH/generated/turbo_modules/RNCSafeAreaContext.cpp

@@ -0,0 +1,17 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#include "RNCSafeAreaContext.h"
+
+namespace rnoh {
+using namespace facebook;
+
+RNCSafeAreaContext::RNCSafeAreaContext(const ArkTSTurboModule::Context ctx,
+    const std::string name) : ArkTSTurboModule(ctx, name)
+{
+    methodMap_ = {
+        ARK_METHOD_METADATA(getConstants, 0),
+    };
+}
+} // namespace rnoh

package/harmony/safe_area/src/main/cpp/generated/RNOH/generated/turbo_modules/RNCSafeAreaContext.h

@@ -0,0 +1,15 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#pragma once
+
+#include "RNOH/ArkTSTurboModule.h"
+
+namespace rnoh {
+
+class JSI_EXPORT RNCSafeAreaContext : public ArkTSTurboModule {
+public:
+    RNCSafeAreaContext(const ArkTSTurboModule::Context ctx, const std::string name);
+};
+} // namespace rnoh

package/harmony/safe_area/src/main/cpp/generated/react/renderer/components/react_native_safe_area_context/ComponentDescriptors.h

@@ -0,0 +1,21 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateComponentDescriptorH.js
+ */
+
+#pragma once
+
+#include <react/renderer/components/react_native_safe_area_context/ShadowNodes.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+    using RNCSafeAreaProviderComponentDescriptor = ConcreteComponentDescriptor<RNCSafeAreaProviderShadowNode>;
+    using RNCSafeAreaViewComponentDescriptor = ConcreteComponentDescriptor<RNCSafeAreaViewShadowNode>;
+} // namespace react
+} // namespace facebook

package/harmony/safe_area/src/main/cpp/generated/react/renderer/components/react_native_safe_area_context/EventEmitters.cpp

@@ -0,0 +1,57 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateEventEmitterCpp.js
+ */
+
+#include <react/renderer/components/react_native_safe_area_context/EventEmitters.h>
+
+
+namespace facebook {
+namespace react {
+
+void RNCSafeAreaViewEventEmitter::onSafeAreaValueChange(OnSafeAreaValueChange $event) const
+{
+    dispatchEvent("safeAreaValueChange", [$event = std::move($event)](jsi::Runtime &runtime) {
+        auto $payload = jsi::Object(runtime);
+        {
+            auto safeAreaViewInsetsValue = jsi::Object(runtime);
+            safeAreaViewInsetsValue.setProperty(runtime, "top", $event.safeAreaViewInsetsValue.top);
+            safeAreaViewInsetsValue.setProperty(runtime, "left", $event.safeAreaViewInsetsValue.left);
+            safeAreaViewInsetsValue.setProperty(runtime, "bottom", $event.safeAreaViewInsetsValue.bottom);
+            safeAreaViewInsetsValue.setProperty(runtime, "right", $event.safeAreaViewInsetsValue.right);
+            $payload.setProperty(runtime, "safeAreaViewInsetsValue", safeAreaViewInsetsValue);
+        }
+        return $payload;
+    });
+}
+
+void RNCSafeAreaProviderEventEmitter::onInsetsChange(OnInsetsChange $event) const
+{
+    dispatchEvent("insetsChange", [$event = std::move($event)](jsi::Runtime &runtime) {
+        auto $payload = jsi::Object(runtime);
+        {
+            auto insets = jsi::Object(runtime);
+            insets.setProperty(runtime, "top", $event.insets.top);
+            insets.setProperty(runtime, "right", $event.insets.right);
+            insets.setProperty(runtime, "bottom", $event.insets.bottom);
+            insets.setProperty(runtime, "left", $event.insets.left);
+            $payload.setProperty(runtime, "insets", insets);
+        }
+        {
+            auto frame = jsi::Object(runtime);
+            frame.setProperty(runtime, "x", $event.frame.x);
+            frame.setProperty(runtime, "y", $event.frame.y);
+            frame.setProperty(runtime, "width", $event.frame.width);
+            frame.setProperty(runtime, "height", $event.frame.height);
+            $payload.setProperty(runtime, "frame", frame);
+        }
+        return $payload;
+});
+}
+}
+}