@react-native-ohos/react-native-pager-view 6.2.4-rc.4

package/harmony/pager_view/src/main/cpp/ViewPagerComponentInstance.cpp

@@ -0,0 +1,247 @@
+/**
+ * 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 "ViewPagerComponentInstance.h"
+#include <arkui/native_gesture.h>
+#include <arkui/native_interface.h>
+#define DURATION_MILLISECONDS 400
+
+namespace rnoh {
+
+ViewPagerComponentInstance::ViewPagerComponentInstance(Context context)
+    : BaseRNCViewPagerComponentInstance(std::move(context))
+{
+    m_swiperNode.setSwiperNodeDelegate(this);
+    this->regsiterGestureEvent();
+}
+
+void ViewPagerComponentInstance::onChildInserted(ComponentInstance::Shared const &childComponentInstance,
+    std::size_t index)
+{
+    super::onChildInserted(childComponentInstance, index);
+    m_swiperNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index);
+}
+
+SwiperNode &ViewPagerComponentInstance::getLocalRootArkUINode() { return m_swiperNode; }
+
+void ViewPagerComponentInstance::onChildRemoved(ComponentInstance::Shared const &childComponentInstance)
+{
+    super::onChildRemoved(childComponentInstance);
+    m_swiperNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+};
+
+void ViewPagerComponentInstance::onPropsChanged(SharedConcreteProps const &props)
+{
+    super::onPropsChanged(props);
+    DLOG(INFO) << "ViewPagerComponentInstance::onPropsChanged: initialPage:" << props->initialPage
+        << " scrollEnabled:" << props->scrollEnabled << " orientation:" << facebook::react::toString(props->orientation)
+        << " keyboardDismissMode:" << facebook::react::toString(props->keyboardDismissMode)
+        << " layoutDirection:" << facebook::react::toString(props->layoutDirection)
+        << " pageMargin:" << props->pageMargin << " offscreenPageLimit:" << props->offscreenPageLimit
+        << " overdrag:" << props->overdrag << " overScrollMode:" << facebook::react::toString(props->overScrollMode);
+    this->m_scrollEnabled = props->scrollEnabled;
+    if (this->m_isInitialPage) this->m_pageIndex = props->initialPage;
+    this->m_keyboardDismissMode = facebook::react::toString(props->keyboardDismissMode);
+    this->getLocalRootArkUINode().setVertical(facebook::react::toString(props->orientation));
+    this->getLocalRootArkUINode().setDirection(facebook::react::toString(props->layoutDirection));
+    this->getLocalRootArkUINode().setItemSpace(props->pageMargin);
+    this->getLocalRootArkUINode().setDisableSwipe(!props->scrollEnabled);
+    this->getLocalRootArkUINode().setLoop(false);
+    this->getLocalRootArkUINode().setIndicator(false);
+    this->getLocalRootArkUINode().setCachedCount(props->offscreenPageLimit);
+    this->getLocalRootArkUINode().setCurve(ARKUI_CURVE_SMOOTH);
+    this->getLocalRootArkUINode().setDuration(DURATION_MILLISECONDS);
+    if (props->overdrag) {
+        this->getLocalRootArkUINode().setEffectMode("SPRING");
+    } else {
+        if (facebook::react::toString(props->overScrollMode) == "never") {
+            this->getLocalRootArkUINode().setEffectMode("NONE");
+        } else {
+            this->getLocalRootArkUINode().setEffectMode("FADE");
+        }
+    }
+}
+
+void ViewPagerComponentInstance::onPageSelected(double pageIndex)
+{
+    this->m_pageIndex = pageIndex;
+    DLOG(INFO) << "ViewPagerComponentInstance::onPageSelected:" << pageIndex;
+    facebook::react::RNCViewPagerEventEmitter::OnPageSelected event = {pageIndex};
+    m_eventEmitter->onPageSelected(event);
+}
+
+void ViewPagerComponentInstance::onPageScroll(
+    facebook::react::RNCViewPagerEventEmitter::OnPageScroll pageScroll)
+{
+    DLOG(INFO) << "ViewPagerComponentInstance::onPageScroll";
+    m_eventEmitter->onPageScroll(pageScroll);
+}
+
+void ViewPagerComponentInstance::onPageScrollStateChanged(
+    facebook::react::RNCViewPagerEventEmitter::OnPageScrollStateChanged value)
+{
+    DLOG(INFO) << "ViewPagerComponentInstance::onPageScrollStateChanged";
+    m_eventEmitter->onPageScrollStateChanged(value);
+}
+
+void ViewPagerComponentInstance::handleCommand(std::string const &commandName,
+    folly::dynamic const &args)
+{
+    DLOG(INFO) << "handleCommand-->commandName: " << commandName;
+    if (commandName == "setScrollEnabledImperatively" && args.isArray() && args.size() == 1) {
+        DLOG(INFO) << "handleCommand-->setScrollEnabledImperatively: " << args[0];
+        this->m_scrollEnabled = args[0].asBool();
+        this->getLocalRootArkUINode().setDisableSwipe(!args[0].asBool());
+        if (!args[0].asBool()) {
+            facebook::react::RNCViewPagerEventEmitter::OnPageScrollStateChanged event = {
+                facebook::react::RNCViewPagerEventEmitter::OnPageScrollStateChangedPageScrollState::IDLE};
+            m_eventEmitter->onPageScrollStateChanged(event);
+        }
+    } else if (commandName == "setPage" && args.isArray() && args.size() == 1) {
+        this->m_clickTap = true;
+        DLOG(INFO) << "handleCommand-->setPage: " << args[0];
+        this->getLocalRootArkUINode().setIndex(args[0].asInt());
+    } else if (commandName == "setPageWithoutAnimation" && args.isArray() && args.size() == 1) {
+        DLOG(INFO) << "handleCommand-->setPageWithoutAnimation: " << args[0];
+        this->m_clickTap = true;
+        this->getLocalRootArkUINode().setIndexNoAnimation(args[0].asInt());
+    }
+}
+
+bool ViewPagerComponentInstance::getScrollEnabled() { return this->m_scrollEnabled; }
+
+bool ViewPagerComponentInstance::getNativeLock() { return this->m_nativeLock; }
+
+std::vector<TouchTarget::Shared> ViewPagerComponentInstance::getTouchTargetChildren()
+{
+    auto children = getChildren();
+    std::vector<TouchTarget::Shared> result;
+    result.push_back(children.at(m_pageIndex));
+    return result;
+}
+
+void ViewPagerComponentInstance::setKeyboardDismiss()
+{
+    DLOG(INFO) << "ViewPagerComponentInstance::setKeyboardDismiss: " << this->m_keyboardDismissMode;
+    if (this->m_keyboardDismissMode != "on-drag") {
+        return;
+    }
+    auto rnInstancePtr = this->m_deps->rnInstance.lock();
+    if (rnInstancePtr != nullptr) {
+        auto turboModule = rnInstancePtr->getTurboModule("RNCViewPagerContext");
+        auto arkTsTurboModule = std::dynamic_pointer_cast<rnoh::ArkTSTurboModule>(turboModule);
+        arkTsTurboModule->callSync("keyboardDismiss", {});
+    }
+}
+
+void ViewPagerComponentInstance::onNativeResponderBlockChange(bool isBlocked)
+{
+    DLOG(INFO) << "ViewPagerComponentInstance::setNativeResponderBlocked:" << isBlocked;
+    if (isBlocked) {
+        this->m_nativeLock = true;
+        this->getLocalRootArkUINode().setDisableSwipe(true);
+        facebook::react::RNCViewPagerEventEmitter::OnPageScrollStateChanged event = {
+            facebook::react::RNCViewPagerEventEmitter::OnPageScrollStateChangedPageScrollState::IDLE};
+        m_eventEmitter->onPageScrollStateChanged(event);
+    } else {
+        this->m_nativeLock = false;
+        if (!this->m_scrollEnabled) {
+            return;
+        }
+        this->getLocalRootArkUINode().setDisableSwipe(false);
+    }
+}
+
+void ViewPagerComponentInstance::setGestureStatus(bool gestureStatus)
+{
+    this->m_gestureStatus = gestureStatus;
+    DLOG(INFO) << "ViewPagerComponentInstance::setGestureStatus:" << gestureStatus;
+}
+
+bool ViewPagerComponentInstance::isHandlingTouches() const
+{
+    DLOG(INFO) << "ViewPagerComponentInstance::isHandlingTouches:" << this->m_gestureStatus;
+    return this->m_gestureStatus;
+}
+
+void ViewPagerComponentInstance::regsiterGestureEvent()
+{
+    DLOG(INFO) << "ViewPagerComponentInstance::regsiterGestureEvent";
+    auto gestureApi = OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_GESTURE, "ArkUI_NativeGestureAPI_1");
+    auto swiperGestureApi = reinterpret_cast<ArkUI_NativeGestureAPI_1 *>(gestureApi);
+    auto swiperGestureRecognizer = swiperGestureApi->createPanGesture(1, GESTURE_DIRECTION_ALL, 50);
+    auto onPanActionCallBack = [](ArkUI_GestureEvent *event, void *extraParam) {
+        PanActionCallBack *panActionCallBack = (PanActionCallBack *)extraParam;
+        ArkUI_GestureEventActionType actionType = OH_ArkUI_GestureEvent_GetActionType(event);
+        if (actionType == GESTURE_EVENT_ACTION_END) {
+            DLOG(INFO) << "ViewPagerComponentInstance::regsiterGestureEvent GESTURE_EVENT_ACTION_END";
+            panActionCallBack->swiperNodeDelegate->setGestureStatus(false);
+        }
+    };
+    PanActionCallBack *panActionCallBack = new PanActionCallBack{
+        .swiperNodeDelegate = this,
+    };
+    swiperGestureApi->setGestureEventTarget(
+        swiperGestureRecognizer, GESTURE_EVENT_ACTION_ACCEPT | GESTURE_EVENT_ACTION_UPDATE | GESTURE_EVENT_ACTION_END,
+        panActionCallBack, onPanActionCallBack);
+    swiperGestureApi->addGestureToNode(this->getLocalRootArkUINode().getArkUINodeHandle(), swiperGestureRecognizer,
+        PARALLEL, NORMAL_GESTURE_MASK);
+}
+
+bool ViewPagerComponentInstance::getClickTap() { return this->m_clickTap; }
+
+void ViewPagerComponentInstance::setClickTap(bool clickTap) { this->m_clickTap = clickTap; }
+
+void ViewPagerComponentInstance::sendEventAnimationsPageScroll(
+    facebook::react::RNCViewPagerEventEmitter::OnPageScroll pageScroll)
+{
+    auto nativeAnimatedTurboModule = m_swiperNativeAnimatedTurboModule.lock();
+    if (nativeAnimatedTurboModule == nullptr) {
+        auto instance = m_deps->rnInstance.lock();
+        if (instance == nullptr) {
+            return;
+        }
+        nativeAnimatedTurboModule = instance->getTurboModule<NativeAnimatedTurboModule>("NativeAnimatedTurboModule");
+        m_swiperNativeAnimatedTurboModule = nativeAnimatedTurboModule;
+    }
+    if (nativeAnimatedTurboModule != nullptr) {
+        using folly::dynamic;
+        dynamic payload = dynamic::object("position", pageScroll.position)("offset", pageScroll.offset);
+        nativeAnimatedTurboModule->handleComponentEvent(m_tag, "onPageScroll", payload);
+        DLOG(INFO) << "ViewPagerComponentInstance::sendEventAnimationsPageScroll position "
+            << pageScroll.position
+            << " offset " << pageScroll.offset;
+    }
+}
+
+void ViewPagerComponentInstance::onSwiperAppear()
+{
+    DLOG(INFO) << "ViewPagerComponentInstance onSwiperAppear m_isInitialPage:"
+        << this->m_isInitialPage << " m_pageIndex:" << this->m_pageIndex;
+    if (this->m_isInitialPage) {
+        this->m_isInitialPage = false;
+        this->getLocalRootArkUINode().setIndexNoAnimation(this->m_pageIndex);
+    }
+}
+} // namespace rnoh

package/harmony/pager_view/src/main/cpp/ViewPagerComponentInstance.h

@@ -0,0 +1,106 @@
+/**
+ * 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 VIEWPAGERCOMPONENTINSTANCE_H
+#define VIEWPAGERCOMPONENTINSTANCE_H
+#pragma once
+#include "SwiperNode.h"
+#include <folly/dynamic.h>
+#include "RNOHCorePackage/TurboModules/Animated/NativeAnimatedTurboModule.h"
+#include "generated/RNOH/generated/components/BaseRNCViewPagerComponentInstance.h"
+
+namespace rnoh {
+class ViewPagerComponentInstance : public BaseRNCViewPagerComponentInstance, public SwiperNodeDelegate {
+
+    using super = BaseRNCViewPagerComponentInstance;
+
+private:
+    SwiperNode m_swiperNode;
+
+    double m_pageIndex;
+
+    bool m_scrollEnabled = false;
+
+    bool m_nativeLock = false;
+
+    std::string m_keyboardDismissMode;
+    
+    bool m_gestureStatus = false;
+
+    bool m_clickTap = false;
+
+    bool m_gestureSwipe = false;
+    
+    bool m_isInitialPage = true;
+
+    struct PanActionCallBack {
+        SwiperNodeDelegate *swiperNodeDelegate;
+    };
+
+    std::weak_ptr<NativeAnimatedTurboModule> m_swiperNativeAnimatedTurboModule{};
+
+public:
+    explicit ViewPagerComponentInstance(Context context);
+
+    void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override;
+
+    void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override;
+
+    SwiperNode &getLocalRootArkUINode() override;
+
+    void onPropsChanged(SharedConcreteProps const &props) override;
+
+    void onPageSelected(double pageIndex) override;
+
+    void onPageScroll(facebook::react::RNCViewPagerEventEmitter::OnPageScroll pageScroll) override;
+
+    void onPageScrollStateChanged(facebook::react::RNCViewPagerEventEmitter::OnPageScrollStateChanged value) override;
+
+    void handleCommand(std::string const &commandName, folly::dynamic const &args) override;
+
+    std::vector<TouchTarget::Shared> getTouchTargetChildren() override;
+
+    bool getScrollEnabled() override;
+
+    bool getNativeLock() override;
+
+    void setKeyboardDismiss() override;
+
+    void onNativeResponderBlockChange(bool isBlocked) override;
+
+    void setGestureStatus(bool gestureStatus) override;
+
+    bool isHandlingTouches() const override;
+
+    bool getClickTap() override;
+
+    void setClickTap(bool clickTap) override;
+
+    void regsiterGestureEvent();
+
+    void sendEventAnimationsPageScroll(facebook::react::RNCViewPagerEventEmitter::OnPageScroll pageScroll) override;
+    
+    void onSwiperAppear() override;
+};
+} // namespace rnoh
+#endif

package/harmony/pager_view/src/main/cpp/ViewPagerPackage.h

@@ -0,0 +1,64 @@
+/**
+ * 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_PAGERVIEW_SRC_MAIN_CPP_VIEWPAGERPACKAGE_H
+#define HARMONY_PAGERVIEW_SRC_MAIN_CPP_VIEWPAGERPACKAGE_H
+#include "ViewPagerComponentInstance.h"
+#include "RNCViewPagerTurbomodule.h"
+#include "generated/RNOH/generated/BaseReactNativePagerViewPackage.h"
+using namespace rnoh;
+using namespace facebook;
+namespace rnoh {
+
+class RNCViewPagerContextFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override
+    {
+        if (name == "RNCViewPagerContext") {
+            return std::make_shared<RNCViewPagerTurbomodule>(ctx, name);
+        }
+        return nullptr;
+    };
+};
+
+class ViewPagerPackage : public BaseReactNativePagerViewPackage {
+    using Super = BaseReactNativePagerViewPackage;
+
+public:
+    ViewPagerPackage(Package::Context ctx) : Super(ctx) {}
+
+    ComponentInstance::Shared createComponentInstance(const ComponentInstance::Context &ctx)
+    {
+        if (ctx.componentName == "RNCViewPager") {
+            return std::make_shared<ViewPagerComponentInstance>(ctx);
+        }
+        return nullptr;
+    };
+
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override
+    {
+        return std::make_unique<RNCViewPagerContextFactoryDelegate>();
+    }
+};
+} // namespace rnoh
+#endif

package/harmony/pager_view/src/main/cpp/generated/RNOH/generated/BaseReactNativePagerViewPackage.h

@@ -0,0 +1,70 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+#pragma once
+
+#include <react/renderer/components/react_native_pager_view/ComponentDescriptors.h>
+#include "RNOH/Package.h"
+#include "RNOH/ArkTSTurboModule.h"
+#include "RNOH/generated/components/RNCViewPagerJSIBinder.h"
+
+namespace rnoh {
+
+class BaseReactNativePagerViewPackageTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override
+    {
+        return nullptr;
+    };
+};
+
+class BaseReactNativePagerViewPackageEventEmitRequestHandler : 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 BaseReactNativePagerViewPackage : public Package {
+  public:
+    BaseReactNativePagerViewPackage(Package::Context ctx) : Package(ctx){};
+
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override
+    {
+        return std::make_unique<BaseReactNativePagerViewPackageTurboModuleFactoryDelegate>();
+    }
+
+    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override
+    {
+        return {
+            facebook::react::concreteComponentDescriptorProvider<facebook::react::RNCViewPagerComponentDescriptor>(),
+        };
+    }
+
+    ComponentJSIBinderByString createComponentJSIBinderByName() override
+    {
+        return {
+            {"RNCViewPager", std::make_shared<RNCViewPagerJSIBinder>()},
+        };
+    };
+
+    EventEmitRequestHandlers createEventEmitRequestHandlers() override
+    {
+        return {
+            std::make_shared<BaseReactNativePagerViewPackageEventEmitRequestHandler>(),
+        };
+    }
+};
+
+} // namespace rnoh

package/harmony/pager_view/src/main/cpp/generated/RNOH/generated/components/BaseRNCViewPagerComponentInstance.h

@@ -0,0 +1,16 @@
+
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+#pragma once
+
+#include "RNOH/CppComponentInstance.h"
+#include <react/renderer/components/react_native_pager_view/ShadowNodes.h>
+
+namespace rnoh {
+    class BaseRNCViewPagerComponentInstance
+        : public CppComponentInstance<facebook::react::RNCViewPagerShadowNode> {
+    public:
+        using CppComponentInstance::CppComponentInstance;
+    };
+} // namespace rnoh

package/harmony/pager_view/src/main/cpp/generated/RNOH/generated/components/RNCViewPagerJSIBinder.h

@@ -0,0 +1,41 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#pragma once
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class RNCViewPagerJSIBinder : public ViewComponentJSIBinder {
+  protected:
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override
+    {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "scrollEnabled", true);
+        object.setProperty(rt, "layoutDirection", true);
+        object.setProperty(rt, "initialPage", true);
+        object.setProperty(rt, "orientation", true);
+        object.setProperty(rt, "offscreenPageLimit", true);
+        object.setProperty(rt, "pageMargin", true);
+        object.setProperty(rt, "overScrollMode", true);
+        object.setProperty(rt, "overdrag", true);
+        object.setProperty(rt, "keyboardDismissMode", 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, "topPageScroll", createDirectEvent(rt, "onPageScroll"));
+        events.setProperty(rt, "topPageSelected", createDirectEvent(rt, "onPageSelected"));
+        events.setProperty(rt, "topPageScrollStateChanged", createDirectEvent(rt, "onPageScrollStateChanged"));
+        return events;
+    }
+};
+} // namespace rnoh

package/harmony/pager_view/src/main/cpp/generated/react/renderer/components/react_native_pager_view/ComponentDescriptors.h

@@ -0,0 +1,22 @@
+
+/**
+ * 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_pager_view/ShadowNodes.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+
+using RNCViewPagerComponentDescriptor = ConcreteComponentDescriptor<RNCViewPagerShadowNode>;
+
+} // namespace react
+} // namespace facebook

package/harmony/pager_view/src/main/cpp/generated/react/renderer/components/react_native_pager_view/EventEmitters.cpp

@@ -0,0 +1,43 @@
+
+/**
+ * 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_pager_view/EventEmitters.h>
+
+
+namespace facebook {
+namespace react {
+
+void RNCViewPagerEventEmitter::onPageScroll(OnPageScroll $event) const
+{
+    dispatchEvent("pageScroll", [$event = std::move($event)](jsi::Runtime &runtime) {
+        auto $payload = jsi::Object(runtime);
+        $payload.setProperty(runtime, "position", $event.position);
+        $payload.setProperty(runtime, "offset", $event.offset);
+        return $payload;
+    });
+}
+void RNCViewPagerEventEmitter::onPageSelected(OnPageSelected $event) const
+{
+    dispatchEvent("pageSelected", [$event = std::move($event)](jsi::Runtime &runtime) {
+        auto $payload = jsi::Object(runtime);
+        $payload.setProperty(runtime, "position", $event.position);
+        return $payload;
+    });
+}
+void RNCViewPagerEventEmitter::onPageScrollStateChanged(OnPageScrollStateChanged $event) const
+{
+    dispatchEvent("pageScrollStateChanged", [$event = std::move($event)](jsi::Runtime &runtime) {
+        auto $payload = jsi::Object(runtime);
+        $payload.setProperty(runtime, "pageScrollState", toString($event.pageScrollState));
+        return $payload;
+    });
+}
+} // namespace react
+} // namespace facebook

package/harmony/pager_view/src/main/cpp/generated/react/renderer/components/react_native_pager_view/EventEmitters.h

@@ -0,0 +1,47 @@
+
+/**
+ * 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: GenerateEventEmitterH.js
+ */
+#pragma once
+
+#include <react/renderer/components/view/ViewEventEmitter.h>
+
+namespace facebook {
+namespace react {
+class RNCViewPagerEventEmitter : public ViewEventEmitter {
+public:
+    using ViewEventEmitter::ViewEventEmitter;
+    struct OnPageScroll {
+        double position;
+        double offset;
+    };
+    struct OnPageSelected {
+        double position;
+    };
+    enum class OnPageScrollStateChangedPageScrollState {
+        IDLE,
+        DRAGGING,
+        SETTLING
+    };
+    static char const *toString(const OnPageScrollStateChangedPageScrollState value)
+    {
+        switch (value) {
+            case OnPageScrollStateChangedPageScrollState::IDLE: return "idle";
+            case OnPageScrollStateChangedPageScrollState::DRAGGING: return "dragging";
+            case OnPageScrollStateChangedPageScrollState::SETTLING: return "settling";
+        }
+    }
+    struct OnPageScrollStateChanged {
+        OnPageScrollStateChangedPageScrollState pageScrollState;
+    };
+    void onPageScroll(OnPageScroll value) const;
+    void onPageSelected(OnPageSelected value) const;
+    void onPageScrollStateChanged(OnPageScrollStateChanged value) const;
+};
+} // namespace react
+} // namespace facebook